copyright, missing-sources, README.source: Exclude minified javascript that the runtime does not need. Add unminified versions of others, update copyright to match. (Closes: #787593)

debian/README.source

@@ -0,0 +1,6 @@
+freeipa
+
+Upstream does not ship unminified copies of various javascript files, so we must ship them
+in debian/missing-sources. Minified dojo.js is built with a certain set of modules, so
+those bits are under missing-sources/dojo. The list of modules are listed on
+install/ui/src/dojo.profile.js.

debian/changelog

@@ -1,3 +1,11 @@
+freeipa (4.3.1+dfsg1-1) UNRELEASED; urgency=medium
+
+  * copyright, missing-sources, README.source: Exclude minified javascript
+    that the runtime does not need. Add unminified versions of others,
+    update copyright to match. (Closes: #787593)
+
+ -- Timo Aaltonen <tjaalton@debian.org>  Mon, 18 Apr 2016 17:40:32 +0300
+
 freeipa (4.3.1-2) experimental; urgency=medium
 
   * control: python-ipalib can be arch:all now.

debian/copyright

@@ -1,6 +1,7 @@
 Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
 Upstream-name: freeipa
 Source: http://freeipa.org/downloads/src/
+Files-Excluded: install/ui/util/uglifyjs/lib/parse-js.js install/ui/util/build/build.js
 
 Files: *
 Copyright: 1999-2011 Red Hat, Inc.
@@ -57,10 +58,17 @@ Copyright: Nicolas Gallagher
 License: MIT
 
 Files: install/ui/src/libs/bootstrap.js
+       debian/missing-sources/bootstrap*.js
 Copyright: 2011-2014 Twitter, Inc.
 License: MIT
 
+Files: install/ui/src/libs/d3.js
+       debian/missing-sources/d3.js
+Copyright: 2010-2015, Michael Bostock
+License: BSD-3-clause
+
 Files: install/ui/src/libs/jquery.js
+       debian/missing-sources/jquery-2.0.3.js
 Copyright: 2005, 2013 jQuery Foundation, Inc.
 License: MIT
 
@@ -69,7 +77,13 @@ Copyright: None
 License: public-domain
  Public Domain.
 
+Files: install/ui/src/libs/patternfly.js
+       debian/missing-sources/patternfly.js
+Copyright: 2013, Red Hat
+License: Apache-2.0
+
 Files: install/ui/src/libs/qrcode.js
+       debian/missing-sources/qrcode.js
 Copyright: 2012, Shim Sangmin
 License: MIT
 
@@ -90,6 +104,7 @@ License: BSD-2-clause
 Files: install/ui/util/build/build.js
        install/ui/util/build/_base/configRhino.js
        install/ui/build/dojo/dojo.js
+       debian/missing-sources/dojo
 Copyright: 2004-2012, The Dojo Foundation
 License: BSD-3-clause or AFL-2.1
 
@@ -337,3 +352,7 @@ License: AFL-2.1
  Permission is hereby granted to copy and distribute this license without
  modification. This license may not be modified without the express written
  permission of its copyright owner.
+
+License: Apache-2.0
+ On Debian machines the full text of the Apache License 2.0 can be found in the
+ file /usr/share/common-licenses/Apache-2.0.

debian/missing-sources/dojo/Evented.js

@@ -0,0 +1,35 @@
+define(["./aspect", "./on"], function(aspect, on){
+	// module:
+	//		dojo/Evented
+
+ 	"use strict";
+ 	var after = aspect.after;
+	function Evented(){
+		// summary:
+		//		A class that can be used as a mixin or base class,
+		//		to add on() and emit() methods to a class
+		//		for listening for events and emitting events:
+		//
+		//		|	define(["dojo/Evented"], function(Evented){
+		//		|		var EventedWidget = dojo.declare([Evented, dijit._Widget], {...});
+		//		|		widget = new EventedWidget();
+		//		|		widget.on("open", function(event){
+		//		|		... do something with event
+		//		|	 });
+		//		|
+		//		|	widget.emit("open", {name:"some event", ...});
+	}
+	Evented.prototype = {
+		on: function(type, listener){
+			return on.parse(this, type, listener, function(target, type){
+				return after(target, 'on' + type, listener, true);
+			});
+		},
+		emit: function(type, event){
+			var args = [this];
+			args.push.apply(args, arguments);
+			return on.emit.apply(on, args);
+		}
+	};
+	return Evented;
+});

debian/missing-sources/dojo/NodeList-dom.js

@@ -0,0 +1,514 @@
+define(["./_base/kernel", "./query", "./_base/array", "./_base/lang", "./dom-class", "./dom-construct", "./dom-geometry", "./dom-attr", "./dom-style"], function(dojo, query, array, lang, domCls, domCtr, domGeom, domAttr, domStyle){
+
+	// module:
+	//		dojo/NodeList-dom.js
+
+	/*=====
+	 return function(){
+		 // summary:
+		 //		Adds DOM related methods to NodeList, and returns NodeList constructor.
+	 };
+	 =====*/
+
+	var magicGuard = function(a){
+		// summary:
+		//		the guard function for dojo.attr() and dojo.style()
+		return a.length == 1 && (typeof a[0] == "string"); // inline'd type check
+	};
+
+	var orphan = function(node){
+		// summary:
+		//		function to orphan nodes
+		var p = node.parentNode;
+		if(p){
+			p.removeChild(node);
+		}
+	};
+	// FIXME: should we move orphan() to dojo.html?
+
+	var NodeList = query.NodeList,
+		awc = NodeList._adaptWithCondition,
+		aafe = NodeList._adaptAsForEach,
+		aam = NodeList._adaptAsMap;
+
+	function getSet(module){
+		return function(node, name, value){
+			if(arguments.length == 2){
+				return module[typeof name == "string" ? "get" : "set"](node, name);
+			}
+			// setter
+			return module.set(node, name, value);
+		};
+	}
+
+	lang.extend(NodeList, {
+		_normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){
+			// summary:
+			//		normalizes data to an array of items to insert.
+			// description:
+			//		If content is an object, it can have special properties "template" and
+			//		"parse". If "template" is defined, then the template value is run through
+			//		dojo.string.substitute (if dojo/string.substitute() has been dojo.required elsewhere),
+			//		or if templateFunc is a function on the content, that function will be used to
+			//		transform the template into a final string to be used for for passing to dojo/dom-construct.toDom().
+			//		If content.parse is true, then it is remembered for later, for when the content
+			//		nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets
+			//		(if dojo.parser has been dojo.required elsewhere).
+
+			//Wanted to just use a DocumentFragment, but for the array/NodeList
+			//case that meant using cloneNode, but we may not want that.
+			//Cloning should only happen if the node operations span
+			//multiple refNodes. Also, need a real array, not a NodeList from the
+			//DOM since the node movements could change those NodeLists.
+
+			var parse = content.parse === true;
+
+			//Do we have an object that needs to be run through a template?
+			if(typeof content.template == "string"){
+				var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute);
+				content = templateFunc ? templateFunc(content.template, content) : content;
+			}
+
+			var type = (typeof content);
+			if(type == "string" || type == "number"){
+				content = domCtr.toDom(content, (refNode && refNode.ownerDocument));
+				if(content.nodeType == 11){
+					//DocumentFragment. It cannot handle cloneNode calls, so pull out the children.
+					content = lang._toArray(content.childNodes);
+				}else{
+					content = [content];
+				}
+			}else if(!lang.isArrayLike(content)){
+				content = [content];
+			}else if(!lang.isArray(content)){
+				//To get to this point, content is array-like, but
+				//not an array, which likely means a DOM NodeList. Convert it now.
+				content = lang._toArray(content);
+			}
+
+			//Pass around the parse info
+			if(parse){
+				content._runParse = true;
+			}
+			return content; //Array
+		},
+
+		_cloneNode: function(/*DOMNode*/ node){
+			// summary:
+			//		private utility to clone a node. Not very interesting in the vanilla
+			//		dojo/NodeList case, but delegates could do interesting things like
+			//		clone event handlers if that is derivable from the node.
+			return node.cloneNode(true);
+		},
+
+		_place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){
+			// summary:
+			//		private utility to handle placing an array of nodes relative to another node.
+			// description:
+			//		Allows for cloning the nodes in the array, and for
+			//		optionally parsing widgets, if ary._runParse is true.
+
+			//Avoid a disallowed operation if trying to do an innerHTML on a non-element node.
+			if(refNode.nodeType != 1 && position == "only"){
+				return;
+			}
+			var rNode = refNode, tempNode;
+
+			//Always cycle backwards in case the array is really a
+			//DOM NodeList and the DOM operations take it out of the live collection.
+			var length = ary.length;
+			for(var i = length - 1; i >= 0; i--){
+				var node = (useClone ? this._cloneNode(ary[i]) : ary[i]);
+
+				//If need widget parsing, use a temp node, instead of waiting after inserting into
+				//real DOM because we need to start widget parsing at one node up from current node,
+				//which could cause some already parsed widgets to be parsed again.
+				if(ary._runParse && dojo.parser && dojo.parser.parse){
+					if(!tempNode){
+						tempNode = rNode.ownerDocument.createElement("div");
+					}
+					tempNode.appendChild(node);
+					dojo.parser.parse(tempNode);
+					node = tempNode.firstChild;
+					while(tempNode.firstChild){
+						tempNode.removeChild(tempNode.firstChild);
+					}
+				}
+
+				if(i == length - 1){
+					domCtr.place(node, rNode, position);
+				}else{
+					rNode.parentNode.insertBefore(node, rNode);
+				}
+				rNode = node;
+			}
+		},
+
+
+		position: aam(domGeom.position),
+		/*=====
+		position: function(){
+			// summary:
+			//		Returns border-box objects (x/y/w/h) of all elements in a node list
+			//		as an Array (*not* a NodeList). Acts like `dojo.position`, though
+			//		assumes the node passed is each node in this list.
+
+			return dojo.map(this, dojo.position); // Array
+		},
+		=====*/
+
+		attr: awc(getSet(domAttr), magicGuard),
+		/*=====
+		attr: function(property, value){
+			// summary:
+			//		gets or sets the DOM attribute for every element in the
+			//		NodeList. See also `dojo.attr`
+			// property: String
+			//		the attribute to get/set
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of attribute values
+			//		If a value is passed, the return is this NodeList
+			// example:
+			//		Make all nodes with a particular class focusable:
+			//	|	dojo.query(".focusable").attr("tabIndex", -1);
+			// example:
+			//		Disable a group of buttons:
+			//	|	dojo.query("button.group").attr("disabled", true);
+			// example:
+			//		innerHTML can be assigned or retrieved as well:
+			//	|	// get the innerHTML (as an array) for each list item
+			//	|	var ih = dojo.query("li.replaceable").attr("innerHTML");
+			return; // dojo/NodeList|Array
+		},
+		=====*/
+
+		style: awc(getSet(domStyle), magicGuard),
+		/*=====
+		style: function(property, value){
+			// summary:
+			//		gets or sets the CSS property for every element in the NodeList
+			// property: String
+			//		the CSS property to get/set, in JavaScript notation
+			//		("lineHieght" instead of "line-height")
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of strings.
+			//		If a value is passed, the return is this NodeList
+			return; // dojo/NodeList
+			return; // Array
+		},
+		=====*/
+
+		addClass: aafe(domCls.add),
+		/*=====
+		addClass: function(className){
+			// summary:
+			//		adds the specified class to every node in the list
+			// className: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			return; // dojo/NodeList
+		},
+		=====*/
+
+		removeClass: aafe(domCls.remove),
+		/*=====
+		removeClass: function(className){
+			// summary:
+			//		removes the specified class from every node in the list
+			// className: String|Array?
+			//		An optional String class name to remove, or several space-separated
+			//		class names, or an array of class names. If omitted, all class names
+			//		will be deleted.
+			// returns:
+			//		this list
+			return; // dojo/NodeList
+		},
+		=====*/
+
+		toggleClass: aafe(domCls.toggle),
+		/*=====
+		toggleClass: function(className, condition){
+			// summary:
+			//		Adds a class to node if not present, or removes if present.
+			//		Pass a boolean condition if you want to explicitly add or remove.
+			// condition: Boolean?
+			//		If passed, true means to add the class, false means to remove.
+			// className: String
+			//		the CSS class to add
+			return; // dojo/NodeList
+		},
+		=====*/
+
+		replaceClass: aafe(domCls.replace),
+		/*=====
+		replaceClass: function(addClassStr, removeClassStr){
+			// summary:
+			//		Replaces one or more classes on a node if not present.
+			//		Operates more quickly than calling `removeClass()` and `addClass()`
+			// addClassStr: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			// removeClassStr: String|Array?
+			//		A String class name to remove, or several space-separated class names,
+			//		or an array of class names.
+			return; // dojo/NodeList
+		 },
+		 =====*/
+
+		empty: aafe(domCtr.empty),
+		/*=====
+		empty: function(){
+			// summary:
+			//		clears all content from each node in the list. Effectively
+			//		equivalent to removing all child nodes from every item in
+			//		the list.
+			return this.forEach("item.innerHTML='';"); // dojo/NodeList
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		=====*/
+
+		removeAttr: aafe(domAttr.remove),
+		/*=====
+		 removeAttr: function(name){
+			// summary:
+			//		Removes an attribute from each node in the list.
+			// name: String
+			//		the name of the attribute to remove
+			return;		// dojo/NodeList
+		},
+		=====*/
+
+		marginBox: aam(domGeom.getMarginBox),
+		/*=====
+		marginBox: function(){
+			// summary:
+			//		Returns margin-box size of nodes
+		 	return; // dojo/NodeList
+		 },
+		 =====*/
+
+		// FIXME: connectPublisher()? connectRunOnce()?
+
+		/*
+		destroy: function(){
+			// summary:
+			//		destroys every item in the list.
+			this.forEach(d.destroy);
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		*/
+
+		place: function(/*String||Node*/ queryOrNode, /*String*/ position){
+			// summary:
+			//		places elements of this node list relative to the first element matched
+			//		by queryOrNode. Returns the original NodeList. See: `dojo.place`
+			// queryOrNode:
+			//		may be a string representing any valid CSS3 selector or a DOM node.
+			//		In the selector case, only the first matching element will be used
+			//		for relative positioning.
+			// position:
+			//		can be one of:
+			//
+			//		-	"last" (default)
+			//		-	"first"
+			//		-	"before"
+			//		-	"after"
+			//		-	"only"
+			//		-	"replace"
+			//
+			//		or an offset in the childNodes property
+			var item = query(queryOrNode)[0];
+			return this.forEach(function(node){ domCtr.place(node, item, position); }); // dojo/NodeList
+		},
+
+		orphan: function(/*String?*/ filter){
+			// summary:
+			//		removes elements in this list that match the filter
+			//		from their parents and returns them as a new NodeList.
+			// filter:
+			//		CSS selector like ".foo" or "div > span"
+			// returns:
+			//		NodeList containing the orphaned elements
+			return (filter ? query._filterResult(this, filter) : this).forEach(orphan); // dojo/NodeList
+		},
+
+		adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){
+			// summary:
+			//		places any/all elements in queryOrListOrNode at a
+			//		position relative to the first element in this list.
+			//		Returns a dojo/NodeList of the adopted elements.
+			// queryOrListOrNode:
+			//		a DOM node or a query string or a query result.
+			//		Represents the nodes to be adopted relative to the
+			//		first element of this NodeList.
+			// position:
+			//		can be one of:
+			//
+			//		-	"last" (default)
+			//		-	"first"
+			//		-	"before"
+			//		-	"after"
+			//		-	"only"
+			//		-	"replace"
+			//
+			//		or an offset in the childNodes property
+			return query(queryOrListOrNode).place(this[0], position)._stash(this);	// dojo/NodeList
+		},
+
+		// FIXME: do we need this?
+		query: function(/*String*/ queryStr){
+			// summary:
+			//		Returns a new list whose members match the passed query,
+			//		assuming elements of the current NodeList as the root for
+			//		each search.
+			// example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo">
+			//	|		<p>
+			//	|			bacon is tasty, <span>dontcha think?</span>
+			//	|		</p>
+			//	|	</div>
+			//	|	<div id="bar">
+			//	|		<p>great comedians may not be funny <span>in person</span></p>
+			//	|	</div>
+			//		If we are presented with the following definition for a NodeList:
+			//	|	var l = new NodeList(dojo.byId("foo"), dojo.byId("bar"));
+			//		it's possible to find all span elements under paragraphs
+			//		contained by these elements with this sub-query:
+			//	|	var spans = l.query("p span");
+
+			// FIXME: probably slow
+			if(!queryStr){ return this; }
+			var ret = new NodeList;
+			this.map(function(node){
+				// FIXME: why would we ever get undefined here?
+				query(queryStr, node).forEach(function(subNode){
+					if(subNode !== undefined){
+						ret.push(subNode);
+					}
+				});
+			});
+			return ret._stash(this);	// dojo/NodeList
+		},
+
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = query._filterResult(this, a[0]);
+				if(a.length == 1){
+					// if we only got a string query, pass back the filtered results
+					return items._stash(this); // dojo/NodeList
+				}
+				// if we got a callback, run it over the filtered items
+				start = 1;
+			}
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo/NodeList
+		},
+
+		/*
+		// FIXME: should this be "copyTo" and include parenting info?
+		clone: function(){
+			// summary:
+			//		creates node clones of each element of this list
+			//		and returns a new list containing the clones
+		},
+		*/
+
+		addContent: function(/*String||DomNode||Object||dojo/NodeList*/ content, /*String||Integer?*/ position){
+			// summary:
+			//		add a node, NodeList or some HTML as a string to every item in the
+			//		list.  Returns the original list.
+			// description:
+			//		a copy of the HTML content is added to each item in the
+			//		list, with an optional position argument. If no position
+			//		argument is provided, the content is appended to the end of
+			//		each item.
+			// content:
+			//		DOM node, HTML in string format, a NodeList or an Object. If a DOM node or
+			//		NodeList, the content will be cloned if the current NodeList has more than one
+			//		element. Only the DOM nodes are cloned, no event handlers. If it is an Object,
+			//		it should be an object with at "template" String property that has the HTML string
+			//		to insert. If dojo.string has already been dojo.required, then dojo.string.substitute
+			//		will be used on the "template" to generate the final HTML string. Other allowed
+			//		properties on the object are: "parse" if the HTML
+			//		string should be parsed for widgets (dojo.require("dojo.parser") to get that
+			//		option to work), and "templateFunc" if a template function besides dojo.string.substitute
+			//		should be used to transform the "template".
+			// position:
+			//		can be one of:
+			//
+			//		-	"last"||"end" (default)
+			//		-	"first||"start"
+			//		-	"before"
+			//		-	"after"
+			//		-	"replace" (replaces nodes in this NodeList with new content)
+			//		-	"only" (removes other children of the nodes so new content is the only child)
+			//
+			//		or an offset in the childNodes property
+			// example:
+			//		appends content to the end if the position is omitted
+			//	|	dojo.query("h3 > p").addContent("hey there!");
+			// example:
+			//		add something to the front of each element that has a
+			//		"thinger" property:
+			//	|	dojo.query("[thinger]").addContent("...", "first");
+			// example:
+			//		adds a header before each element of the list
+			//	|	dojo.query(".note").addContent("<h4>NOTE:</h4>", "before");
+			// example:
+			//		add a clone of a DOM node to the end of every element in
+			//		the list, removing it from its existing parent.
+			//	|	dojo.query(".note").addContent(dojo.byId("foo"));
+			// example:
+			//		Append nodes from a templatized string.
+			// |	dojo.require("dojo.string");
+			// |	dojo.query(".note").addContent({
+			// |		template: '<b>${id}: </b><span>${name}</span>',
+			// |		id: "user332",
+			// |		name: "Mr. Anderson"
+			// |	});
+			// example:
+			//		Append nodes from a templatized string that also has widgets parsed.
+			// |	dojo.require("dojo.string");
+			// |	dojo.require("dojo.parser");
+			// |	var notes = dojo.query(".note").addContent({
+			// |		template: '<button dojoType="dijit/form/Button">${text}</button>',
+			// |		parse: true,
+			// |		text: "Send"
+			// |	});
+			content = this._normalize(content, this[0]);
+			for(var i = 0, node; (node = this[i]); i++){
+				if(content.length){
+					this._place(content, node, position, i > 0);
+				}else{
+					// if it is an empty array, we empty the target node
+					domCtr.empty(node);
+				}
+			}
+			return this; // dojo/NodeList
+		}
+	});
+
+	return NodeList;
+});

debian/missing-sources/dojo/Stateful.js

@@ -0,0 +1,213 @@
+define(["./_base/declare", "./_base/lang", "./_base/array", "./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
+	}
+
+});
+
+});

debian/missing-sources/dojo/_base/array.js

@@ -0,0 +1,350 @@
+define(["./kernel", "../has", "./lang"], function(dojo, has, lang){
+	// module:
+	//		dojo/_base/array
+
+	// our old simple function builder stuff
+	var cache = {}, u;
+
+	function buildFn(fn){
+		return cache[fn] = new Function("item", "index", "array", fn); // Function
+	}
+	// magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+
+	// every & some
+
+	function everyOrSome(some){
+		var every = !some;
+		return function(a, fn, o){
+			var i = 0, l = a && a.length || 0, result;
+			if(l && typeof a == "string") a = a.split("");
+			if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+			if(o){
+				for(; i < l; ++i){
+					result = !fn.call(o, a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}else{
+				for(; i < l; ++i){
+					result = !fn(a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}
+			return every; // Boolean
+		};
+	}
+
+	// indexOf, lastIndexOf
+
+	function index(up){
+		var delta = 1, lOver = 0, uOver = 0;
+		if(!up){
+			delta = lOver = uOver = -1;
+		}
+		return function(a, x, from, last){
+			if(last && delta > 0){
+				// TODO: why do we use a non-standard signature? why do we need "last"?
+				return array.lastIndexOf(a, x, from);
+			}
+			var l = a && a.length || 0, end = up ? l + uOver : lOver, i;
+			if(from === u){
+				i = up ? lOver : l + uOver;
+			}else{
+				if(from < 0){
+					i = l + from;
+					if(i < 0){
+						i = lOver;
+					}
+				}else{
+					i = from >= l ? l + uOver : from;
+				}
+			}
+			if(l && typeof a == "string") a = a.split("");
+			for(; i != end; i += delta){
+				if(a[i] == x){
+					return i; // Number
+				}
+			}
+			return -1; // Number
+		};
+	}
+
+	var array = {
+		// summary:
+		//		The Javascript v1.6 array extensions.
+
+		every: everyOrSome(false),
+		/*=====
+		 every: function(arr, callback, thisObject){
+			 // summary:
+			 //		Determines whether or not every item in arr satisfies the
+			 //		condition implemented by callback.
+			 // arr: Array|String
+			 //		the array to iterate on. If a string, operates on individual characters.
+			 // callback: Function|String
+			 //		a function is invoked with three arguments: item, index,
+			 //		and array and returns true if the condition is met.
+			 // thisObject: Object?
+			 //		may be used to scope the call to callback
+			 // returns: Boolean
+			 // description:
+			 //		This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
+			 //		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			 //		the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
+			 //		For more details, see:
+			 //		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
+			 // example:
+			 //	|	// returns false
+			 //	|	array.every([1, 2, 3, 4], function(item){ return item>1; });
+			 // example:
+			 //	|	// returns true
+			 //	|	array.every([1, 2, 3, 4], function(item){ return item>0; });
+		 },
+		 =====*/
+
+		some: everyOrSome(true),
+		/*=====
+		some: function(arr, callback, thisObject){
+			// summary:
+			//		Determines whether or not any item in arr satisfies the
+			//		condition implemented by callback.
+			// arr: Array|String
+			//		the array to iterate over. If a string, operates on individual characters.
+			// callback: Function|String
+			//		a function is invoked with three arguments: item, index,
+			//		and array and returns true if the condition is met.
+			// thisObject: Object?
+			//		may be used to scope the call to callback
+			// returns: Boolean
+			// description:
+			//		This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
+			//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			//		the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
+			//		For more details, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
+			// example:
+			//	| // is true
+			//	| array.some([1, 2, 3, 4], function(item){ return item>1; });
+			// example:
+			//	| // is false
+			//	| array.some([1, 2, 3, 4], function(item){ return item<1; });
+		},
+		=====*/
+
+		indexOf: index(true),
+		/*=====
+		indexOf: function(arr, value, fromIndex, findLast){
+			// summary:
+			//		locates the first index of the provided value in the
+			//		passed array. If the value is not found, -1 is returned.
+			// description:
+			//		This method corresponds to the JavaScript 1.6 Array.indexOf method, with two differences:
+			//
+			//		1. when run over sparse arrays, the Dojo function invokes the callback for every index
+			//		   whereas JavaScript 1.6's indexOf skips the holes in the sparse array.
+			//		2. uses equality (==) rather than strict equality (===)
+			//
+			//		For details on this method, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+			// arr: Array
+			// value: Object
+			// fromIndex: Integer?
+			// findLast: Boolean?
+			//		Makes indexOf() work like lastIndexOf().  Used internally; not meant for external usage.
+			// returns: Number
+		},
+		=====*/
+
+		lastIndexOf: index(false),
+		/*=====
+		lastIndexOf: function(arr, value, fromIndex){
+			// summary:
+			//		locates the last index of the provided value in the passed
+			//		array. If the value is not found, -1 is returned.
+			// description:
+		 	//		This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with two differences:
+		 	//
+		 	//		1. when run over sparse arrays, the Dojo function invokes the callback for every index
+		 	//		   whereas JavaScript 1.6's lasIndexOf skips the holes in the sparse array.
+		 	//		2. uses equality (==) rather than strict equality (===)
+		 	//
+		 	//		For details on this method, see:
+		 	//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
+			// arr: Array,
+			// value: Object,
+			// fromIndex: Integer?
+			// returns: Number
+		},
+		=====*/
+
+		forEach: function(arr, callback, thisObject){
+			// summary:
+			//		for every item in arr, callback is invoked. Return values are ignored.
+			//		If you want to break out of the loop, consider using array.every() or array.some().
+			//		forEach does not allow breaking out of the loop over the items in arr.
+			// arr:
+			//		the array to iterate over. If a string, operates on individual characters.
+			// callback:
+			//		a function is invoked with three arguments: item, index, and array
+			// thisObject:
+			//		may be used to scope the call to callback
+			// description:
+			//		This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
+			//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			//		the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
+			//		For more details, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
+			// example:
+			//	| // log out all members of the array:
+			//	| array.forEach(
+			//	|		[ "thinger", "blah", "howdy", 10 ],
+			//	|		function(item){
+			//	|			console.log(item);
+			//	|		}
+			//	| );
+			// example:
+			//	| // log out the members and their indexes
+			//	| array.forEach(
+			//	|		[ "thinger", "blah", "howdy", 10 ],
+			//	|		function(item, idx, arr){
+			//	|			console.log(item, "at index:", idx);
+			//	|		}
+			//	| );
+			// example:
+			//	| // use a scoped object member as the callback
+			//	|
+			//	| var obj = {
+			//	|		prefix: "logged via obj.callback:",
+			//	|		callback: function(item){
+			//	|			console.log(this.prefix, item);
+			//	|		}
+			//	| };
+			//	|
+			//	| // specifying the scope function executes the callback in that scope
+			//	| array.forEach(
+			//	|		[ "thinger", "blah", "howdy", 10 ],
+			//	|		obj.callback,
+			//	|		obj
+			//	| );
+			//	|
+			//	| // alternately, we can accomplish the same thing with lang.hitch()
+			//	| array.forEach(
+			//	|		[ "thinger", "blah", "howdy", 10 ],
+			//	|		lang.hitch(obj, "callback")
+			//	| );
+			// arr: Array|String
+			// callback: Function|String
+			// thisObject: Object?
+
+			var i = 0, l = arr && arr.length || 0;
+			if(l && typeof arr == "string") arr = arr.split("");
+			if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
+			if(thisObject){
+				for(; i < l; ++i){
+					callback.call(thisObject, arr[i], i, arr);
+				}
+			}else{
+				for(; i < l; ++i){
+					callback(arr[i], i, arr);
+				}
+			}
+		},
+
+		map: function(arr, callback, thisObject, Ctr){
+			// summary:
+			//		applies callback to each element of arr and returns
+			//		an Array with the results
+			// arr: Array|String
+			//		the array to iterate on. If a string, operates on
+			//		individual characters.
+			// callback: Function|String
+			//		a function is invoked with three arguments, (item, index,
+			//		array),	 and returns a value
+			// thisObject: Object?
+			//		may be used to scope the call to callback
+			// returns: Array
+			// description:
+			//		This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
+			//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			//		the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
+			//		For more details, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+			// example:
+			//	| // returns [2, 3, 4, 5]
+			//	| array.map([1, 2, 3, 4], function(item){ return item+1 });
+
+			// TODO: why do we have a non-standard signature here? do we need "Ctr"?
+			var i = 0, l = arr && arr.length || 0, out = new (Ctr || Array)(l);
+			if(l && typeof arr == "string") arr = arr.split("");
+			if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
+			if(thisObject){
+				for(; i < l; ++i){
+					out[i] = callback.call(thisObject, arr[i], i, arr);
+				}
+			}else{
+				for(; i < l; ++i){
+					out[i] = callback(arr[i], i, arr);
+				}
+			}
+			return out; // Array
+		},
+
+		filter: function(arr, callback, thisObject){
+			// summary:
+			//		Returns a new Array with those items from arr that match the
+			//		condition implemented by callback.
+			// arr: Array
+			//		the array to iterate over.
+			// callback: Function|String
+			//		a function that is invoked with three arguments (item,
+			//		index, array). The return of this function is expected to
+			//		be a boolean which determines whether the passed-in item
+			//		will be included in the returned array.
+			// thisObject: Object?
+			//		may be used to scope the call to callback
+			// returns: Array
+			// description:
+			//		This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
+			//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+			//		the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
+			//		For more details, see:
+			//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+			// example:
+			//	| // returns [2, 3, 4]
+			//	| array.filter([1, 2, 3, 4], function(item){ return item>1; });
+
+			// TODO: do we need "Ctr" here like in map()?
+			var i = 0, l = arr && arr.length || 0, out = [], value;
+			if(l && typeof arr == "string") arr = arr.split("");
+			if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
+			if(thisObject){
+				for(; i < l; ++i){
+					value = arr[i];
+					if(callback.call(thisObject, value, i, arr)){
+						out.push(value);
+					}
+				}
+			}else{
+				for(; i < l; ++i){
+					value = arr[i];
+					if(callback(value, i, arr)){
+						out.push(value);
+					}
+				}
+			}
+			return out; // Array
+		},
+
+		clearCache: function(){
+			cache = {};
+		}
+	};
+
+
+	has("extend-dojo") && lang.mixin(dojo, array);
+
+	return array;
+});

debian/missing-sources/dojo/_base/lang.js

@@ -0,0 +1,605 @@
+define(["./kernel", "../has", "../sniff"], function(dojo, has){
+	// module:
+	//		dojo/_base/lang
+
+	has.add("bug-for-in-skips-shadowed", function(){
+		// if true, the for-in iterator skips object properties that exist in Object's prototype (IE 6 - ?)
+		for(var i in {toString: 1}){
+			return 0;
+		}
+		return 1;
+	});
+
+	// Helper methods
+	var _extraNames =
+			has("bug-for-in-skips-shadowed") ?
+				"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [],
+
+		_extraLen = _extraNames.length,
+
+		getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
+			var p, i = 0, dojoGlobal = dojo.global;
+			if(!context){
+				if(!parts.length){
+					return dojoGlobal;
+				}else{
+					p = parts[i++];
+					try{
+						context = dojo.scopeMap[p] && dojo.scopeMap[p][1];
+					}catch(e){}
+					context = context || (p in dojoGlobal ? dojoGlobal[p] : (create ? dojoGlobal[p] = {} : undefined));
+				}
+			}
+			while(context && (p = parts[i++])){
+				context = (p in context ? context[p] : (create ? context[p] = {} : undefined));
+			}
+			return context; // mixed
+		},
+
+		opts = Object.prototype.toString,
+
+		efficient = function(obj, offset, startWith){
+			return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
+		},
+
+		_pattern = /\{([^\}]+)\}/g;
+
+	// Module export
+	var lang = {
+		// summary:
+		//		This module defines Javascript language extensions.
+
+		// _extraNames: String[]
+		//		Lists property names that must be explicitly processed during for-in iteration
+		//		in environments that have has("bug-for-in-skips-shadowed") true.
+		_extraNames:_extraNames,
+
+		_mixin: function(dest, source, copyFunc){
+			// summary:
+			//		Copies/adds all properties of source to dest; returns dest.
+			// dest: Object
+			//		The object to which to copy/add all properties contained in source.
+			// source: Object
+			//		The object from which to draw all properties to copy into dest.
+			// copyFunc: Function?
+			//		The process used to copy/add a property in source; defaults to the Javascript assignment operator.
+			// returns:
+			//		dest, as modified
+			// description:
+			//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
+			//		found in Object.prototype, are copied/added to dest. Copying/adding each particular property is
+			//		delegated to copyFunc (if any); copyFunc defaults to the Javascript assignment operator if not provided.
+			//		Notice that by default, _mixin executes a so-called "shallow copy" and aggregate types are copied/added by reference.
+			var name, s, i, empty = {};
+			for(name in source){
+				// the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source"
+				// inherited from Object.prototype.	 For example, if dest has a custom toString() method,
+				// don't overwrite it with the toString() method that source inherited from Object.prototype
+				s = source[name];
+				if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
+					dest[name] = copyFunc ? copyFunc(s) : s;
+				}
+			}
+
+			if(has("bug-for-in-skips-shadowed")){
+				if(source){
+					for(i = 0; i < _extraLen; ++i){
+						name = _extraNames[i];
+						s = source[name];
+						if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
+							dest[name] = copyFunc ? copyFunc(s) : s;
+						}
+					}
+				}
+			}
+
+			return dest; // Object
+		},
+
+		mixin: function(dest, sources){
+			// summary:
+			//		Copies/adds all properties of one or more sources to dest; returns dest.
+			// dest: Object
+			//		The object to which to copy/add all properties contained in source. If dest is falsy, then
+			//		a new object is manufactured before copying/adding properties begins.
+			// sources: Object...
+			//		One of more objects from which to draw all properties to copy into dest. sources are processed
+			//		left-to-right and if more than one of these objects contain the same property name, the right-most
+			//		value "wins".
+			// returns: Object
+			//		dest, as modified
+			// description:
+			//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
+			//		found in Object.prototype, are copied/added from sources to dest. sources are processed left to right.
+			//		The Javascript assignment operator is used to copy/add each property; therefore, by default, mixin
+			//		executes a so-called "shallow copy" and aggregate types are copied/added by reference.
+			// example:
+			//		make a shallow copy of an object
+			//	|	var copy = lang.mixin({}, source);
+			// example:
+			//		many class constructors often take an object which specifies
+			//		values to be configured on the object. In this case, it is
+			//		often simplest to call `lang.mixin` on the `this` object:
+			//	|	declare("acme.Base", null, {
+			//	|		constructor: function(properties){
+			//	|			// property configuration:
+			//	|			lang.mixin(this, properties);
+			//	|
+			//	|			console.log(this.quip);
+			//	|			//	...
+			//	|		},
+			//	|		quip: "I wasn't born yesterday, you know - I've seen movies.",
+			//	|		// ...
+			//	|	});
+			//	|
+			//	|	// create an instance of the class and configure it
+			//	|	var b = new acme.Base({quip: "That's what it does!" });
+			// example:
+			//		copy in properties from multiple objects
+			//	|	var flattened = lang.mixin(
+			//	|		{
+			//	|			name: "Frylock",
+			//	|			braces: true
+			//	|		},
+			//	|		{
+			//	|			name: "Carl Brutanananadilewski"
+			//	|		}
+			//	|	);
+			//	|
+			//	|	// will print "Carl Brutanananadilewski"
+			//	|	console.log(flattened.name);
+			//	|	// will print "true"
+			//	|	console.log(flattened.braces);
+
+			if(!dest){ dest = {}; }
+			for(var i = 1, l = arguments.length; i < l; i++){
+				lang._mixin(dest, arguments[i]);
+			}
+			return dest; // Object
+		},
+
+		setObject: function(name, value, context){
+			// summary:
+			//		Set a property from a dot-separated string, such as "A.B.C"
+			// description:
+			//		Useful for longer api chains where you have to test each object in
+			//		the chain, or when you have an object reference in string format.
+			//		Objects are created as needed along `path`. Returns the passed
+			//		value if setting is successful or `undefined` if not.
+			// name: String
+			//		Path to a property, in the form "A.B.C".
+			// value: anything
+			//		value or object to place at location given by name
+			// context: Object?
+			//		Optional. Object to use as root of path. Defaults to
+			//		`dojo.global`.
+			// example:
+			//		set the value of `foo.bar.baz`, regardless of whether
+			//		intermediate objects already exist:
+			//	| lang.setObject("foo.bar.baz", value);
+			// example:
+			//		without `lang.setObject`, we often see code like this:
+			//	| // ensure that intermediate objects are available
+			//	| if(!obj["parent"]){ obj.parent = {}; }
+			//	| if(!obj.parent["child"]){ obj.parent.child = {}; }
+			//	| // now we can safely set the property
+			//	| obj.parent.child.prop = "some value";
+			//		whereas with `lang.setObject`, we can shorten that to:
+			//	| lang.setObject("parent.child.prop", "some value", obj);
+
+			var parts = name.split("."), p = parts.pop(), obj = getProp(parts, true, context);
+			return obj && p ? (obj[p] = value) : undefined; // Object
+		},
+
+		getObject: function(name, create, context){
+			// summary:
+			//		Get a property from a dot-separated string, such as "A.B.C"
+			// description:
+			//		Useful for longer api chains where you have to test each object in
+			//		the chain, or when you have an object reference in string format.
+			// name: String
+			//		Path to an property, in the form "A.B.C".
+			// create: Boolean?
+			//		Optional. Defaults to `false`. If `true`, Objects will be
+			//		created at any point along the 'path' that is undefined.
+			// context: Object?
+			//		Optional. Object to use as root of path. Defaults to
+			//		'dojo.global'. Null may be passed.
+			return getProp(name.split("."), create, context); // Object
+		},
+
+		exists: function(name, obj){
+			// summary:
+			//		determine if an object supports a given method
+			// description:
+			//		useful for longer api chains where you have to test each object in
+			//		the chain. Useful for object and method detection.
+			// name: String
+			//		Path to an object, in the form "A.B.C".
+			// obj: Object?
+			//		Object to use as root of path. Defaults to
+			//		'dojo.global'. Null may be passed.
+			// example:
+			//	| // define an object
+			//	| var foo = {
+			//	|		bar: { }
+			//	| };
+			//	|
+			//	| // search the global scope
+			//	| lang.exists("foo.bar"); // true
+			//	| lang.exists("foo.bar.baz"); // false
+			//	|
+			//	| // search from a particular scope
+			//	| lang.exists("bar", foo); // true
+			//	| lang.exists("bar.baz", foo); // false
+			return lang.getObject(name, false, obj) !== undefined; // Boolean
+		},
+
+		// Crockford (ish) functions
+
+		isString: function(it){
+			// summary:
+			//		Return true if it is a String
+			// it: anything
+			//		Item to test.
+			return (typeof it == "string" || it instanceof String); // Boolean
+		},
+
+		isArray: function(it){
+			// summary:
+			//		Return true if it is an Array.
+			//		Does not work on Arrays created in other windows.
+			// it: anything
+			//		Item to test.
+			return it && (it instanceof Array || typeof it == "array"); // Boolean
+		},
+
+		isFunction: function(it){
+			// summary:
+			//		Return true if it is a Function
+			// it: anything
+			//		Item to test.
+			return opts.call(it) === "[object Function]";
+		},
+
+		isObject: function(it){
+			// summary:
+			//		Returns true if it is a JavaScript object (or an Array, a Function
+			//		or null)
+			// it: anything
+			//		Item to test.
+			return it !== undefined &&
+				(it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean
+		},
+
+		isArrayLike: function(it){
+			// summary:
+			//		similar to isArray() but more permissive
+			// it: anything
+			//		Item to test.
+			// returns:
+			//		If it walks like a duck and quacks like a duck, return `true`
+			// description:
+			//		Doesn't strongly test for "arrayness".  Instead, settles for "isn't
+			//		a string or number and has a length property". Arguments objects
+			//		and DOM collections will return true when passed to
+			//		isArrayLike(), but will return false when passed to
+			//		isArray().
+			return it && it !== undefined && // Boolean
+				// keep out built-in constructors (Number, String, ...) which have length
+				// properties
+				!lang.isString(it) && !lang.isFunction(it) &&
+				!(it.tagName && it.tagName.toLowerCase() == 'form') &&
+				(lang.isArray(it) || isFinite(it.length));
+		},
+
+		isAlien: function(it){
+			// summary:
+			//		Returns true if it is a built-in function or some other kind of
+			//		oddball that *should* report as a function but doesn't
+			return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
+		},
+
+		extend: function(ctor, props){
+			// summary:
+			//		Adds all properties and methods of props to constructor's
+			//		prototype, making them available to all instances created with
+			//		constructor.
+			// ctor: Object
+			//		Target constructor to extend.
+			// props: Object
+			//		One or more objects to mix into ctor.prototype
+			for(var i=1, l=arguments.length; i<l; i++){
+				lang._mixin(ctor.prototype, arguments[i]);
+			}
+			return ctor; // Object
+		},
+
+		_hitchArgs: function(scope, method){
+			var pre = lang._toArray(arguments, 2);
+			var named = lang.isString(method);
+			return function(){
+				// arrayify arguments
+				var args = lang._toArray(arguments);
+				// locate our method
+				var f = named ? (scope||dojo.global)[method] : method;
+				// invoke with collected args
+				return f && f.apply(scope || this, pre.concat(args)); // mixed
+			}; // Function
+		},
+
+		hitch: function(scope, method){
+			// summary:
+			//		Returns a function that will only ever execute in the a given scope.
+			//		This allows for easy use of object member functions
+			//		in callbacks and other places in which the "this" keyword may
+			//		otherwise not reference the expected scope.
+			//		Any number of default positional arguments may be passed as parameters
+			//		beyond "method".
+			//		Each of these values will be used to "placehold" (similar to curry)
+			//		for the hitched function.
+			// scope: Object
+			//		The scope to use when method executes. If method is a string,
+			//		scope is also the object containing method.
+			// method: Function|String...
+			//		A function to be hitched to scope, or the name of the method in
+			//		scope to be hitched.
+			// example:
+			//	|	lang.hitch(foo, "bar")();
+			//		runs foo.bar() in the scope of foo
+			// example:
+			//	|	lang.hitch(foo, myFunction);
+			//		returns a function that runs myFunction in the scope of foo
+			// example:
+			//		Expansion on the default positional arguments passed along from
+			//		hitch. Passed args are mixed first, additional args after.
+			//	|	var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
+			//	|	var fn = lang.hitch(foo, "bar", 1, 2);
+			//	|	fn(3); // logs "1, 2, 3"
+			// example:
+			//	|	var foo = { bar: 2 };
+			//	|	lang.hitch(foo, function(){ this.bar = 10; })();
+			//		execute an anonymous function in scope of foo
+			if(arguments.length > 2){
+				return lang._hitchArgs.apply(dojo, arguments); // Function
+			}
+			if(!method){
+				method = scope;
+				scope = null;
+			}
+			if(lang.isString(method)){
+				scope = scope || dojo.global;
+				if(!scope[method]){ throw(['lang.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
+				return function(){ return scope[method].apply(scope, arguments || []); }; // Function
+			}
+			return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
+		},
+
+		delegate: (function(){
+			// boodman/crockford delegation w/ cornford optimization
+			function TMP(){}
+			return function(obj, props){
+				TMP.prototype = obj;
+				var tmp = new TMP();
+				TMP.prototype = null;
+				if(props){
+					lang._mixin(tmp, props);
+				}
+				return tmp; // Object
+			};
+		})(),
+		/*=====
+		delegate: function(obj, props){
+			// summary:
+			//		Returns a new object which "looks" to obj for properties which it
+			//		does not have a value for. Optionally takes a bag of properties to
+			//		seed the returned object with initially.
+			// description:
+			//		This is a small implementation of the Boodman/Crockford delegation
+			//		pattern in JavaScript. An intermediate object constructor mediates
+			//		the prototype chain for the returned object, using it to delegate
+			//		down to obj for property lookup when object-local lookup fails.
+			//		This can be thought of similarly to ES4's "wrap", save that it does
+			//		not act on types but rather on pure objects.
+			// obj: Object
+			//		The object to delegate to for properties not found directly on the
+			//		return object or in props.
+			// props: Object...
+			//		an object containing properties to assign to the returned object
+			// returns:
+			//		an Object of anonymous type
+			// example:
+			//	|	var foo = { bar: "baz" };
+			//	|	var thinger = lang.delegate(foo, { thud: "xyzzy"});
+			//	|	thinger.bar == "baz"; // delegated to foo
+			//	|	foo.thud == undefined; // by definition
+			//	|	thinger.thud == "xyzzy"; // mixed in from props
+			//	|	foo.bar = "thonk";
+			//	|	thinger.bar == "thonk"; // still delegated to foo's bar
+		},
+		=====*/
+
+		_toArray: has("ie") ?
+			(function(){
+				function slow(obj, offset, startWith){
+					var arr = startWith||[];
+					for(var x = offset || 0; x < obj.length; x++){
+						arr.push(obj[x]);
+					}
+					return arr;
+				}
+				return function(obj){
+					return ((obj.item) ? slow : efficient).apply(this, arguments);
+				};
+			})() : efficient,
+		/*=====
+		 _toArray: function(obj, offset, startWith){
+			 // summary:
+			 //		Converts an array-like object (i.e. arguments, DOMCollection) to an
+			 //		array. Returns a new Array with the elements of obj.
+			 // obj: Object
+			 //		the object to "arrayify". We expect the object to have, at a
+			 //		minimum, a length property which corresponds to integer-indexed
+			 //		properties.
+			 // offset: Number?
+			 //		the location in obj to start iterating from. Defaults to 0.
+			 //		Optional.
+			 // startWith: Array?
+			 //		An array to pack with the properties of obj. If provided,
+			 //		properties in obj are appended at the end of startWith and
+			 //		startWith is the returned array.
+		 },
+		 =====*/
+
+		partial: function(/*Function|String*/ method /*, ...*/){
+			// summary:
+			//		similar to hitch() except that the scope object is left to be
+			//		whatever the execution context eventually becomes.
+			// description:
+			//		Calling lang.partial is the functional equivalent of calling:
+			//		|	lang.hitch(null, funcName, ...);
+			// method:
+			//		The function to "wrap"
+			var arr = [ null ];
+			return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function
+		},
+
+		clone: function(/*anything*/ src){
+			// summary:
+			//		Clones objects (including DOM nodes) and all children.
+			//		Warning: do not clone cyclic structures.
+			// src:
+			//		The object to clone
+			if(!src || typeof src != "object" || lang.isFunction(src)){
+				// null, undefined, any non-object, or function
+				return src;	// anything
+			}
+			if(src.nodeType && "cloneNode" in src){
+				// DOM Node
+				return src.cloneNode(true); // Node
+			}
+			if(src instanceof Date){
+				// Date
+				return new Date(src.getTime());	// Date
+			}
+			if(src instanceof RegExp){
+				// RegExp
+				return new RegExp(src);   // RegExp
+			}
+			var r, i, l;
+			if(lang.isArray(src)){
+				// array
+				r = [];
+				for(i = 0, l = src.length; i < l; ++i){
+					if(i in src){
+						r.push(lang.clone(src[i]));
+					}
+				}
+				// we don't clone functions for performance reasons
+				//		}else if(d.isFunction(src)){
+				//			// function
+				//			r = function(){ return src.apply(this, arguments); };
+			}else{
+				// generic objects
+				r = src.constructor ? new src.constructor() : {};
+			}
+			return lang._mixin(r, src, lang.clone);
+		},
+
+
+		trim: String.prototype.trim ?
+			function(str){ return str.trim(); } :
+			function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); },
+		/*=====
+		 trim: function(str){
+			 // summary:
+			 //		Trims whitespace from both sides of the string
+			 // str: String
+			 //		String to be trimmed
+			 // returns: String
+			 //		Returns the trimmed string
+			 // description:
+			 //		This version of trim() was selected for inclusion into the base due
+			 //		to its compact size and relatively good performance
+			 //		(see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript)
+			 //		Uses String.prototype.trim instead, if available.
+			 //		The fastest but longest version of this function is located at
+			 //		lang.string.trim()
+		 },
+		 =====*/
+
+		replace: function(tmpl, map, pattern){
+			// summary:
+			//		Performs parameterized substitutions on a string. Throws an
+			//		exception if any parameter is unmatched.
+			// tmpl: String
+			//		String to be used as a template.
+			// map: Object|Function
+			//		If an object, it is used as a dictionary to look up substitutions.
+			//		If a function, it is called for every substitution with following parameters:
+			//		a whole match, a name, an offset, and the whole template
+			//		string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
+			//		for more details).
+			// pattern: RegEx?
+			//		Optional regular expression objects that overrides the default pattern.
+			//		Must be global and match one item. The default is: /\{([^\}]+)\}/g,
+			//		which matches patterns like that: "{xxx}", where "xxx" is any sequence
+			//		of characters, which doesn't include "}".
+			// returns: String
+			//		Returns the substituted string.
+			// example:
+			//	|	// uses a dictionary for substitutions:
+			//	|	lang.replace("Hello, {name.first} {name.last} AKA {nick}!",
+			//	|		{
+			//	|			nick: "Bob",
+			//	|			name: {
+			//	|				first:	"Robert",
+			//	|				middle: "X",
+			//	|				last:		"Cringely"
+			//	|			}
+			//	|		});
+			//	|	// returns: Hello, Robert Cringely AKA Bob!
+			// example:
+			//	|	// uses an array for substitutions:
+			//	|	lang.replace("Hello, {0} {2}!",
+			//	|		["Robert", "X", "Cringely"]);
+			//	|	// returns: Hello, Robert Cringely!
+			// example:
+			//	|	// uses a function for substitutions:
+			//	|	function sum(a){
+			//	|		var t = 0;
+			//	|		arrayforEach(a, function(x){ t += x; });
+			//	|		return t;
+			//	|	}
+			//	|	lang.replace(
+			//	|		"{count} payments averaging {avg} USD per payment.",
+			//	|		lang.hitch(
+			//	|			{ payments: [11, 16, 12] },
+			//	|			function(_, key){
+			//	|				switch(key){
+			//	|					case "count": return this.payments.length;
+			//	|					case "min":		return Math.min.apply(Math, this.payments);
+			//	|					case "max":		return Math.max.apply(Math, this.payments);
+			//	|					case "sum":		return sum(this.payments);
+			//	|					case "avg":		return sum(this.payments) / this.payments.length;
+			//	|				}
+			//	|			}
+			//	|		)
+			//	|	);
+			//	|	// prints: 3 payments averaging 13 USD per payment.
+			// example:
+			//	|	// uses an alternative PHP-like pattern for substitutions:
+			//	|	lang.replace("Hello, ${0} ${2}!",
+			//	|		["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
+			//	|	// returns: Hello, Robert Cringely!
+
+			return tmpl.replace(pattern || _pattern, lang.isFunction(map) ?
+				map : function(_, k){ return lang.getObject(k, false, map); });
+		}
+	};
+
+	has("extend-dojo") && lang.mixin(dojo, lang);
+
+	return lang;
+});
+

debian/missing-sources/dojo/dom-class.js

@@ -0,0 +1,326 @@
+define(["./_base/lang", "./_base/array", "./dom"], function(lang, array, dom){
+	// module:
+	//		dojo/dom-class
+
+	var className = "className";
+
+	/* Part I of classList-based implementation is preserved here for posterity
+	var classList = "classList";
+	has.add("dom-classList", function(){
+		return classList in document.createElement("p");
+	});
+	*/
+
+	// =============================
+	// (CSS) Class Functions
+	// =============================
+
+	var cls, // exports object
+		spaces = /\s+/, a1 = [""];
+
+	function str2array(s){
+		if(typeof s == "string" || s instanceof String){
+			if(s && !spaces.test(s)){
+				a1[0] = s;
+				return a1;
+			}
+			var a = s.split(spaces);
+			if(a.length && !a[0]){
+				a.shift();
+			}
+			if(a.length && !a[a.length - 1]){
+				a.pop();
+			}
+			return a;
+		}
+		// assumed to be an array
+		if(!s){
+			return [];
+		}
+		return array.filter(s, function(x){ return x; });
+	}
+
+	/* Part II of classList-based implementation is preserved here for posterity
+	if(has("dom-classList")){
+		// new classList version
+		cls = {
+			contains: function containsClass(node, classStr){
+				var clslst = classStr && dom.byId(node)[classList];
+				return clslst && clslst.contains(classStr); // Boolean
+			},
+
+			add: function addClass(node, classStr){
+				node = dom.byId(node);
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					node[classList].add(classStr[i]);
+				}
+			},
+
+			remove: function removeClass(node, classStr){
+				node = dom.byId(node);
+				if(classStr === undefined){
+					node[className] = "";
+				}else{
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].remove(classStr[i]);
+					}
+				}
+			},
+
+			replace: function replaceClass(node, addClassStr, removeClassStr){
+				node = dom.byId(node);
+				if(removeClassStr === undefined){
+					node[className] = "";
+				}else{
+					removeClassStr = str2array(removeClassStr);
+					for(var i = 0, len = removeClassStr.length; i < len; ++i){
+						node[classList].remove(removeClassStr[i]);
+					}
+				}
+				addClassStr = str2array(addClassStr);
+				for(i = 0, len = addClassStr.length; i < len; ++i){
+					node[classList].add(addClassStr[i]);
+				}
+			},
+
+			toggle: function toggleClass(node, classStr, condition){
+				node = dom.byId(node);
+				if(condition === undefined){
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].toggle(classStr[i]);
+					}
+				}else{
+					cls[condition ? "add" : "remove"](node, classStr);
+				}
+				return condition;   // Boolean
+			}
+		}
+	}
+	*/
+
+	// regular DOM version
+	var fakeNode = {};  // for effective replacement
+	cls = {
+		// summary:
+		//		This module defines the core dojo DOM class API.
+
+		contains: function containsClass(/*DomNode|String*/ node, /*String*/ classStr){
+			// summary:
+			//		Returns whether or not the specified classes are a portion of the
+			//		class list currently applied to the node.
+			// node: String|DOMNode
+			//		String ID or DomNode reference to check the class for.
+			// classStr: String
+			//		A string class name to look for.
+			// example:
+			//		Do something if a node with id="someNode" has class="aSillyClassName" present
+			//	|	if(dojo.hasClass("someNode","aSillyClassName")){ ... }
+
+			return ((" " + dom.byId(node)[className] + " ").indexOf(" " + classStr + " ") >= 0); // Boolean
+		},
+
+		add: function addClass(/*DomNode|String*/ node, /*String|Array*/ classStr){
+			// summary:
+			//		Adds the specified classes to the end of the class list on the
+			//		passed node. Will not re-apply duplicate classes.
+			//
+			// node: String|DOMNode
+			//		String ID or DomNode reference to add a class string too
+			//
+			// classStr: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			//
+			// example:
+			//		Add a class to some node:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.add("someNode", "anewClass");
+			//	|	});
+			//
+			// example:
+			//		Add two classes at once:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.add("someNode", "firstClass secondClass");
+			//	|	});
+			//
+			// example:
+			//		Add two classes at once (using array):
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.add("someNode", ["firstClass", "secondClass"]);
+			//	|	});
+			//
+			// example:
+			//		Available in `dojo/NodeList` for multiple additions
+			//	|	require(["dojo/query"], function(query){
+			//	|		query("ul > li").addClass("firstLevel");
+			//	|	});
+
+			node = dom.byId(node);
+			classStr = str2array(classStr);
+			var cls = node[className], oldLen;
+			cls = cls ? " " + cls + " " : " ";
+			oldLen = cls.length;
+			for(var i = 0, len = classStr.length, c; i < len; ++i){
+				c = classStr[i];
+				if(c && cls.indexOf(" " + c + " ") < 0){
+					cls += c + " ";
+				}
+			}
+			if(oldLen < cls.length){
+				node[className] = cls.substr(1, cls.length - 2);
+			}
+		},
+
+		remove: function removeClass(/*DomNode|String*/ node, /*String|Array?*/ classStr){
+			// summary:
+			//		Removes the specified classes from node. No `contains()`
+			//		check is required.
+			//
+			// node: String|DOMNode
+			//		String ID or DomNode reference to remove the class from.
+			//
+			// classStr: String|Array
+			//		An optional String class name to remove, or several space-separated
+			//		class names, or an array of class names. If omitted, all class names
+			//		will be deleted.
+			//
+			// example:
+			//		Remove a class from some node:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.remove("someNode", "firstClass");
+			//	|	});
+			//
+			// example:
+			//		Remove two classes from some node:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.remove("someNode", "firstClass secondClass");
+			//	|	});
+			//
+			// example:
+			//		Remove two classes from some node (using array):
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.remove("someNode", ["firstClass", "secondClass"]);
+			//	|	});
+			//
+			// example:
+			//		Remove all classes from some node:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.remove("someNode");
+			//	|	});
+			//
+			// example:
+			//		Available in `dojo/NodeList` for multiple removal
+			//	|	require(["dojo/query"], function(query){
+			//	|		query("ul > li").removeClass("foo");
+			//	|	});
+
+			node = dom.byId(node);
+			var cls;
+			if(classStr !== undefined){
+				classStr = str2array(classStr);
+				cls = " " + node[className] + " ";
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					cls = cls.replace(" " + classStr[i] + " ", " ");
+				}
+				cls = lang.trim(cls);
+			}else{
+				cls = "";
+			}
+			if(node[className] != cls){ node[className] = cls; }
+		},
+
+		replace: function replaceClass(/*DomNode|String*/ node, /*String|Array*/ addClassStr, /*String|Array?*/ removeClassStr){
+			// summary:
+			//		Replaces one or more classes on a node if not present.
+			//		Operates more quickly than calling dojo.removeClass and dojo.addClass
+			//
+			// node: String|DOMNode
+			//		String ID or DomNode reference to remove the class from.
+			//
+			// addClassStr: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			//
+			// removeClassStr: String|Array?
+			//		A String class name to remove, or several space-separated class names,
+			//		or an array of class names.
+			//
+			// example:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.replace("someNode", "add1 add2", "remove1 remove2");
+			//	|	});
+			//
+			// example:
+			//	Replace all classes with addMe
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.replace("someNode", "addMe");
+			//	|	});
+			//
+			// example:
+			//	Available in `dojo/NodeList` for multiple toggles
+			//	|	require(["dojo/query"], function(query){
+			//	|		query(".findMe").replaceClass("addMe", "removeMe");
+			//	|	});
+
+			node = dom.byId(node);
+			fakeNode[className] = node[className];
+			cls.remove(fakeNode, removeClassStr);
+			cls.add(fakeNode, addClassStr);
+			if(node[className] !== fakeNode[className]){
+				node[className] = fakeNode[className];
+			}
+		},
+
+		toggle: function toggleClass(/*DomNode|String*/ node, /*String|Array*/ classStr, /*Boolean?*/ condition){
+			// summary:
+			//		Adds a class to node if not present, or removes if present.
+			//		Pass a boolean condition if you want to explicitly add or remove.
+			//		Returns the condition that was specified directly or indirectly.
+			//
+			// node: String|DOMNode
+			//		String ID or DomNode reference to toggle a class string
+			//
+			// classStr: String|Array
+			//		A String class name to toggle, or several space-separated class names,
+			//		or an array of class names.
+			//
+			// condition:
+			//		If passed, true means to add the class, false means to remove.
+			//		Otherwise dojo.hasClass(node, classStr) is used to detect the class presence.
+			//
+			// example:
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.toggle("someNode", "hovered");
+			//	|	});
+			//
+			// example:
+			//		Forcefully add a class
+			//	|	require(["dojo/dom-class"], function(domClass){
+			//	|		domClass.toggle("someNode", "hovered", true);
+			//	|	});
+			//
+			// example:
+			//		Available in `dojo/NodeList` for multiple toggles
+			//	|	require(["dojo/query"], function(query){
+			//	|		query(".toggleMe").toggleClass("toggleMe");
+			//	|	});
+
+			node = dom.byId(node);
+			if(condition === undefined){
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length, c; i < len; ++i){
+					c = classStr[i];
+					cls[cls.contains(node, c) ? "remove" : "add"](node, c);
+				}
+			}else{
+				cls[condition ? "add" : "remove"](node, classStr);
+			}
+			return condition;   // Boolean
+		}
+	};
+
+	return cls;
+});

debian/missing-sources/dojo/dom-construct.js

@@ -0,0 +1,360 @@
+define(["exports", "./_base/kernel", "./sniff", "./_base/window", "./dom", "./dom-attr"],
+		function(exports, dojo, has, win, dom, attr){
+	// module:
+	//		dojo/dom-construct
+	// summary:
+	//		This module defines the core dojo DOM construction API.
+
+	// TODOC: summary not showing up in output, see https://github.com/csnover/js-doc-parse/issues/42
+
+	// support stuff for toDom()
+	var tagWrap = {
+			option: ["select"],
+			tbody: ["table"],
+			thead: ["table"],
+			tfoot: ["table"],
+			tr: ["table", "tbody"],
+			td: ["table", "tbody", "tr"],
+			th: ["table", "thead", "tr"],
+			legend: ["fieldset"],
+			caption: ["table"],
+			colgroup: ["table"],
+			col: ["table", "colgroup"],
+			li: ["ul"]
+		},
+		reTag = /<\s*([\w\:]+)/,
+		masterNode = {}, masterNum = 0,
+		masterName = "__" + dojo._scopeName + "ToDomId";
+
+	// generate start/end tag strings to use
+	// for the injection for each special tag wrap case.
+	for(var param in tagWrap){
+		if(tagWrap.hasOwnProperty(param)){
+			var tw = tagWrap[param];
+			tw.pre = param == "option" ? '<select multiple="multiple">' : "<" + tw.join("><") + ">";
+			tw.post = "</" + tw.reverse().join("></") + ">";
+			// the last line is destructive: it reverses the array,
+			// but we don't care at this point
+		}
+	}
+
+	var html5domfix;
+	if(has("ie") <= 8){
+		html5domfix = function(doc){
+			doc.__dojo_html5_tested = "yes";
+			var div = create('div', {innerHTML: "<nav>a</nav>", style: {visibility: "hidden"}}, doc.body);
+			if(div.childNodes.length !== 1){
+				('abbr article aside audio canvas details figcaption figure footer header ' +
+				'hgroup mark meter nav output progress section summary time video').replace(
+					/\b\w+\b/g, function(n){
+						doc.createElement(n);
+					}
+				);
+			}
+			destroy(div);
+		}
+	}
+
+	function _insertBefore(/*DomNode*/ node, /*DomNode*/ ref){
+		var parent = ref.parentNode;
+		if(parent){
+			parent.insertBefore(node, ref);
+		}
+	}
+
+	function _insertAfter(/*DomNode*/ node, /*DomNode*/ ref){
+		// summary:
+		//		Try to insert node after ref
+		var parent = ref.parentNode;
+		if(parent){
+			if(parent.lastChild == ref){
+				parent.appendChild(node);
+			}else{
+				parent.insertBefore(node, ref.nextSibling);
+			}
+		}
+	}
+
+	exports.toDom = function toDom(frag, doc){
+		// summary:
+		//		instantiates an HTML fragment returning the corresponding DOM.
+		// frag: String
+		//		the HTML fragment
+		// doc: DocumentNode?
+		//		optional document to use when creating DOM nodes, defaults to
+		//		dojo.doc if not specified.
+		// returns:
+		//		Document fragment, unless it's a single node in which case it returns the node itself
+		// example:
+		//		Create a table row:
+		//	|	var tr = dojo.toDom("<tr><td>First!</td></tr>");
+
+		doc = doc || win.doc;
+		var masterId = doc[masterName];
+		if(!masterId){
+			doc[masterName] = masterId = ++masterNum + "";
+			masterNode[masterId] = doc.createElement("div");
+		}
+
+		if(has("ie") <= 8){
+			if(!doc.__dojo_html5_tested && doc.body){
+				html5domfix(doc);
+			}
+		}
+
+		// make sure the frag is a string.
+		frag += "";
+
+		// find the starting tag, and get node wrapper
+		var match = frag.match(reTag),
+			tag = match ? match[1].toLowerCase() : "",
+			master = masterNode[masterId],
+			wrap, i, fc, df;
+		if(match && tagWrap[tag]){
+			wrap = tagWrap[tag];
+			master.innerHTML = wrap.pre + frag + wrap.post;
+			for(i = wrap.length; i; --i){
+				master = master.firstChild;
+			}
+		}else{
+			master.innerHTML = frag;
+		}
+
+		// one node shortcut => return the node itself
+		if(master.childNodes.length == 1){
+			return master.removeChild(master.firstChild); // DOMNode
+		}
+
+		// return multiple nodes as a document fragment
+		df = doc.createDocumentFragment();
+		while((fc = master.firstChild)){ // intentional assignment
+			df.appendChild(fc);
+		}
+		return df; // DocumentFragment
+	};
+
+	exports.place = function place(/*DOMNode|String*/ node, /*DOMNode|String*/ refNode, /*String|Number?*/ position){
+		// summary:
+		//		Attempt to insert node into the DOM, choosing from various positioning options.
+		//		Returns the first argument resolved to a DOM node.
+		// node: DOMNode|String
+		//		id or node reference, or HTML fragment starting with "<" to place relative to refNode
+		// refNode: DOMNode|String
+		//		id or node reference to use as basis for placement
+		// position: String|Number?
+		//		string noting the position of node relative to refNode or a
+		//		number indicating the location in the childNodes collection of refNode.
+		//		Accepted string values are:
+		//
+		//		- before
+		//		- after
+		//		- replace
+		//		- only
+		//		- first
+		//		- last
+		//
+		//		"first" and "last" indicate positions as children of refNode, "replace" replaces refNode,
+		//		"only" replaces all children.  position defaults to "last" if not specified
+		// returns: DOMNode
+		//		Returned values is the first argument resolved to a DOM node.
+		//
+		//		.place() is also a method of `dojo/NodeList`, allowing `dojo.query` node lookups.
+		// example:
+		//		Place a node by string id as the last child of another node by string id:
+		//	|	dojo.place("someNode", "anotherNode");
+		// example:
+		//		Place a node by string id before another node by string id
+		//	|	dojo.place("someNode", "anotherNode", "before");
+		// example:
+		//		Create a Node, and place it in the body element (last child):
+		//	|	dojo.place("<div></div>", dojo.body());
+		// example:
+		//		Put a new LI as the first child of a list by id:
+		//	|	dojo.place("<li></li>", "someUl", "first");
+
+		refNode = dom.byId(refNode);
+		if(typeof node == "string"){ // inline'd type check
+			node = /^\s*</.test(node) ? exports.toDom(node, refNode.ownerDocument) : dom.byId(node);
+		}
+		if(typeof position == "number"){ // inline'd type check
+			var cn = refNode.childNodes;
+			if(!cn.length || cn.length <= position){
+				refNode.appendChild(node);
+			}else{
+				_insertBefore(node, cn[position < 0 ? 0 : position]);
+			}
+		}else{
+			switch(position){
+				case "before":
+					_insertBefore(node, refNode);
+					break;
+				case "after":
+					_insertAfter(node, refNode);
+					break;
+				case "replace":
+					refNode.parentNode.replaceChild(node, refNode);
+					break;
+				case "only":
+					exports.empty(refNode);
+					refNode.appendChild(node);
+					break;
+				case "first":
+					if(refNode.firstChild){
+						_insertBefore(node, refNode.firstChild);
+						break;
+					}
+					// else fallthrough...
+				default: // aka: last
+					refNode.appendChild(node);
+			}
+		}
+		return node; // DomNode
+	};
+
+	var create = exports.create = function create(/*DOMNode|String*/ tag, /*Object*/ attrs, /*DOMNode|String?*/ refNode, /*String?*/ pos){
+		// summary:
+		//		Create an element, allowing for optional attribute decoration
+		//		and placement.
+		// description:
+		//		A DOM Element creation function. A shorthand method for creating a node or
+		//		a fragment, and allowing for a convenient optional attribute setting step,
+		//		as well as an optional DOM placement reference.
+		//
+		//		Attributes are set by passing the optional object through `dojo.setAttr`.
+		//		See `dojo.setAttr` for noted caveats and nuances, and API if applicable.
+		//
+		//		Placement is done via `dojo.place`, assuming the new node to be the action
+		//		node, passing along the optional reference node and position.
+		// tag: DOMNode|String
+		//		A string of the element to create (eg: "div", "a", "p", "li", "script", "br"),
+		//		or an existing DOM node to process.
+		// attrs: Object
+		//		An object-hash of attributes to set on the newly created node.
+		//		Can be null, if you don't want to set any attributes/styles.
+		//		See: `dojo.setAttr` for a description of available attributes.
+		// refNode: DOMNode|String?
+		//		Optional reference node. Used by `dojo.place` to place the newly created
+		//		node somewhere in the dom relative to refNode. Can be a DomNode reference
+		//		or String ID of a node.
+		// pos: String?
+		//		Optional positional reference. Defaults to "last" by way of `dojo.place`,
+		//		though can be set to "first","after","before","last", "replace" or "only"
+		//		to further control the placement of the new node relative to the refNode.
+		//		'refNode' is required if a 'pos' is specified.
+		// example:
+		//		Create a DIV:
+		//	|	var n = dojo.create("div");
+		//
+		// example:
+		//		Create a DIV with content:
+		//	|	var n = dojo.create("div", { innerHTML:"<p>hi</p>" });
+		//
+		// example:
+		//		Place a new DIV in the BODY, with no attributes set
+		//	|	var n = dojo.create("div", null, dojo.body());
+		//
+		// example:
+		//		Create an UL, and populate it with LI's. Place the list as the first-child of a
+		//		node with id="someId":
+		//	|	var ul = dojo.create("ul", null, "someId", "first");
+		//	|	var items = ["one", "two", "three", "four"];
+		//	|	dojo.forEach(items, function(data){
+		//	|		dojo.create("li", { innerHTML: data }, ul);
+		//	|	});
+		//
+		// example:
+		//		Create an anchor, with an href. Place in BODY:
+		//	|	dojo.create("a", { href:"foo.html", title:"Goto FOO!" }, dojo.body());
+		//
+		// example:
+		//		Create a `dojo/NodeList()` from a new element (for syntactic sugar):
+		//	|	dojo.query(dojo.create('div'))
+		//	|		.addClass("newDiv")
+		//	|		.onclick(function(e){ console.log('clicked', e.target) })
+		//	|		.place("#someNode"); // redundant, but cleaner.
+
+		var doc = win.doc;
+		if(refNode){
+			refNode = dom.byId(refNode);
+			doc = refNode.ownerDocument;
+		}
+		if(typeof tag == "string"){ // inline'd type check
+			tag = doc.createElement(tag);
+		}
+		if(attrs){ attr.set(tag, attrs); }
+		if(refNode){ exports.place(tag, refNode, pos); }
+		return tag; // DomNode
+	};
+
+	function _empty(/*DomNode*/ node){
+		if(node.canHaveChildren){
+			try{
+				// fast path
+				node.innerHTML = "";
+				return;
+			}catch(e){
+				// innerHTML is readOnly (e.g. TABLE (sub)elements in quirks mode)
+				// Fall through (saves bytes)
+			}
+		}
+		// SVG/strict elements don't support innerHTML/canHaveChildren, and OBJECT/APPLET elements in quirks node have canHaveChildren=false
+		for(var c; c = node.lastChild;){ // intentional assignment
+			_destroy(c, node); // destroy is better than removeChild so TABLE subelements are removed in proper order
+		}
+	}
+
+	exports.empty = function empty(/*DOMNode|String*/ node){
+		 // summary:
+		 //		safely removes all children of the node.
+		 // node: DOMNode|String
+		 //		a reference to a DOM node or an id.
+		 // example:
+		 //		Destroy node's children byId:
+		 //	|	dojo.empty("someId");
+		 //
+		 // example:
+		 //		Destroy all nodes' children in a list by reference:
+		 //	|	dojo.query(".someNode").forEach(dojo.empty);
+
+		_empty(dom.byId(node));
+	};
+
+
+	function _destroy(/*DomNode*/ node, /*DomNode*/ parent){
+		// in IE quirks, node.canHaveChildren can be false but firstChild can be non-null (OBJECT/APPLET)
+		if(node.firstChild){
+			_empty(node);
+		}
+		if(parent){
+			// removeNode(false) doesn't leak in IE 6+, but removeChild() and removeNode(true) are known to leak under IE 8- while 9+ is TBD.
+			// In IE quirks mode, PARAM nodes as children of OBJECT/APPLET nodes have a removeNode method that does nothing and
+			// the parent node has canHaveChildren=false even though removeChild correctly removes the PARAM children.
+			// In IE, SVG/strict nodes don't have a removeNode method nor a canHaveChildren boolean.
+			has("ie") && parent.canHaveChildren && "removeNode" in node ? node.removeNode(false) : parent.removeChild(node);
+		}
+	}
+	var destroy = exports.destroy = function destroy(/*DOMNode|String*/ node){
+		// summary:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children.
+		//
+		// description:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children. Function only works with DomNodes, and returns nothing.
+		//
+		// node: DOMNode|String
+		//		A String ID or DomNode reference of the element to be destroyed
+		//
+		// example:
+		//		Destroy a node byId:
+		//	|	dojo.destroy("someId");
+		//
+		// example:
+		//		Destroy all nodes in a list by reference:
+		//	|	dojo.query(".someNode").forEach(dojo.destroy);
+
+		node = dom.byId(node);
+		if(!node){ return; }
+		_destroy(node, node.parentNode);
+	};
+});

debian/missing-sources/dojo/dom-prop.js

@@ -0,0 +1,180 @@
+define(["exports", "./_base/kernel", "./sniff", "./_base/lang", "./dom", "./dom-style", "./dom-construct", "./_base/connect"],
+		function(exports, dojo, has, lang, dom, style, ctr, conn){
+	// module:
+	//		dojo/dom-prop
+	// summary:
+	//		This module defines the core dojo DOM properties API.
+
+	// TODOC: summary not showing up in output, see https://github.com/csnover/js-doc-parse/issues/42
+
+	// =============================
+	// Element properties Functions
+	// =============================
+
+	// helper to connect events
+	var _evtHdlrMap = {}, _ctr = 0, _attrId = dojo._scopeName + "attrid";
+
+	exports.names = {
+		// properties renamed to avoid clashes with reserved words
+		"class": "className",
+		"for": "htmlFor",
+		// properties written as camelCase
+		tabindex: "tabIndex",
+		readonly: "readOnly",
+		colspan: "colSpan",
+		frameborder: "frameBorder",
+		rowspan: "rowSpan",
+		valuetype: "valueType"
+	};
+
+	exports.get = function getProp(/*DOMNode|String*/ node, /*String*/ name){
+		// summary:
+		//		Gets a property on an HTML element.
+		// description:
+		//		Handles normalized getting of properties on DOM nodes.
+		//
+		// node: DOMNode|String
+		//		id or reference to the element to get the property on
+		// name: String
+		//		the name of the property to get.
+		// returns:
+		//		the value of the requested property or its default value
+		//
+		// example:
+		//	|	// get the current value of the "foo" property on a node
+		//	|	dojo.getProp(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.getProp("nodeId", "foo");
+
+		node = dom.byId(node);
+		var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+		return node[propName];	// Anything
+	};
+
+	exports.set = function setProp(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
+		// summary:
+		//		Sets a property on an HTML element.
+		// description:
+		//		Handles normalized setting of properties on DOM nodes.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to set the property on
+		// name: String|Object
+		//		the name of the property to set, or a hash object to set
+		//		multiple properties at once.
+		// value: String?
+		//		The value to set for the property
+		// returns:
+		//		the DOM node
+		//
+		// example:
+		//	|	// use prop() to set the tab index
+		//	|	dojo.setProp("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.setProp("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.setProp("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.setProp("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+
+		node = dom.byId(node);
+		var l = arguments.length;
+		if(l == 2 && typeof name != "string"){ // inline'd type check
+			// the object form of setter: the 2nd argument is a dictionary
+			for(var x in name){
+				exports.set(node, x, name[x]);
+			}
+			return node; // DomNode
+		}
+		var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+		if(propName == "style" && typeof value != "string"){ // inline'd type check
+			// special case: setting a style
+			style.set(node, value);
+			return node; // DomNode
+		}
+		if(propName == "innerHTML"){
+			// special case: assigning HTML
+			// the hash lists elements with read-only innerHTML on IE
+			if(has("ie") && node.tagName.toLowerCase() in {col: 1, colgroup: 1,
+						table: 1, tbody: 1, tfoot: 1, thead: 1, tr: 1, title: 1}){
+				ctr.empty(node);
+				node.appendChild(ctr.toDom(value, node.ownerDocument));
+			}else{
+				node[propName] = value;
+			}
+			return node; // DomNode
+		}
+		if(lang.isFunction(value)){
+			// special case: assigning an event handler
+			// clobber if we can
+			var attrId = node[_attrId];
+			if(!attrId){
+				attrId = _ctr++;
+				node[_attrId] = attrId;
+			}
+			if(!_evtHdlrMap[attrId]){
+				_evtHdlrMap[attrId] = {};
+			}
+			var h = _evtHdlrMap[attrId][propName];
+			if(h){
+				//h.remove();
+				conn.disconnect(h);
+			}else{
+				try{
+					delete node[propName];
+				}catch(e){}
+			}
+			// ensure that event objects are normalized, etc.
+			if(value){
+				//_evtHdlrMap[attrId][propName] = on(node, propName, value);
+				_evtHdlrMap[attrId][propName] = conn.connect(node, propName, value);
+			}else{
+				node[propName] = null;
+			}
+			return node; // DomNode
+		}
+		node[propName] = value;
+		return node;	// DomNode
+	};
+});

debian/missing-sources/dojo/dom-style.js

@@ -0,0 +1,312 @@
+define(["./sniff", "./dom"], function(has, dom){
+	// module:
+	//		dojo/dom-style
+
+	// =============================
+	// Style Functions
+	// =============================
+
+	// getComputedStyle drives most of the style code.
+	// Wherever possible, reuse the returned object.
+	//
+	// API functions below that need to access computed styles accept an
+	// optional computedStyle parameter.
+	// If this parameter is omitted, the functions will call getComputedStyle themselves.
+	// This way, calling code can access computedStyle once, and then pass the reference to
+	// multiple API functions.
+
+	// Although we normally eschew argument validation at this
+	// level, here we test argument 'node' for (duck)type,
+	// by testing nodeType, ecause 'document' is the 'parentNode' of 'body'
+	// it is frequently sent to this function even
+	// though it is not Element.
+	var getComputedStyle, style = {
+		// summary:
+		//		This module defines the core dojo DOM style API.
+	};
+	if(has("webkit")){
+		getComputedStyle = function(/*DomNode*/ node){
+			var s;
+			if(node.nodeType == 1){
+				var dv = node.ownerDocument.defaultView;
+				s = dv.getComputedStyle(node, null);
+				if(!s && node.style){
+					node.style.display = "";
+					s = dv.getComputedStyle(node, null);
+				}
+			}
+			return s || {};
+		};
+	}else if(has("ie") && (has("ie") < 9 || has("quirks"))){
+		getComputedStyle = function(node){
+			// IE (as of 7) doesn't expose Element like sane browsers
+			// currentStyle can be null on IE8!
+			return node.nodeType == 1 /* ELEMENT_NODE*/ && node.currentStyle ? node.currentStyle : {};
+		};
+	}else{
+		getComputedStyle = function(node){
+			return node.nodeType == 1 /* ELEMENT_NODE*/ ?
+				node.ownerDocument.defaultView.getComputedStyle(node, null) : {};
+		};
+	}
+	style.getComputedStyle = getComputedStyle;
+	/*=====
+	style.getComputedStyle = function(node){
+		// summary:
+		//		Returns a "computed style" object.
+		//
+		// description:
+		//		Gets a "computed style" object which can be used to gather
+		//		information about the current state of the rendered node.
+		//
+		//		Note that this may behave differently on different browsers.
+		//		Values may have different formats and value encodings across
+		//		browsers.
+		//
+		//		Note also that this method is expensive.  Wherever possible,
+		//		reuse the returned object.
+		//
+		//		Use the dojo.style() method for more consistent (pixelized)
+		//		return values.
+		//
+		// node: DOMNode
+		//		A reference to a DOM node. Does NOT support taking an
+		//		ID string for speed reasons.
+		// example:
+		//	|	dojo.getComputedStyle(dojo.byId('foo')).borderWidth;
+		//
+		// example:
+		//		Reusing the returned object, avoiding multiple lookups:
+		//	|	var cs = dojo.getComputedStyle(dojo.byId("someNode"));
+		//	|	var w = cs.width, h = cs.height;
+		return; // CSS2Properties
+	};
+	=====*/
+
+	var toPixel;
+	if(!has("ie")){
+		toPixel = function(element, value){
+			// style values can be floats, client code may want
+			// to round for integer pixels.
+			return parseFloat(value) || 0;
+		};
+	}else{
+		toPixel = function(element, avalue){
+			if(!avalue){ return 0; }
+			// on IE7, medium is usually 4 pixels
+			if(avalue == "medium"){ return 4; }
+			// style values can be floats, client code may
+			// want to round this value for integer pixels.
+			if(avalue.slice && avalue.slice(-2) == 'px'){ return parseFloat(avalue); }
+			var s = element.style, rs = element.runtimeStyle, cs = element.currentStyle,
+				sLeft = s.left, rsLeft = rs.left;
+			rs.left = cs.left;
+			try{
+				// 'avalue' may be incompatible with style.left, which can cause IE to throw
+				// this has been observed for border widths using "thin", "medium", "thick" constants
+				// those particular constants could be trapped by a lookup
+				// but perhaps there are more
+				s.left = avalue;
+				avalue = s.pixelLeft;
+			}catch(e){
+				avalue = 0;
+			}
+			s.left = sLeft;
+			rs.left = rsLeft;
+			return avalue;
+		};
+	}
+	style.toPixelValue = toPixel;
+	/*=====
+	style.toPixelValue = function(node, value){
+		// summary:
+		//		converts style value to pixels on IE or return a numeric value.
+		// node: DOMNode
+		// value: String
+		// returns: Number
+	};
+	=====*/
+
+	// FIXME: there opacity quirks on FF that we haven't ported over. Hrm.
+
+	var astr = "DXImageTransform.Microsoft.Alpha";
+	var af = function(n, f){
+		try{
+			return n.filters.item(astr);
+		}catch(e){
+			return f ? {} : null;
+		}
+	};
+
+	var _getOpacity =
+		has("ie") < 9 || (has("ie") < 10 && has("quirks")) ? function(node){
+			try{
+				return af(node).Opacity / 100; // Number
+			}catch(e){
+				return 1; // Number
+			}
+		} :
+		function(node){
+			return getComputedStyle(node).opacity;
+		};
+
+	var _setOpacity =
+		has("ie") < 9 || (has("ie") < 10 && has("quirks")) ? function(/*DomNode*/ node, /*Number*/ opacity){
+			if(opacity === ""){ opacity = 1; }
+			var ov = opacity * 100, fullyOpaque = opacity === 1;
+
+			// on IE7 Alpha(Filter opacity=100) makes text look fuzzy so disable it altogether (bug #2661),
+			// but still update the opacity value so we can get a correct reading if it is read later:
+			// af(node, 1).Enabled = !fullyOpaque;
+
+			if(fullyOpaque){
+				node.style.zoom = "";
+				if(af(node)){
+					node.style.filter = node.style.filter.replace(
+						new RegExp("\\s*progid:" + astr + "\\([^\\)]+?\\)", "i"), "");
+				}
+			}else{
+				node.style.zoom = 1;
+				if(af(node)){
+					af(node, 1).Opacity = ov;
+				}else{
+					node.style.filter += " progid:" + astr + "(Opacity=" + ov + ")";
+				}
+				af(node, 1).Enabled = true;
+			}
+
+			if(node.tagName.toLowerCase() == "tr"){
+				for(var td = node.firstChild; td; td = td.nextSibling){
+					if(td.tagName.toLowerCase() == "td"){
+						_setOpacity(td, opacity);
+					}
+				}
+			}
+			return opacity;
+		} :
+		function(node, opacity){
+			return node.style.opacity = opacity;
+		};
+
+	var _pixelNamesCache = {
+		left: true, top: true
+	};
+	var _pixelRegExp = /margin|padding|width|height|max|min|offset/; // |border
+	function _toStyleValue(node, type, value){
+		//TODO: should we really be doing string case conversion here? Should we cache it? Need to profile!
+		type = type.toLowerCase();
+		if(has("ie")){
+			if(value == "auto"){
+				if(type == "height"){ return node.offsetHeight; }
+				if(type == "width"){ return node.offsetWidth; }
+			}
+			if(type == "fontweight"){
+				switch(value){
+					case 700: return "bold";
+					case 400:
+					default: return "normal";
+				}
+			}
+		}
+		if(!(type in _pixelNamesCache)){
+			_pixelNamesCache[type] = _pixelRegExp.test(type);
+		}
+		return _pixelNamesCache[type] ? toPixel(node, value) : value;
+	}
+
+	var _floatAliases = {cssFloat: 1, styleFloat: 1, "float": 1};
+
+	// public API
+
+	style.get = function getStyle(/*DOMNode|String*/ node, /*String?*/ name){
+		// summary:
+		//		Accesses styles on a node.
+		// description:
+		//		Getting the style value uses the computed style for the node, so the value
+		//		will be a calculated value, not just the immediate node.style value.
+		//		Also when getting values, use specific style names,
+		//		like "borderBottomWidth" instead of "border" since compound values like
+		//		"border" are not necessarily reflected as expected.
+		//		If you want to get node dimensions, use `dojo.marginBox()`,
+		//		`dojo.contentBox()` or `dojo.position()`.
+		// node: DOMNode|String
+		//		id or reference to node to get style for
+		// name: String?
+		//		the style property to get
+		// example:
+		//		Passing only an ID or node returns the computed style object of
+		//		the node:
+		//	|	dojo.getStyle("thinger");
+		// example:
+		//		Passing a node and a style property returns the current
+		//		normalized, computed value for that property:
+		//	|	dojo.getStyle("thinger", "opacity"); // 1 by default
+
+		var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+		if(l == 2 && op){
+			return _getOpacity(n);
+		}
+		name = _floatAliases[name] ? "cssFloat" in n.style ? "cssFloat" : "styleFloat" : name;
+		var s = style.getComputedStyle(n);
+		return (l == 1) ? s : _toStyleValue(n, name, s[name] || n.style[name]); /* CSS2Properties||String||Number */
+	};
+
+	style.set = function setStyle(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
+		// summary:
+		//		Sets styles on a node.
+		// node: DOMNode|String
+		//		id or reference to node to set style for
+		// name: String|Object
+		//		the style property to set in DOM-accessor format
+		//		("borderWidth", not "border-width") or an object with key/value
+		//		pairs suitable for setting each property.
+		// value: String?
+		//		If passed, sets value on the node for style, handling
+		//		cross-browser concerns.  When setting a pixel value,
+		//		be sure to include "px" in the value. For instance, top: "200px".
+		//		Otherwise, in some cases, some browsers will not apply the style.
+		//
+		// example:
+		//		Passing a node, a style property, and a value changes the
+		//		current display of the node and returns the new computed value
+		//	|	dojo.setStyle("thinger", "opacity", 0.5); // == 0.5
+		//
+		// example:
+		//		Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
+		//	|	dojo.setStyle("thinger", {
+		//	|		"opacity": 0.5,
+		//	|		"border": "3px solid black",
+		//	|		"height": "300px"
+		//	|	});
+		//
+		// example:
+		//		When the CSS style property is hyphenated, the JavaScript property is camelCased.
+		//		font-size becomes fontSize, and so on.
+		//	|	dojo.setStyle("thinger",{
+		//	|		fontSize:"14pt",
+		//	|		letterSpacing:"1.2em"
+		//	|	});
+		//
+		// example:
+		//		dojo/NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
+		//		dojo.style() on every element of the list. See: `dojo.query()` and `dojo/NodeList`
+		//	|	dojo.query(".someClassName").style("visibility","hidden");
+		//	|	// or
+		//	|	dojo.query("#baz > div").style({
+		//	|		opacity:0.75,
+		//	|		fontSize:"13pt"
+		//	|	});
+
+		var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+		name = _floatAliases[name] ? "cssFloat" in n.style ? "cssFloat" : "styleFloat" : name;
+		if(l == 3){
+			return op ? _setOpacity(n, value) : n.style[name] = value; // Number
+		}
+		for(var x in name){
+			style.set(node, x, name[x]);
+		}
+		return style.getComputedStyle(n);
+	};
+
+	return style;
+});

debian/missing-sources/dojo/dom.js

@@ -0,0 +1,185 @@
+define(["./sniff", "./_base/window"],
+		function(has, win){
+	// module:
+	//		dojo/dom
+
+	// FIXME: need to add unit tests for all the semi-public methods
+
+	if(has("ie") <= 7){
+		try{
+			document.execCommand("BackgroundImageCache", false, true);
+		}catch(e){
+			// sane browsers don't have cache "issues"
+		}
+	}
+
+	// =============================
+	// DOM Functions
+	// =============================
+
+	// the result object
+	var dom = {
+		// summary:
+		//		This module defines the core dojo DOM API.
+	};
+
+	if(has("ie")){
+		dom.byId = function(id, doc){
+			if(typeof id != "string"){
+				return id;
+			}
+			var _d = doc || win.doc, te = id && _d.getElementById(id);
+			// attributes.id.value is better than just id in case the
+			// user has a name=id inside a form
+			if(te && (te.attributes.id.value == id || te.id == id)){
+				return te;
+			}else{
+				var eles = _d.all[id];
+				if(!eles || eles.nodeName){
+					eles = [eles];
+				}
+				// if more than 1, choose first with the correct id
+				var i = 0;
+				while((te = eles[i++])){
+					if((te.attributes && te.attributes.id && te.attributes.id.value == id) || te.id == id){
+						return te;
+					}
+				}
+			}
+		};
+	}else{
+		dom.byId = function(id, doc){
+			// inline'd type check.
+			// be sure to return null per documentation, to match IE branch.
+			return ((typeof id == "string") ? (doc || win.doc).getElementById(id) : id) || null; // DOMNode
+		};
+	}
+	/*=====
+	 dom.byId = function(id, doc){
+		 // summary:
+		 //		Returns DOM node with matching `id` attribute or falsy value (ex: null or undefined)
+		 //		if not found.  If `id` is a DomNode, this function is a no-op.
+		 //
+		 // id: String|DOMNode
+		 //		A string to match an HTML id attribute or a reference to a DOM Node
+		 //
+		 // doc: Document?
+		 //		Document to work in. Defaults to the current value of
+		 //		dojo.doc.  Can be used to retrieve
+		 //		node references from other documents.
+		 //
+		 // example:
+		 //		Look up a node by ID:
+		 //	|	var n = dojo.byId("foo");
+		 //
+		 // example:
+		 //		Check if a node exists, and use it.
+		 //	|	var n = dojo.byId("bar");
+		 //	|	if(n){ doStuff() ... }
+		 //
+		 // example:
+		 //		Allow string or DomNode references to be passed to a custom function:
+		 //	|	var foo = function(nodeOrId){
+		 //	|		nodeOrId = dojo.byId(nodeOrId);
+		 //	|		// ... more stuff
+		 //	|	}
+	 };
+	 =====*/
+
+	dom.isDescendant = function(/*DOMNode|String*/ node, /*DOMNode|String*/ ancestor){
+		// summary:
+		//		Returns true if node is a descendant of ancestor
+		// node: DOMNode|String
+		//		string id or node reference to test
+		// ancestor: DOMNode|String
+		//		string id or node reference of potential parent to test against
+		//
+		// example:
+		//		Test is node id="bar" is a descendant of node id="foo"
+		//	|	if(dojo.isDescendant("bar", "foo")){ ... }
+
+		try{
+			node = dom.byId(node);
+			ancestor = dom.byId(ancestor);
+			while(node){
+				if(node == ancestor){
+					return true; // Boolean
+				}
+				node = node.parentNode;
+			}
+		}catch(e){ /* squelch, return false */ }
+		return false; // Boolean
+	};
+
+
+	// TODO: do we need setSelectable in the base?
+
+	// Add feature test for user-select CSS property
+	// (currently known to work in all but IE < 10 and Opera)
+	has.add("css-user-select", function(global, doc, element){
+		// Avoid exception when dom.js is loaded in non-browser environments
+		if(!element){ return false; }
+		
+		var style = element.style;
+		var prefixes = ["Khtml", "O", "ms", "Moz", "Webkit"],
+			i = prefixes.length,
+			name = "userSelect",
+			prefix;
+
+		// Iterate prefixes from most to least likely
+		do{
+			if(typeof style[name] !== "undefined"){
+				// Supported; return property name
+				return name;
+			}
+		}while(i-- && (name = prefixes[i] + "UserSelect"));
+
+		// Not supported if we didn't return before now
+		return false;
+	});
+
+	/*=====
+	dom.setSelectable = function(node, selectable){
+		// summary:
+		//		Enable or disable selection on a node
+		// node: DOMNode|String
+		//		id or reference to node
+		// selectable: Boolean
+		//		state to put the node in. false indicates unselectable, true
+		//		allows selection.
+		// example:
+		//		Make the node id="bar" unselectable
+		//	|	dojo.setSelectable("bar");
+		// example:
+		//		Make the node id="bar" selectable
+		//	|	dojo.setSelectable("bar", true);
+	};
+	=====*/
+
+	var cssUserSelect = has("css-user-select");
+	dom.setSelectable = cssUserSelect ? function(node, selectable){
+		// css-user-select returns a (possibly vendor-prefixed) CSS property name
+		dom.byId(node).style[cssUserSelect] = selectable ? "" : "none";
+	} : function(node, selectable){
+		node = dom.byId(node);
+
+		// (IE < 10 / Opera) Fall back to setting/removing the
+		// unselectable attribute on the element and all its children
+		var nodes = node.getElementsByTagName("*"),
+			i = nodes.length;
+
+		if(selectable){
+			node.removeAttribute("unselectable");
+			while(i--){
+				nodes[i].removeAttribute("unselectable");
+			}
+		}else{
+			node.setAttribute("unselectable", "on");
+			while(i--){
+				nodes[i].setAttribute("unselectable", "on");
+			}
+		}
+	};
+
+	return dom;
+});

debian/missing-sources/dojo/domReady.js

@@ -0,0 +1,124 @@
+define(['./has'], function(has){
+	var global = this,
+		doc = document,
+		readyStates = { 'loaded': 1, 'complete': 1 },
+		fixReadyState = typeof doc.readyState != "string",
+		ready = !!readyStates[doc.readyState],
+		readyQ = [],
+		recursiveGuard;
+
+	function domReady(callback){
+		// summary:
+		//		Plugin to delay require()/define() callback from firing until the DOM has finished loading.
+		readyQ.push(callback);
+		if(ready){ processQ(); }
+	}
+	domReady.load = function(id, req, load){
+		domReady(load);
+	};
+
+	// Export queue so that ready() can check if it's empty or not.
+	domReady._Q = readyQ;
+	domReady._onQEmpty = function(){
+		// summary:
+		//		Private method overridden by dojo/ready, to notify when everything in the
+		//		domReady queue has been processed.  Do not use directly.
+		//		Will be removed in 2.0, along with domReady._Q.
+	};
+
+	// For FF <= 3.5
+	if(fixReadyState){ doc.readyState = "loading"; }
+
+	function processQ(){
+		// Calls all functions in the queue in order, unless processQ() is already running, in which case just return
+
+		if(recursiveGuard){ return; }
+		recursiveGuard = true;
+
+		while(readyQ.length){
+			try{
+				(readyQ.shift())(doc);
+			}catch(err){
+				console.log("Error on domReady callback: " + err);
+			}
+		}
+
+		recursiveGuard = false;
+
+		// Notification for dojo/ready.  Remove for 2.0.
+		// Note that this could add more tasks to the ready queue.
+		domReady._onQEmpty();
+	}
+
+	if(!ready){
+		var tests = [],
+			detectReady = function(evt){
+				evt = evt || global.event;
+				if(ready || (evt.type == "readystatechange" && !readyStates[doc.readyState])){ return; }
+
+				// For FF <= 3.5
+				if(fixReadyState){ doc.readyState = "complete"; }
+
+				ready = 1;
+				processQ();
+			},
+			on = function(node, event){
+				node.addEventListener(event, detectReady, false);
+				readyQ.push(function(){ node.removeEventListener(event, detectReady, false); });
+			};
+
+		if(!has("dom-addeventlistener")){
+			on = function(node, event){
+				event = "on" + event;
+				node.attachEvent(event, detectReady);
+				readyQ.push(function(){ node.detachEvent(event, detectReady); });
+			};
+
+			var div = doc.createElement("div");
+			try{
+				if(div.doScroll && global.frameElement === null){
+					// the doScroll test is only useful if we're in the top-most frame
+					tests.push(function(){
+						// Derived with permission from Diego Perini's IEContentLoaded
+						// http://javascript.nwbox.com/IEContentLoaded/
+						try{
+							div.doScroll("left");
+							return 1;
+						}catch(e){}
+					});
+				}
+			}catch(e){}
+		}
+
+		on(doc, "DOMContentLoaded");
+		on(global, "load");
+
+		if("onreadystatechange" in doc){
+			on(doc, "readystatechange");
+		}else if(!fixReadyState){
+			// if the ready state property exists and there's
+			// no readystatechange event, poll for the state
+			// to change
+			tests.push(function(){
+				return readyStates[doc.readyState];
+			});
+		}
+
+		if(tests.length){
+			var poller = function(){
+				if(ready){ return; }
+				var i = tests.length;
+				while(i--){
+					if(tests[i]()){
+						detectReady("poller");
+						return;
+					}
+				}
+				setTimeout(poller, 30);
+			};
+			poller();
+		}
+	}
+
+	return domReady;
+});

debian/missing-sources/dojo/hash.js

@@ -0,0 +1,256 @@
+define(["./_base/kernel", "require", "./_base/config", "./aspect", "./_base/lang", "./topic", "./domReady", "./sniff"],
+	function(dojo, require, config, aspect, lang, topic, domReady, has){
+
+	// module:
+	//		dojo/hash
+
+	dojo.hash = function(/* String? */ hash, /* Boolean? */ replace){
+		// summary:
+		//		Gets or sets the hash string in the browser URL.
+		// description:
+		//		Handles getting and setting of location.hash.
+		//
+		//		 - If no arguments are passed, acts as a getter.
+		//		 - If a string is passed, acts as a setter.
+		// hash:
+		//		the hash is set - #string.
+		// replace:
+		//		If true, updates the hash value in the current history
+		//		state instead of creating a new history state.
+		// returns:
+		//		when used as a getter, returns the current hash string.
+		//		when used as a setter, returns the new hash string.
+		// example:
+		//	|	topic.subscribe("/dojo/hashchange", context, callback);
+		//	|
+		//	|	function callback (hashValue){
+		//	|		// do something based on the hash value.
+		//	|	}
+
+		// getter
+		if(!arguments.length){
+			return _getHash();
+		}
+		// setter
+		if(hash.charAt(0) == "#"){
+			hash = hash.substring(1);
+		}
+		if(replace){
+			_replace(hash);
+		}else{
+			location.href = "#" + hash;
+		}
+		return hash; // String
+	};
+
+	// Global vars
+	var _recentHash, _ieUriMonitor, _connect,
+		_pollFrequency = config.hashPollFrequency || 100;
+
+	//Internal functions
+	function _getSegment(str, delimiter){
+		var i = str.indexOf(delimiter);
+		return (i >= 0) ? str.substring(i+1) : "";
+	}
+
+	function _getHash(){
+		return _getSegment(location.href, "#");
+	}
+
+	function _dispatchEvent(){
+		topic.publish("/dojo/hashchange", _getHash());
+	}
+
+	function _pollLocation(){
+		if(_getHash() === _recentHash){
+			return;
+		}
+		_recentHash = _getHash();
+		_dispatchEvent();
+	}
+
+	function _replace(hash){
+		if(_ieUriMonitor){
+			if(_ieUriMonitor.isTransitioning()){
+				setTimeout(lang.hitch(null,_replace,hash), _pollFrequency);
+				return;
+			}
+			var href = _ieUriMonitor.iframe.location.href;
+			var index = href.indexOf('?');
+			// main frame will detect and update itself
+			_ieUriMonitor.iframe.location.replace(href.substring(0, index) + "?" + hash);
+			return;
+		}
+		location.replace("#"+hash);
+		!_connect && _pollLocation();
+	}
+
+	function IEUriMonitor(){
+		// summary:
+		//		Determine if the browser's URI has changed or if the user has pressed the
+		//		back or forward button. If so, call _dispatchEvent.
+		//
+		// description:
+		//		IE doesn't add changes to the URI's hash into the history unless the hash
+		//		value corresponds to an actual named anchor in the document. To get around
+		//		this IE difference, we use a background IFrame to maintain a back-forward
+		//		history, by updating the IFrame's query string to correspond to the
+		//		value of the main browser location's hash value.
+		//
+		//		E.g. if the value of the browser window's location changes to
+		//
+		//		#action=someAction
+		//
+		//		... then we'd update the IFrame's source to:
+		//
+		//		?action=someAction
+		//
+		//		This design leads to a somewhat complex state machine, which is
+		//		described below:
+		//
+		//		####s1
+		//
+		//		Stable state - neither the window's location has changed nor
+		//		has the IFrame's location. Note that this is the 99.9% case, so
+		//		we optimize for it.
+		//
+		//		Transitions: s1, s2, s3
+		//
+		//		####s2
+		//
+		//		Window's location changed - when a user clicks a hyperlink or
+		//		code programmatically changes the window's URI.
+		//
+		//		Transitions: s4
+		//
+		//		####s3
+		//
+		//		Iframe's location changed as a result of user pressing back or
+		//		forward - when the user presses back or forward, the location of
+		//		the background's iframe changes to the previous or next value in
+		//		its history.
+		//
+		//		Transitions: s1
+		//
+		//		####s4
+		//
+		//		IEUriMonitor has programmatically changed the location of the
+		//		background iframe, but it's location hasn't yet changed. In this
+		//		case we do nothing because we need to wait for the iframe's
+		//		location to reflect its actual state.
+		//
+		//		Transitions: s4, s5
+		//
+		//		####s5
+		//
+		//		IEUriMonitor has programmatically changed the location of the
+		//		background iframe, and the iframe's location has caught up with
+		//		reality. In this case we need to transition to s1.
+		//
+		//		Transitions: s1
+		//
+		//		The hashchange event is always dispatched on the transition back to s1.
+
+
+		// create and append iframe
+		var ifr = document.createElement("iframe"),
+			IFRAME_ID = "dojo-hash-iframe",
+			ifrSrc = config.dojoBlankHtmlUrl || require.toUrl("./resources/blank.html");
+
+		if(config.useXDomain && !config.dojoBlankHtmlUrl){
+			console.warn("dojo.hash: When using cross-domain Dojo builds,"
+				+ " please save dojo/resources/blank.html to your domain and set djConfig.dojoBlankHtmlUrl"
+				+ " to the path on your domain to blank.html");
+		}
+
+		ifr.id = IFRAME_ID;
+		ifr.src = ifrSrc + "?" + _getHash();
+		ifr.style.display = "none";
+		document.body.appendChild(ifr);
+
+		this.iframe = dojo.global[IFRAME_ID];
+		var recentIframeQuery, transitioning, expectedIFrameQuery, docTitle, ifrOffline,
+			iframeLoc = this.iframe.location;
+
+		function resetState(){
+			_recentHash = _getHash();
+			recentIframeQuery = ifrOffline ? _recentHash : _getSegment(iframeLoc.href, "?");
+			transitioning = false;
+			expectedIFrameQuery = null;
+		}
+
+		this.isTransitioning = function(){
+			return transitioning;
+		};
+
+		this.pollLocation = function(){
+			if(!ifrOffline){
+				try{
+					//see if we can access the iframe's location without a permission denied error
+					var iframeSearch = _getSegment(iframeLoc.href, "?");
+					//good, the iframe is same origin (no thrown exception)
+					if(document.title != docTitle){ //sync title of main window with title of iframe.
+						docTitle = this.iframe.document.title = document.title;
+					}
+				}catch(e){
+					//permission denied - server cannot be reached.
+					ifrOffline = true;
+					console.error("dojo.hash: Error adding history entry. Server unreachable.");
+				}
+			}
+			var hash = _getHash();
+			if(transitioning && _recentHash === hash){
+				// we're in an iframe transition (s4 or s5)
+				if(ifrOffline || iframeSearch === expectedIFrameQuery){
+					// s5 (iframe caught up to main window or iframe offline), transition back to s1
+					resetState();
+					_dispatchEvent();
+				}else{
+					// s4 (waiting for iframe to catch up to main window)
+					setTimeout(lang.hitch(this,this.pollLocation),0);
+					return;
+				}
+			}else if(_recentHash === hash && (ifrOffline || recentIframeQuery === iframeSearch)){
+				// we're in stable state (s1, iframe query == main window hash), do nothing
+			}else{
+				// the user has initiated a URL change somehow.
+				// sync iframe query <-> main window hash
+				if(_recentHash !== hash){
+					// s2 (main window location changed), set iframe url and transition to s4
+					_recentHash = hash;
+					transitioning = true;
+					expectedIFrameQuery = hash;
+					ifr.src = ifrSrc + "?" + expectedIFrameQuery;
+					ifrOffline = false; //we're updating the iframe src - set offline to false so we can check again on next poll.
+					setTimeout(lang.hitch(this,this.pollLocation),0); //yielded transition to s4 while iframe reloads.
+					return;
+				}else if(!ifrOffline){
+					// s3 (iframe location changed via back/forward button), set main window url and transition to s1.
+					location.href = "#" + iframeLoc.search.substring(1);
+					resetState();
+					_dispatchEvent();
+				}
+			}
+			setTimeout(lang.hitch(this,this.pollLocation), _pollFrequency);
+		};
+		resetState(); // initialize state (transition to s1)
+		setTimeout(lang.hitch(this,this.pollLocation), _pollFrequency);
+	}
+	domReady(function(){
+		if("onhashchange" in dojo.global && (!has("ie") || (has("ie") >= 8 && document.compatMode != "BackCompat"))){	//need this IE browser test because "onhashchange" exists in IE8 in IE7 mode
+			_connect = aspect.after(dojo.global,"onhashchange",_dispatchEvent, true);
+		}else{
+			if(document.addEventListener){ // Non-IE
+				_recentHash = _getHash();
+				setInterval(_pollLocation, _pollFrequency); //Poll the window location for changes
+			}else if(document.attachEvent){ // IE7-
+				//Use hidden iframe in versions of IE that don't have onhashchange event
+				_ieUriMonitor = new IEUriMonitor();
+			}
+			// else non-supported browser, do nothing.
+		}
+	});
+
+	return dojo.hash;
+
+});

debian/missing-sources/dojo/io-query.js

@@ -0,0 +1,97 @@
+define(["./_base/lang"], function(lang){
+
+// module:
+//		dojo/io-query
+
+var backstop = {};
+
+return {
+// summary:
+//		This module defines query string processing functions.
+
+	objectToQuery: function objectToQuery(/*Object*/ map){
+		// summary:
+        //		takes a name/value mapping object and returns a string representing
+        //		a URL-encoded version of that object.
+        // example:
+        //		this object:
+        //
+        //	|	{
+        //	|		blah: "blah",
+        //	|		multi: [
+        //	|			"thud",
+        //	|			"thonk"
+        //	|		]
+        //	|	};
+        //
+        //		yields the following query string:
+        //
+        //	|	"blah=blah&multi=thud&multi=thonk"
+
+        // FIXME: need to implement encodeAscii!!
+        var enc = encodeURIComponent, pairs = [];
+        for(var name in map){
+            var value = map[name];
+            if(value != backstop[name]){
+                var assign = enc(name) + "=";
+                if(lang.isArray(value)){
+                    for(var i = 0, l = value.length; i < l; ++i){
+                        pairs.push(assign + enc(value[i]));
+                    }
+                }else{
+                    pairs.push(assign + enc(value));
+                }
+            }
+        }
+        return pairs.join("&"); // String
+    },
+
+	queryToObject: function queryToObject(/*String*/ str){
+        // summary:
+        //		Create an object representing a de-serialized query section of a
+        //		URL. Query keys with multiple values are returned in an array.
+        //
+        // example:
+        //		This string:
+        //
+        //	|		"foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
+        //
+        //		results in this object structure:
+        //
+        //	|		{
+        //	|			foo: [ "bar", "baz" ],
+        //	|			thinger: " spaces =blah",
+        //	|			zonk: "blarg"
+        //	|		}
+        //
+        //		Note that spaces and other urlencoded entities are correctly
+        //		handled.
+
+        // FIXME: should we grab the URL string if we're not passed one?
+        var dec = decodeURIComponent, qp = str.split("&"), ret = {}, name, val;
+        for(var i = 0, l = qp.length, item; i < l; ++i){
+            item = qp[i];
+            if(item.length){
+                var s = item.indexOf("=");
+                if(s < 0){
+                    name = dec(item);
+                    val = "";
+                }else{
+                    name = dec(item.slice(0, s));
+                    val  = dec(item.slice(s + 1));
+                }
+                if(typeof ret[name] == "string"){ // inline'd type check
+                    ret[name] = [ret[name]];
+                }
+
+                if(lang.isArray(ret[name])){
+                    ret[name].push(val);
+                }else{
+                    ret[name] = val;
+                }
+            }
+        }
+        return ret; // Object
+    }
+};
+});

debian/missing-sources/dojo/keys.js

@@ -0,0 +1,77 @@
+define(["./_base/kernel", "./sniff"], function(dojo, has){
+
+	// module:
+	//		dojo/keys
+
+	return dojo.keys = {
+		// summary:
+		//		Definitions for common key values.  Client code should test keyCode against these named constants,
+		//		as the actual codes can vary by browser.
+
+		BACKSPACE: 8,
+		TAB: 9,
+		CLEAR: 12,
+		ENTER: 13,
+		SHIFT: 16,
+		CTRL: 17,
+		ALT: 18,
+		META: has("webkit") ? 91 : 224,		// the apple key on macs
+		PAUSE: 19,
+		CAPS_LOCK: 20,
+		ESCAPE: 27,
+		SPACE: 32,
+		PAGE_UP: 33,
+		PAGE_DOWN: 34,
+		END: 35,
+		HOME: 36,
+		LEFT_ARROW: 37,
+		UP_ARROW: 38,
+		RIGHT_ARROW: 39,
+		DOWN_ARROW: 40,
+		INSERT: 45,
+		DELETE: 46,
+		HELP: 47,
+		LEFT_WINDOW: 91,
+		RIGHT_WINDOW: 92,
+		SELECT: 93,
+		NUMPAD_0: 96,
+		NUMPAD_1: 97,
+		NUMPAD_2: 98,
+		NUMPAD_3: 99,
+		NUMPAD_4: 100,
+		NUMPAD_5: 101,
+		NUMPAD_6: 102,
+		NUMPAD_7: 103,
+		NUMPAD_8: 104,
+		NUMPAD_9: 105,
+		NUMPAD_MULTIPLY: 106,
+		NUMPAD_PLUS: 107,
+		NUMPAD_ENTER: 108,
+		NUMPAD_MINUS: 109,
+		NUMPAD_PERIOD: 110,
+		NUMPAD_DIVIDE: 111,
+		F1: 112,
+		F2: 113,
+		F3: 114,
+		F4: 115,
+		F5: 116,
+		F6: 117,
+		F7: 118,
+		F8: 119,
+		F9: 120,
+		F10: 121,
+		F11: 122,
+		F12: 123,
+		F13: 124,
+		F14: 125,
+		F15: 126,
+		NUM_LOCK: 144,
+		SCROLL_LOCK: 145,
+		UP_DPAD: 175,
+		DOWN_DPAD: 176,
+		LEFT_DPAD: 177,
+		RIGHT_DPAD: 178,
+		// virtual key mapping
+		copyKey: has("mac") && !has("air") ? (has("safari") ? 91 : 224 ) : 17
+	};
+});

debian/missing-sources/dojo/on.js

@@ -0,0 +1,531 @@
+define(["./has!dom-addeventlistener?:./aspect", "./_base/kernel", "./sniff"], function(aspect, dojo, has){
+
+	"use strict";
+	if(has("dom")){ // check to make sure we are in a browser, this module should work anywhere
+		var major = window.ScriptEngineMajorVersion;
+		has.add("jscript", major && (major() + ScriptEngineMinorVersion() / 10));
+		has.add("event-orientationchange", has("touch") && !has("android")); // TODO: how do we detect this?
+		has.add("event-stopimmediatepropagation", window.Event && !!window.Event.prototype && !!window.Event.prototype.stopImmediatePropagation);
+		has.add("event-focusin", function(global, doc, element){
+			// All browsers except firefox support focusin, but too hard to feature test webkit since element.onfocusin
+			// is undefined.  Just return true for IE and use fallback path for other browsers.
+			return !!element.attachEvent;
+		});
+	}
+	var on = function(target, type, listener, dontFix){
+		// summary:
+		//		A function that provides core event listening functionality. With this function
+		//		you can provide a target, event type, and listener to be notified of
+		//		future matching events that are fired.
+		// target: Element|Object
+		//		This is the target object or DOM element that to receive events from
+		// type: String|Function
+		//		This is the name of the event to listen for or an extension event type.
+		// listener: Function
+		//		This is the function that should be called when the event fires.
+		// returns: Object
+		//		An object with a remove() method that can be used to stop listening for this
+		//		event.
+		// description:
+		//		To listen for "click" events on a button node, we can do:
+		//		|	define(["dojo/on"], function(listen){
+		//		|		on(button, "click", clickHandler);
+		//		|		...
+		//		Evented JavaScript objects can also have their own events.
+		//		|	var obj = new Evented;
+		//		|	on(obj, "foo", fooHandler);
+		//		And then we could publish a "foo" event:
+		//		|	on.emit(obj, "foo", {key: "value"});
+		//		We can use extension events as well. For example, you could listen for a tap gesture:
+		//		|	define(["dojo/on", "dojo/gesture/tap", function(listen, tap){
+		//		|		on(button, tap, tapHandler);
+		//		|		...
+		//		which would trigger fooHandler. Note that for a simple object this is equivalent to calling:
+		//		|	obj.onfoo({key:"value"});
+		//		If you use on.emit on a DOM node, it will use native event dispatching when possible.
+
+		if(typeof target.on == "function" && typeof type != "function" && !target.nodeType){
+			// delegate to the target's on() method, so it can handle it's own listening if it wants (unless it 
+			// is DOM node and we may be dealing with jQuery or Prototype's incompatible addition to the
+			// Element prototype 
+			return target.on(type, listener);
+		}
+		// delegate to main listener code
+		return on.parse(target, type, listener, addListener, dontFix, this);
+	};
+	on.pausable =  function(target, type, listener, dontFix){
+		// summary:
+		//		This function acts the same as on(), but with pausable functionality. The
+		//		returned signal object has pause() and resume() functions. Calling the
+		//		pause() method will cause the listener to not be called for future events. Calling the
+		//		resume() method will cause the listener to again be called for future events.
+		var paused;
+		var signal = on(target, type, function(){
+			if(!paused){
+				return listener.apply(this, arguments);
+			}
+		}, dontFix);
+		signal.pause = function(){
+			paused = true;
+		};
+		signal.resume = function(){
+			paused = false;
+		};
+		return signal;
+	};
+	on.once = function(target, type, listener, dontFix){
+		// summary:
+		//		This function acts the same as on(), but will only call the listener once. The 
+		//		listener will be called for the first
+		//		event that takes place and then listener will automatically be removed.
+		var signal = on(target, type, function(){
+			// remove this listener
+			signal.remove();
+			// proceed to call the listener
+			return listener.apply(this, arguments);
+		});
+		return signal;
+	};
+	on.parse = function(target, type, listener, addListener, dontFix, matchesTarget){
+		if(type.call){
+			// event handler function
+			// on(node, touch.press, touchListener);
+			return type.call(matchesTarget, target, listener);
+		}
+
+		if(type.indexOf(",") > -1){
+			// we allow comma delimited event names, so you can register for multiple events at once
+			var events = type.split(/\s*,\s*/);
+			var handles = [];
+			var i = 0;
+			var eventName;
+			while(eventName = events[i++]){
+				handles.push(addListener(target, eventName, listener, dontFix, matchesTarget));
+			}
+			handles.remove = function(){
+				for(var i = 0; i < handles.length; i++){
+					handles[i].remove();
+				}
+			};
+			return handles;
+		}
+		return addListener(target, type, listener, dontFix, matchesTarget);
+	};
+	var touchEvents = /^touch/;
+	function addListener(target, type, listener, dontFix, matchesTarget){
+		// event delegation:
+		var selector = type.match(/(.*):(.*)/);
+		// if we have a selector:event, the last one is interpreted as an event, and we use event delegation
+		if(selector){
+			type = selector[2];
+			selector = selector[1];
+			// create the extension event for selectors and directly call it
+			return on.selector(selector, type).call(matchesTarget, target, listener);
+		}
+		// test to see if it a touch event right now, so we don't have to do it every time it fires
+		if(has("touch")){
+			if(touchEvents.test(type)){
+				// touch event, fix it
+				listener = fixTouchListener(listener);
+			}
+			if(!has("event-orientationchange") && (type == "orientationchange")){
+				//"orientationchange" not supported <= Android 2.1, 
+				//but works through "resize" on window
+				type = "resize"; 
+				target = window;
+				listener = fixTouchListener(listener);
+			} 
+		}
+		if(addStopImmediate){
+			// add stopImmediatePropagation if it doesn't exist
+			listener = addStopImmediate(listener);
+		}
+		// normal path, the target is |this|
+		if(target.addEventListener){
+			// the target has addEventListener, which should be used if available (might or might not be a node, non-nodes can implement this method as well)
+			// check for capture conversions
+			var capture = type in captures,
+				adjustedType = capture ? captures[type] : type;
+			target.addEventListener(adjustedType, listener, capture);
+			// create and return the signal
+			return {
+				remove: function(){
+					target.removeEventListener(adjustedType, listener, capture);
+				}
+			};
+		}
+		type = "on" + type;
+		if(fixAttach && target.attachEvent){
+			return fixAttach(target, type, listener);
+		}
+		throw new Error("Target must be an event emitter");
+	}
+
+	on.selector = function(selector, eventType, children){
+		// summary:
+		//		Creates a new extension event with event delegation. This is based on
+		//		the provided event type (can be extension event) that
+		//		only calls the listener when the CSS selector matches the target of the event.
+		//
+		//		The application must require() an appropriate level of dojo/query to handle the selector.
+		// selector:
+		//		The CSS selector to use for filter events and determine the |this| of the event listener.
+		// eventType:
+		//		The event to listen for
+		// children:
+		//		Indicates if children elements of the selector should be allowed. This defaults to 
+		//		true
+		// example:
+		// |	require(["dojo/on", "dojo/mouse", "dojo/query!css2"], function(listen, mouse){
+		// |		on(node, on.selector(".my-class", mouse.enter), handlerForMyHover);
+		return function(target, listener){
+			// if the selector is function, use it to select the node, otherwise use the matches method
+			var matchesTarget = typeof selector == "function" ? {matches: selector} : this,
+				bubble = eventType.bubble;
+			function select(eventTarget){
+				// see if we have a valid matchesTarget or default to dojo.query
+				matchesTarget = matchesTarget && matchesTarget.matches ? matchesTarget : dojo.query;
+				// there is a selector, so make sure it matches
+				while(!matchesTarget.matches(eventTarget, selector, target)){
+					if(eventTarget == target || children === false || !(eventTarget = eventTarget.parentNode) || eventTarget.nodeType != 1){ // intentional assignment
+						return;
+					}
+				}
+				return eventTarget;
+			}
+			if(bubble){
+				// the event type doesn't naturally bubble, but has a bubbling form, use that, and give it the selector so it can perform the select itself
+				return on(target, bubble(select), listener);
+			}
+			// standard event delegation
+			return on(target, eventType, function(event){
+				// call select to see if we match
+				var eventTarget = select(event.target);
+				// if it matches we call the listener
+				return eventTarget && listener.call(eventTarget, event);
+			});
+		};
+	};
+
+	function syntheticPreventDefault(){
+		this.cancelable = false;
+		this.defaultPrevented = true;
+	}
+	function syntheticStopPropagation(){
+		this.bubbles = false;
+	}
+	var slice = [].slice,
+		syntheticDispatch = on.emit = function(target, type, event){
+		// summary:
+		//		Fires an event on the target object.
+		// target:
+		//		The target object to fire the event on. This can be a DOM element or a plain 
+		//		JS object. If the target is a DOM element, native event emitting mechanisms
+		//		are used when possible.
+		// type:
+		//		The event type name. You can emulate standard native events like "click" and 
+		//		"mouseover" or create custom events like "open" or "finish".
+		// event:
+		//		An object that provides the properties for the event. See https://developer.mozilla.org/en/DOM/event.initEvent 
+		//		for some of the properties. These properties are copied to the event object.
+		//		Of particular importance are the cancelable and bubbles properties. The
+		//		cancelable property indicates whether or not the event has a default action
+		//		that can be cancelled. The event is cancelled by calling preventDefault() on
+		//		the event object. The bubbles property indicates whether or not the
+		//		event will bubble up the DOM tree. If bubbles is true, the event will be called
+		//		on the target and then each parent successively until the top of the tree
+		//		is reached or stopPropagation() is called. Both bubbles and cancelable 
+		//		default to false.
+		// returns:
+		//		If the event is cancelable and the event is not cancelled,
+		//		emit will return true. If the event is cancelable and the event is cancelled,
+		//		emit will return false.
+		// details:
+		//		Note that this is designed to emit events for listeners registered through
+		//		dojo/on. It should actually work with any event listener except those
+		//		added through IE's attachEvent (IE8 and below's non-W3C event emitting
+		//		doesn't support custom event types). It should work with all events registered
+		//		through dojo/on. Also note that the emit method does do any default
+		//		action, it only returns a value to indicate if the default action should take
+		//		place. For example, emitting a keypress event would not cause a character
+		//		to appear in a textbox.
+		// example:
+		//		To fire our own click event
+		//	|	on.emit(dojo.byId("button"), "click", {
+		//	|		cancelable: true,
+		//	|		bubbles: true,
+		//	|		screenX: 33,
+		//	|		screenY: 44
+		//	|	});
+		//		We can also fire our own custom events:
+		//	|	on.emit(dojo.byId("slider"), "slide", {
+		//	|		cancelable: true,
+		//	|		bubbles: true,
+		//	|		direction: "left-to-right"
+		//	|	});
+		var args = slice.call(arguments, 2);
+		var method = "on" + type;
+		if("parentNode" in target){
+			// node (or node-like), create event controller methods
+			var newEvent = args[0] = {};
+			for(var i in event){
+				newEvent[i] = event[i];
+			}
+			newEvent.preventDefault = syntheticPreventDefault;
+			newEvent.stopPropagation = syntheticStopPropagation;
+			newEvent.target = target;
+			newEvent.type = type;
+			event = newEvent;
+		}
+		do{
+			// call any node which has a handler (note that ideally we would try/catch to simulate normal event propagation but that causes too much pain for debugging)
+			target[method] && target[method].apply(target, args);
+			// and then continue up the parent node chain if it is still bubbling (if started as bubbles and stopPropagation hasn't been called)
+		}while(event && event.bubbles && (target = target.parentNode));
+		return event && event.cancelable && event; // if it is still true (was cancelable and was cancelled), return the event to indicate default action should happen
+	};
+	var captures = has("event-focusin") ? {} : {focusin: "focus", focusout: "blur"};
+	if(!has("event-stopimmediatepropagation")){
+		var stopImmediatePropagation =function(){
+			this.immediatelyStopped = true;
+			this.modified = true; // mark it as modified so the event will be cached in IE
+		};
+		var addStopImmediate = function(listener){
+			return function(event){
+				if(!event.immediatelyStopped){// check to make sure it hasn't been stopped immediately
+					event.stopImmediatePropagation = stopImmediatePropagation;
+					return listener.apply(this, arguments);
+				}
+			};
+		}
+	} 
+	if(has("dom-addeventlistener")){
+		// emitter that works with native event handling
+		on.emit = function(target, type, event){
+			if(target.dispatchEvent && document.createEvent){
+				// use the native event emitting mechanism if it is available on the target object
+				// create a generic event				
+				// we could create branch into the different types of event constructors, but 
+				// that would be a lot of extra code, with little benefit that I can see, seems 
+				// best to use the generic constructor and copy properties over, making it 
+				// easy to have events look like the ones created with specific initializers
+				var nativeEvent = target.ownerDocument.createEvent("HTMLEvents");
+				nativeEvent.initEvent(type, !!event.bubbles, !!event.cancelable);
+				// and copy all our properties over
+				for(var i in event){
+					if(!(i in nativeEvent)){
+						nativeEvent[i] = event[i];
+					}
+				}
+				return target.dispatchEvent(nativeEvent) && nativeEvent;
+			}
+			return syntheticDispatch.apply(on, arguments); // emit for a non-node
+		};
+	}else{
+		// no addEventListener, basically old IE event normalization
+		on._fixEvent = function(evt, sender){
+			// summary:
+			//		normalizes properties on the event object including event
+			//		bubbling methods, keystroke normalization, and x/y positions
+			// evt:
+			//		native event object
+			// sender:
+			//		node to treat as "currentTarget"
+			if(!evt){
+				var w = sender && (sender.ownerDocument || sender.document || sender).parentWindow || window;
+				evt = w.event;
+			}
+			if(!evt){return evt;}
+			try{
+				if(lastEvent && evt.type == lastEvent.type  && evt.srcElement == lastEvent.target){
+					// should be same event, reuse event object (so it can be augmented);
+					// accessing evt.srcElement rather than evt.target since evt.target not set on IE until fixup below
+					evt = lastEvent;
+				}
+			}catch(e){
+				// will occur on IE on lastEvent.type reference if lastEvent points to a previous event that already
+				// finished bubbling, but the setTimeout() to clear lastEvent hasn't fired yet
+			}
+			if(!evt.target){ // check to see if it has been fixed yet
+				evt.target = evt.srcElement;
+				evt.currentTarget = (sender || evt.srcElement);
+				if(evt.type == "mouseover"){
+					evt.relatedTarget = evt.fromElement;
+				}
+				if(evt.type == "mouseout"){
+					evt.relatedTarget = evt.toElement;
+				}
+				if(!evt.stopPropagation){
+					evt.stopPropagation = stopPropagation;
+					evt.preventDefault = preventDefault;
+				}
+				switch(evt.type){
+					case "keypress":
+						var c = ("charCode" in evt ? evt.charCode : evt.keyCode);
+						if (c==10){
+							// CTRL-ENTER is CTRL-ASCII(10) on IE, but CTRL-ENTER on Mozilla
+							c=0;
+							evt.keyCode = 13;
+						}else if(c==13||c==27){
+							c=0; // Mozilla considers ENTER and ESC non-printable
+						}else if(c==3){
+							c=99; // Mozilla maps CTRL-BREAK to CTRL-c
+						}
+						// Mozilla sets keyCode to 0 when there is a charCode
+						// but that stops the event on IE.
+						evt.charCode = c;
+						_setKeyChar(evt);
+						break;
+				}
+			}
+			return evt;
+		};
+		var lastEvent, IESignal = function(handle){
+			this.handle = handle;
+		};
+		IESignal.prototype.remove = function(){
+			delete _dojoIEListeners_[this.handle];
+		};
+		var fixListener = function(listener){
+			// this is a minimal function for closing on the previous listener with as few as variables as possible
+			return function(evt){
+				evt = on._fixEvent(evt, this);
+				var result = listener.call(this, evt);
+				if(evt.modified){
+					// cache the last event and reuse it if we can
+					if(!lastEvent){
+						setTimeout(function(){
+							lastEvent = null;
+						});
+					}
+					lastEvent = evt;
+				}
+				return result;
+			};
+		};
+		var fixAttach = function(target, type, listener){
+			listener = fixListener(listener);
+			if(((target.ownerDocument ? target.ownerDocument.parentWindow : target.parentWindow || target.window || window) != top || 
+						has("jscript") < 5.8) && 
+					!has("config-_allow_leaks")){
+				// IE will leak memory on certain handlers in frames (IE8 and earlier) and in unattached DOM nodes for JScript 5.7 and below.
+				// Here we use global redirection to solve the memory leaks
+				if(typeof _dojoIEListeners_ == "undefined"){
+					_dojoIEListeners_ = [];
+				}
+				var emitter = target[type];
+				if(!emitter || !emitter.listeners){
+					var oldListener = emitter;
+					emitter = Function('event', 'var callee = arguments.callee; for(var i = 0; i<callee.listeners.length; i++){var listener = _dojoIEListeners_[callee.listeners[i]]; if(listener){listener.call(this,event);}}');
+					emitter.listeners = [];
+					target[type] = emitter;
+					emitter.global = this;
+					if(oldListener){
+						emitter.listeners.push(_dojoIEListeners_.push(oldListener) - 1);
+					}
+				}
+				var handle;
+				emitter.listeners.push(handle = (emitter.global._dojoIEListeners_.push(listener) - 1));
+				return new IESignal(handle);
+			}
+			return aspect.after(target, type, listener, true);
+		};
+
+		var _setKeyChar = function(evt){
+			evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+			evt.charOrCode = evt.keyChar || evt.keyCode;
+		};
+		// Called in Event scope
+		var stopPropagation = function(){
+			this.cancelBubble = true;
+		};
+		var preventDefault = on._preventDefault = function(){
+			// Setting keyCode to 0 is the only way to prevent certain keypresses (namely
+			// ctrl-combinations that correspond to menu accelerator keys).
+			// Otoh, it prevents upstream listeners from getting this information
+			// Try to split the difference here by clobbering keyCode only for ctrl
+			// combinations. If you still need to access the key upstream, bubbledKeyCode is
+			// provided as a workaround.
+			this.bubbledKeyCode = this.keyCode;
+			if(this.ctrlKey){
+				try{
+					// squelch errors when keyCode is read-only
+					// (e.g. if keyCode is ctrl or shift)
+					this.keyCode = 0;
+				}catch(e){
+				}
+			}
+			this.defaultPrevented = true;
+			this.returnValue = false;
+			this.modified = true; // mark it as modified  (for defaultPrevented flag) so the event will be cached in IE
+		};
+	}
+	if(has("touch")){ 
+		var Event = function(){};
+		var windowOrientation = window.orientation; 
+		var fixTouchListener = function(listener){ 
+			return function(originalEvent){ 
+				//Event normalization(for ontouchxxx and resize): 
+				//1.incorrect e.pageX|pageY in iOS 
+				//2.there are no "e.rotation", "e.scale" and "onorientationchange" in Android
+				//3.More TBD e.g. force | screenX | screenX | clientX | clientY | radiusX | radiusY
+
+				// see if it has already been corrected
+				var event = originalEvent.corrected;
+				if(!event){
+					var type = originalEvent.type;
+					try{
+						delete originalEvent.type; // on some JS engines (android), deleting properties make them mutable
+					}catch(e){} 
+					if(originalEvent.type){
+						// deleting properties doesn't work (older iOS), have to use delegation
+						if(has('mozilla')){
+							// Firefox doesn't like delegated properties, so we have to copy
+							var event = {};
+							for(var name in originalEvent){
+								event[name] = originalEvent[name];
+							}
+						}else{
+							// old iOS branch
+							Event.prototype = originalEvent;
+							var event = new Event;
+						}
+						// have to delegate methods to make them work
+						event.preventDefault = function(){
+							originalEvent.preventDefault();
+						};
+						event.stopPropagation = function(){
+							originalEvent.stopPropagation();
+						};
+					}else{
+						// deletion worked, use property as is
+						event = originalEvent;
+						event.type = type;
+					}
+					originalEvent.corrected = event;
+					if(type == 'resize'){
+						if(windowOrientation == window.orientation){ 
+							return null;//double tap causes an unexpected 'resize' in Android
+						} 
+						windowOrientation = window.orientation;
+						event.type = "orientationchange"; 
+						return listener.call(this, event);
+					}
+					// We use the original event and augment, rather than doing an expensive mixin operation
+					if(!("rotation" in event)){ // test to see if it has rotation
+						event.rotation = 0; 
+						event.scale = 1;
+					}
+					//use event.changedTouches[0].pageX|pageY|screenX|screenY|clientX|clientY|target
+					var firstChangeTouch = event.changedTouches[0];
+					for(var i in firstChangeTouch){ // use for-in, we don't need to have dependency on dojo/_base/lang here
+						delete event[i]; // delete it first to make it mutable
+						event[i] = firstChangeTouch[i];
+					}
+				}
+				return listener.call(this, event); 
+			}; 
+		}; 
+	}
+	return on;
+});

debian/missing-sources/dojo/promise/all.js

@@ -0,0 +1,76 @@
+define([
+	"../_base/array",
+	"../Deferred",
+	"../when"
+], function(array, Deferred, when){
+	"use strict";
+
+	// module:
+	//		dojo/promise/all
+
+	var some = array.some;
+
+	return function all(objectOrArray){
+		// summary:
+		//		Takes multiple promises and returns a new promise that is fulfilled
+		//		when all promises have been fulfilled.
+		// description:
+		//		Takes multiple promises and returns a new promise that is fulfilled
+		//		when all promises have been fulfilled. If one of the promises is rejected,
+		//		the returned promise is also rejected. Canceling the returned promise will
+		//		*not* cancel any passed promises.
+		// objectOrArray: Object|Array?
+		//		The promise will be fulfilled with a list of results if invoked with an
+		//		array, or an object of results when passed an object (using the same
+		//		keys). If passed neither an object or array it is resolved with an
+		//		undefined value.
+		// returns: dojo/promise/Promise
+
+		var object, array;
+		if(objectOrArray instanceof Array){
+			array = objectOrArray;
+		}else if(objectOrArray && typeof objectOrArray === "object"){
+			object = objectOrArray;
+		}
+
+		var results;
+		var keyLookup = [];
+		if(object){
+			array = [];
+			for(var key in object){
+				if(Object.hasOwnProperty.call(object, key)){
+					keyLookup.push(key);
+					array.push(object[key]);
+				}
+			}
+			results = {};
+		}else if(array){
+			results = [];
+		}
+
+		if(!array || !array.length){
+			return new Deferred().resolve(results);
+		}
+
+		var deferred = new Deferred();
+		deferred.promise.always(function(){
+			results = keyLookup = null;
+		});
+		var waiting = array.length;
+		some(array, function(valueOrPromise, index){
+			if(!object){
+				keyLookup.push(index);
+			}
+			when(valueOrPromise, function(value){
+				if(!deferred.isFulfilled()){
+					results[keyLookup[index]] = value;
+					if(--waiting === 0){
+						deferred.resolve(results);
+					}
+				}
+			}, deferred.reject);
+			return deferred.isFulfilled();
+		});
+		return deferred.promise;	// dojo/promise/Promise
+	};
+});

debian/missing-sources/dojo/query.js

@@ -0,0 +1,705 @@
+define(["./_base/kernel", "./has", "./dom", "./on", "./_base/array", "./_base/lang", "./selector/_loader", "./selector/_loader!default"],
+	function(dojo, has, dom, on, array, lang, loader, defaultEngine){
+
+	"use strict";
+
+	has.add("array-extensible", function(){
+		// test to see if we can extend an array (not supported in old IE)
+		return lang.delegate([], {length: 1}).length == 1 && !has("bug-for-in-skips-shadowed");
+	});
+	
+	var ap = Array.prototype, aps = ap.slice, apc = ap.concat, forEach = array.forEach;
+
+	var tnl = function(/*Array*/ a, /*dojo/NodeList?*/ parent, /*Function?*/ NodeListCtor){
+		// summary:
+		//		decorate an array to make it look like a `dojo/NodeList`.
+		// a:
+		//		Array of nodes to decorate.
+		// parent:
+		//		An optional parent NodeList that generated the current
+		//		list of nodes. Used to call _stash() so the parent NodeList
+		//		can be accessed via end() later.
+		// NodeListCtor:
+		//		An optional constructor function to use for any
+		//		new NodeList calls. This allows a certain chain of
+		//		NodeList calls to use a different object than dojo/NodeList.
+		var nodeList = new (NodeListCtor || this._NodeListCtor || nl)(a);
+		return parent ? nodeList._stash(parent) : nodeList;
+	};
+
+	var loopBody = function(f, a, o){
+		a = [0].concat(aps.call(a, 0));
+		o = o || dojo.global;
+		return function(node){
+			a[0] = node;
+			return f.apply(o, a);
+		};
+	};
+
+	// adapters
+
+	var adaptAsForEach = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the forEach-type
+		//		actions. The initial object is returned from the specialized
+		//		function.
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			this.forEach(loopBody(f, arguments, o));
+			return this;	// Object
+		};
+	};
+
+	var adaptAsMap = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions. The return is a new array of values, as via `dojo.map`
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.map(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptAsFilter = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the filter-type actions
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.filter(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptWithCondition = function(f, g, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions, behaves like forEach() or map() depending on arguments
+		// f: Function
+		//		a function to adapt
+		// g: Function
+		//		a condition function, if true runs as map(), otherwise runs as forEach()
+		// o: Object?
+		//		an optional context for f and g
+		return function(){
+			var a = arguments, body = loopBody(f, a, o);
+			if(g.call(o || dojo.global, a)){
+				return this.map(body);	// self
+			}
+			this.forEach(body);
+			return this;	// self
+		};
+	};
+
+	var NodeList = function(array){
+		// summary:
+		//		Array-like object which adds syntactic
+		//		sugar for chaining, common iteration operations, animation, and
+		//		node manipulation. NodeLists are most often returned as the
+		//		result of dojo.query() calls.
+		// description:
+		//		NodeList instances provide many utilities that reflect
+		//		core Dojo APIs for Array iteration and manipulation, DOM
+		//		manipulation, and event handling. Instead of needing to dig up
+		//		functions in the dojo.* namespace, NodeLists generally make the
+		//		full power of Dojo available for DOM manipulation tasks in a
+		//		simple, chainable way.
+		// example:
+		//		create a node list from a node
+		//		|	new query.NodeList(dojo.byId("foo"));
+		// example:
+		//		get a NodeList from a CSS query and iterate on it
+		//		|	var l = dojo.query(".thinger");
+		//		|	l.forEach(function(node, index, nodeList){
+		//		|		console.log(index, node.innerHTML);
+		//		|	});
+		// example:
+		//		use native and Dojo-provided array methods to manipulate a
+		//		NodeList without needing to use dojo.* functions explicitly:
+		//		|	var l = dojo.query(".thinger");
+		//		|	// since NodeLists are real arrays, they have a length
+		//		|	// property that is both readable and writable and
+		//		|	// push/pop/shift/unshift methods
+		//		|	console.log(l.length);
+		//		|	l.push(dojo.create("span"));
+		//		|
+		//		|	// dojo's normalized array methods work too:
+		//		|	console.log( l.indexOf(dojo.byId("foo")) );
+		//		|	// ...including the special "function as string" shorthand
+		//		|	console.log( l.every("item.nodeType == 1") );
+		//		|
+		//		|	// NodeLists can be [..] indexed, or you can use the at()
+		//		|	// function to get specific items wrapped in a new NodeList:
+		//		|	var node = l[3]; // the 4th element
+		//		|	var newList = l.at(1, 3); // the 2nd and 4th elements
+		// example:
+		//		the style functions you expect are all there too:
+		//		|	// style() as a getter...
+		//		|	var borders = dojo.query(".thinger").style("border");
+		//		|	// ...and as a setter:
+		//		|	dojo.query(".thinger").style("border", "1px solid black");
+		//		|	// class manipulation
+		//		|	dojo.query("li:nth-child(even)").addClass("even");
+		//		|	// even getting the coordinates of all the items
+		//		|	var coords = dojo.query(".thinger").coords();
+		// example:
+		//		DOM manipulation functions from the dojo.* namespace area also available:
+		//		|	// remove all of the elements in the list from their
+		//		|	// parents (akin to "deleting" them from the document)
+		//		|	dojo.query(".thinger").orphan();
+		//		|	// place all elements in the list at the front of #foo
+		//		|	dojo.query(".thinger").place("foo", "first");
+		// example:
+		//		Event handling couldn't be easier. `dojo.connect` is mapped in,
+		//		and shortcut handlers are provided for most DOM events:
+		//		|	// like dojo.connect(), but with implicit scope
+		//		|	dojo.query("li").connect("onclick", console, "log");
+		//		|
+		//		|	// many common event handlers are already available directly:
+		//		|	dojo.query("li").onclick(console, "log");
+		//		|	var toggleHovered = dojo.hitch(dojo, "toggleClass", "hovered");
+		//		|	dojo.query("p")
+		//		|		.onmouseenter(toggleHovered)
+		//		|		.onmouseleave(toggleHovered);
+		// example:
+		//		chainability is a key advantage of NodeLists:
+		//		|	dojo.query(".thinger")
+		//		|		.onclick(function(e){ /* ... */ })
+		//		|		.at(1, 3, 8) // get a subset
+		//		|			.style("padding", "5px")
+		//		|			.forEach(console.log);
+		var isNew = this instanceof nl && has("array-extensible");
+		if(typeof array == "number"){
+			array = Array(array);
+		}
+		var nodeArray = (array && "length" in array) ? array : arguments;
+		if(isNew || !nodeArray.sort){
+			// make sure it's a real array before we pass it on to be wrapped 
+			var target = isNew ? this : [],
+				l = target.length = nodeArray.length;
+			for(var i = 0; i < l; i++){
+				target[i] = nodeArray[i];
+			}
+			if(isNew){
+				// called with new operator, this means we are going to use this instance and push
+				// the nodes on to it. This is usually much faster since the NodeList properties
+				//	don't need to be copied (unless the list of nodes is extremely large).
+				return target;
+			}
+			nodeArray = target;
+		}
+		// called without new operator, use a real array and copy prototype properties,
+		// this is slower and exists for back-compat. Should be removed in 2.0.
+		lang._mixin(nodeArray, nlp);
+		nodeArray._NodeListCtor = function(array){
+			// call without new operator to preserve back-compat behavior
+			return nl(array);
+		};
+		return nodeArray;
+	};
+	
+	var nl = NodeList, nlp = nl.prototype = 
+		has("array-extensible") ? [] : {};// extend an array if it is extensible
+
+	// expose adapters and the wrapper as private functions
+
+	nl._wrap = nlp._wrap = tnl;
+	nl._adaptAsMap = adaptAsMap;
+	nl._adaptAsForEach = adaptAsForEach;
+	nl._adaptAsFilter  = adaptAsFilter;
+	nl._adaptWithCondition = adaptWithCondition;
+
+	// mass assignment
+
+	// add array redirectors
+	forEach(["slice", "splice"], function(name){
+		var f = ap[name];
+		//Use a copy of the this array via this.slice() to allow .end() to work right in the splice case.
+		// CANNOT apply ._stash()/end() to splice since it currently modifies
+		// the existing this array -- it would break backward compatibility if we copy the array before
+		// the splice so that we can use .end(). So only doing the stash option to this._wrap for slice.
+		nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); };
+	});
+	// concat should be here but some browsers with native NodeList have problems with it
+
+	// add array.js redirectors
+	forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){
+		var f = array[name];
+		nlp[name] = function(){ return f.apply(dojo, [this].concat(aps.call(arguments, 0))); };
+	});
+
+	lang.extend(NodeList, {
+		// copy the constructors
+		constructor: nl,
+		_NodeListCtor: nl,
+		toString: function(){
+			// Array.prototype.toString can't be applied to objects, so we use join
+			return this.join(",");
+		},
+		_stash: function(parent){
+			// summary:
+			//		private function to hold to a parent NodeList. end() to return the parent NodeList.
+			//
+			// example:
+			//		How to make a `dojo/NodeList` method that only returns the third node in
+			//		the dojo/NodeList but allows access to the original NodeList by using this._stash:
+			//	|	dojo.extend(NodeList, {
+			//	|		third: function(){
+			//	|			var newNodeList = NodeList(this[2]);
+			//	|			return newNodeList._stash(this);
+			//	|		}
+			//	|	});
+			//	|	// then see how _stash applies a sub-list, to be .end()'ed out of
+			//	|	dojo.query(".foo")
+			//	|		.third()
+			//	|			.addClass("thirdFoo")
+			//	|		.end()
+			//	|		// access to the orig .foo list
+			//	|		.removeClass("foo")
+			//	|
+			//
+			this._parent = parent;
+			return this; // dojo/NodeList
+		},
+
+		on: function(eventName, listener){
+			// summary:
+			//		Listen for events on the nodes in the NodeList. Basic usage is:
+			//		| query(".my-class").on("click", listener);
+			//		This supports event delegation by using selectors as the first argument with the event names as
+			//		pseudo selectors. For example:
+			//		| dojo.query("#my-list").on("li:click", listener);
+			//		This will listen for click events within `<li>` elements that are inside the `#my-list` element.
+			//		Because on supports CSS selector syntax, we can use comma-delimited events as well:
+			//		| dojo.query("#my-list").on("li button:mouseover, li:click", listener);
+			var handles = this.map(function(node){
+				return on(node, eventName, listener); // TODO: apply to the NodeList so the same selector engine is used for matches
+			});
+			handles.remove = function(){
+				for(var i = 0; i < handles.length; i++){
+					handles[i].remove();
+				}
+			};
+			return handles;
+		},
+
+		end: function(){
+			// summary:
+			//		Ends use of the current `NodeList` by returning the previous NodeList
+			//		that generated the current NodeList.
+			// description:
+			//		Returns the `NodeList` that generated the current `NodeList`. If there
+			//		is no parent NodeList, an empty NodeList is returned.
+			// example:
+			//	|	dojo.query("a")
+			//	|		.filter(".disabled")
+			//	|			// operate on the anchors that only have a disabled class
+			//	|			.style("color", "grey")
+			//	|		.end()
+			//	|		// jump back to the list of anchors
+			//	|		.style(...)
+			//
+			if(this._parent){
+				return this._parent;
+			}else{
+				//Just return empty list.
+				return new this._NodeListCtor(0);
+			}
+		},
+
+		// http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods
+
+		// FIXME: handle return values for #3244
+		//		http://trac.dojotoolkit.org/ticket/3244
+
+		// FIXME:
+		//		need to wrap or implement:
+		//			join (perhaps w/ innerHTML/outerHTML overload for toString() of items?)
+		//			reduce
+		//			reduceRight
+
+		/*=====
+		slice: function(begin, end){
+			// summary:
+			//		Returns a new NodeList, maintaining this one in place
+			// description:
+			//		This method behaves exactly like the Array.slice method
+			//		with the caveat that it returns a dojo/NodeList and not a
+			//		raw Array. For more details, see Mozilla's [slice
+			//		documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/slice)
+			// begin: Integer
+			//		Can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// end: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			return this._wrap(a.slice.apply(this, arguments));
+		},
+
+		splice: function(index, howmany, item){
+			// summary:
+			//		Returns a new NodeList, manipulating this NodeList based on
+			//		the arguments passed, potentially splicing in new elements
+			//		at an offset, optionally deleting elements
+			// description:
+			//		This method behaves exactly like the Array.splice method
+			//		with the caveat that it returns a dojo/NodeList and not a
+			//		raw Array. For more details, see Mozilla's [splice
+			//		documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice)
+			//		For backwards compatibility, calling .end() on the spliced NodeList
+			//		does not return the original NodeList -- splice alters the NodeList in place.
+			// index: Integer
+			//		begin can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// howmany: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			// item: Object...?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+			return this._wrap(a.splice.apply(this, arguments));	// dojo/NodeList
+		},
+
+		indexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.indexOf(). The primary difference is that the acted-on
+			//		array is implicitly this NodeList
+			// value: Object
+			//		The value to search for.
+			// fromIndex: Integer?
+			//		The location to start searching from. Optional. Defaults to 0.
+			// description:
+			//		For more details on the behavior of indexOf, see Mozilla's
+			//		[indexOf
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf)
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.indexOf(this, value, fromIndex); // Integer
+		},
+
+		lastIndexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.lastIndexOf(). The primary difference is that the
+			//		acted-on array is implicitly this NodeList
+			// description:
+			//		For more details on the behavior of lastIndexOf, see
+			//		Mozilla's [lastIndexOf
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf)
+			// value: Object
+			//		The value to search for.
+			// fromIndex: Integer?
+			//		The location to start searching from. Optional. Defaults to 0.
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.lastIndexOf(this, value, fromIndex); // Integer
+		},
+
+		every: function(callback, thisObject){
+			// summary:
+			//		see `dojo.every()` and the [Array.every
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every).
+			//		Takes the same structure of arguments and returns as
+			//		dojo.every() with the caveat that the passed array is
+			//		implicitly this NodeList
+			// callback: Function
+			//		the callback
+			// thisObject: Object?
+			//		the context
+			return d.every(this, callback, thisObject); // Boolean
+		},
+
+		some: function(callback, thisObject){
+			// summary:
+			//		Takes the same structure of arguments and returns as
+			//		`dojo.some()` with the caveat that the passed array is
+			//		implicitly this NodeList.  See `dojo.some()` and Mozilla's
+			//		[Array.some
+			//		documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some).
+			// callback: Function
+			//		the callback
+			// thisObject: Object?
+			//		the context
+			return d.some(this, callback, thisObject); // Boolean
+		},
+		=====*/
+
+		concat: function(item){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		as well as items passed in as parameters
+			// description:
+			//		This method behaves exactly like the Array.concat method
+			//		with the caveat that it returns a `NodeList` and not a
+			//		raw Array. For more details, see the [Array.concat
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/concat)
+			// item: Object?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+
+			//return this._wrap(apc.apply(this, arguments));
+			// the line above won't work for the native NodeList, or for Dojo NodeLists either :-(
+
+			// implementation notes:
+			// Array.concat() doesn't recognize native NodeLists or Dojo NodeLists
+			// as arrays, and so does not inline them into a unioned array, but
+			// appends them as single entities. Both the original NodeList and the
+			// items passed in as parameters must be converted to raw Arrays
+			// and then the concatenation result may be re-_wrap()ed as a Dojo NodeList.
+
+			var t = aps.call(this, 0),
+				m = array.map(arguments, function(a){
+					return aps.call(a, 0);
+				});
+			return this._wrap(apc.apply(t, m), this);	// dojo/NodeList
+		},
+
+		map: function(/*Function*/ func, /*Function?*/ obj){
+			// summary:
+			//		see dojo.map(). The primary difference is that the acted-on
+			//		array is implicitly this NodeList and the return is a
+			//		NodeList (a subclass of Array)
+			return this._wrap(array.map(this, func, obj), this); // dojo/NodeList
+		},
+
+		forEach: function(callback, thisObj){
+			// summary:
+			//		see `dojo.forEach()`. The primary difference is that the acted-on
+			//		array is implicitly this NodeList. If you want the option to break out
+			//		of the forEach loop, use every() or some() instead.
+			forEach(this, callback, thisObj);
+			// non-standard return to allow easier chaining
+			return this; // dojo/NodeList
+		},
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = query._filterResult(this, a[0]);
+				if(a.length == 1){
+					// if we only got a string query, pass back the filtered results
+					return items._stash(this); // dojo/NodeList
+				}
+				// if we got a callback, run it over the filtered items
+				start = 1;
+			}
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo/NodeList
+		},
+		instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){
+			// summary:
+			//		Create a new instance of a specified class, using the
+			//		specified properties and each node in the NodeList as a
+			//		srcNodeRef.
+			// example:
+			//		Grabs all buttons in the page and converts them to dijit/form/Button's.
+			//	|	var buttons = query("button").instantiate(Button, {showLabel: true});
+			var c = lang.isFunction(declaredClass) ? declaredClass : lang.getObject(declaredClass);
+			properties = properties || {};
+			return this.forEach(function(node){
+				new c(properties, node);
+			});	// dojo/NodeList
+		},
+		at: function(/*===== index =====*/){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		at the given index or indices.
+			//
+			// index: Integer...
+			//		One or more 0-based indices of items in the current
+			//		NodeList. A negative index will start at the end of the
+			//		list and go backwards.
+			//
+			// example:
+			//	Shorten the list to the first, second, and third elements
+			//	|	query("a").at(0, 1, 2).forEach(fn);
+			//
+			// example:
+			//	Retrieve the first and last elements of a unordered list:
+			//	|	query("ul > li").at(0, -1).forEach(cb);
+			//
+			// example:
+			//	Do something for the first element only, but end() out back to
+			//	the original list and continue chaining:
+			//	|	query("a").at(0).onclick(fn).end().forEach(function(n){
+			//	|		console.log(n); // all anchors on the page.
+			//	|	})
+
+			var t = new this._NodeListCtor(0);
+			forEach(arguments, function(i){
+				if(i < 0){ i = this.length + i; }
+				if(this[i]){ t.push(this[i]); }
+			}, this);
+			return t._stash(this); // dojo/NodeList
+		}
+	});
+
+	function queryForEngine(engine, NodeList){
+		var query = function(/*String*/ query, /*String|DOMNode?*/ root){
+			// summary:
+			//		Returns nodes which match the given CSS selector, searching the
+			//		entire document by default but optionally taking a node to scope
+			//		the search by. Returns an instance of NodeList.
+			if(typeof root == "string"){
+				root = dom.byId(root);
+				if(!root){
+					return new NodeList([]);
+				}
+			}
+			var results = typeof query == "string" ? engine(query, root) : query ? (query.end && query.on) ? query : [query] : [];
+			if(results.end && results.on){
+				// already wrapped
+				return results;
+			}
+			return new NodeList(results);
+		};
+		query.matches = engine.match || function(node, selector, root){
+			// summary:
+			//		Test to see if a node matches a selector
+			return query.filter([node], selector, root).length > 0;
+		};
+		// the engine provides a filtering function, use it to for matching
+		query.filter = engine.filter || function(nodes, selector, root){
+			// summary:
+			//		Filters an array of nodes. Note that this does not guarantee to return a NodeList, just an array.
+			return query(selector, root).filter(function(node){
+				return array.indexOf(nodes, node) > -1;
+			});
+		};
+		if(typeof engine != "function"){
+			var search = engine.search;
+			engine = function(selector, root){
+				// Slick does it backwards (or everyone else does it backwards, probably the latter)
+				return search(root || document, selector);
+			};
+		}
+		return query;
+	}
+	var query = queryForEngine(defaultEngine, NodeList);
+	/*=====
+	query = function(selector, context){
+		// summary:
+		//		This modules provides DOM querying functionality. The module export is a function
+		//		that can be used to query for DOM nodes by CSS selector and returns a NodeList
+		//		representing the matching nodes.
+		// selector: String
+		//		A CSS selector to search for.
+		// context: String|DomNode?
+		//		An optional context to limit the searching scope. Only nodes under `context` will be
+		//		scanned.
+		// example:
+		//		add an onclick handler to every submit button in the document
+		//		which causes the form to be sent via Ajax instead:
+		//	|	require(["dojo/query"], function(query){
+		//	|		query("input[type='submit']").on("click", function(e){
+		//	|			dojo.stopEvent(e); // prevent sending the form
+		//	|			var btn = e.target;
+		//	|			dojo.xhrPost({
+		//	|				form: btn.form,
+		//	|				load: function(data){
+		//	|					// replace the form with the response
+		//	|					var div = dojo.doc.createElement("div");
+		//	|					dojo.place(div, btn.form, "after");
+		//	|					div.innerHTML = data;
+		//	|					dojo.style(btn.form, "display", "none");
+		//	|				}
+		//	|			});
+		//	|		});
+		// |	});
+		//
+		// description:
+		//		dojo/query is responsible for loading the appropriate query engine and wrapping
+		//		its results with a `NodeList`. You can use dojo/query with a specific selector engine
+		//		by using it as a plugin. For example, if you installed the sizzle package, you could
+		//		use it as the selector engine with:
+		//		|	require(["dojo/query!sizzle"], function(query){
+		//		|		query("div")...
+		//
+		//		The id after the ! can be a module id of the selector engine or one of the following values:
+		//
+		//		- acme: This is the default engine used by Dojo base, and will ensure that the full
+		//		Acme engine is always loaded.
+		//
+		//		- css2: If the browser has a native selector engine, this will be used, otherwise a
+		//		very minimal lightweight selector engine will be loaded that can do simple CSS2 selectors
+		//		(by #id, .class, tag, and [name=value] attributes, with standard child or descendant (>)
+		//		operators) and nothing more.
+		//
+		//		- css2.1: If the browser has a native selector engine, this will be used, otherwise the
+		//		full Acme engine will be loaded.
+		//
+		//		- css3: If the browser has a native selector engine with support for CSS3 pseudo
+		//		selectors (most modern browsers except IE8), this will be used, otherwise the
+		//		full Acme engine will be loaded.
+		//
+		//		- Or the module id of a selector engine can be used to explicitly choose the selector engine
+		//
+		//		For example, if you are using CSS3 pseudo selectors in module, you can specify that
+		//		you will need support them with:
+		//		|	require(["dojo/query!css3"], function(query){
+		//		|		query('#t > h3:nth-child(odd)')...
+		//
+		//		You can also choose the selector engine/load configuration by setting the query-selector:
+		//		For example:
+		//		|	<script data-dojo-config="query-selector:'css3'" src="dojo.js"></script>
+		//
+		return new NodeList(); // dojo/NodeList
+	 };
+	 =====*/
+
+	// the query that is returned from this module is slightly different than dojo.query,
+	// because dojo.query has to maintain backwards compatibility with returning a
+	// true array which has performance problems. The query returned from the module
+	// does not use true arrays, but rather inherits from Array, making it much faster to
+	// instantiate.
+	dojo.query = queryForEngine(defaultEngine, function(array){
+		// call it without the new operator to invoke the back-compat behavior that returns a true array
+		return NodeList(array);	// dojo/NodeList
+	});
+
+	query.load = function(id, parentRequire, loaded){
+		// summary:
+		//		can be used as AMD plugin to conditionally load new query engine
+		// example:
+		//	|	require(["dojo/query!custom"], function(qsa){
+		//	|		// loaded selector/custom.js as engine
+		//	|		qsa("#foobar").forEach(...);
+		//	|	});
+		loader.load(id, parentRequire, function(engine){
+			loaded(queryForEngine(engine, NodeList));
+		});
+	};
+
+	dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){
+		return new NodeList(query.filter(nodes, selector, root));
+	};
+	dojo.NodeList = query.NodeList = NodeList;
+	return query;
+});

debian/missing-sources/dojo/router.js

@@ -0,0 +1,28 @@
+define([
+	"./router/RouterBase"
+], function(RouterBase){
+
+	// module:
+	//		dojo/router
+
+/*=====
+return {
+	// summary:
+	//		A singleton-style instance of dojo/router/RouterBase. See that
+	//		module for specifics.
+	// example:
+	//	|	router.register("/widgets/:id", function(evt){
+	//	|		// If "/widgets/3" was matched,
+	//	|		// evt.params.id === "3"
+	//	|		xhr.get({
+	//	|			url: "/some/path/" + evt.params.id,
+	//	|			load: function(data){
+	//	|				// ...
+	//	|			}
+	//	|		});
+	//	|	});
+};
+=====*/
+
+	return new RouterBase({});
+});

debian/missing-sources/dojo/store/Memory.js

@@ -0,0 +1,164 @@
+define(["../_base/declare", "./util/QueryResults", "./util/SimpleQueryEngine" /*=====, "./api/Store" =====*/],
+function(declare, QueryResults, SimpleQueryEngine /*=====, Store =====*/){
+
+// module:
+//		dojo/store/Memory
+
+// No base class, but for purposes of documentation, the base class is dojo/store/api/Store
+var base = null;
+/*===== base = Store; =====*/
+
+return declare("dojo.store.Memory", base, {
+	// summary:
+	//		This is a basic in-memory object store. It implements dojo/store/api/Store.
+	constructor: function(options){
+		// summary:
+		//		Creates a memory object store.
+		// options: dojo/store/Memory
+		//		This provides any configuration information that will be mixed into the store.
+		//		This should generally include the data property to provide the starting set of data.
+		for(var i in options){
+			this[i] = options[i];
+		}
+		this.setData(this.data || []);
+	},
+	// data: Array
+	//		The array of all the objects in the memory store
+	data:null,
+
+	// idProperty: String
+	//		Indicates the property to use as the identity property. The values of this
+	//		property should be unique.
+	idProperty: "id",
+
+	// index: Object
+	//		An index of data indices into the data array by id
+	index:null,
+
+	// queryEngine: Function
+	//		Defines the query engine to use for querying the data store
+	queryEngine: SimpleQueryEngine,
+	get: function(id){
+		// summary:
+		//		Retrieves an object by its identity
+		// id: Number
+		//		The identity to use to lookup the object
+		// returns: Object
+		//		The object in the store that matches the given id.
+		return this.data[this.index[id]];
+	},
+	getIdentity: function(object){
+		// summary:
+		//		Returns an object's identity
+		// object: Object
+		//		The object to get the identity from
+		// returns: Number
+		return object[this.idProperty];
+	},
+	put: function(object, options){
+		// summary:
+		//		Stores an object
+		// object: Object
+		//		The object to store.
+		// options: dojo/store/api/Store.PutDirectives?
+		//		Additional metadata for storing the data.  Includes an "id"
+		//		property if a specific id is to be used.
+		// returns: Number
+		var data = this.data,
+			index = this.index,
+			idProperty = this.idProperty;
+		var id = object[idProperty] = (options && "id" in options) ? options.id : idProperty in object ? object[idProperty] : Math.random();
+		if(id in index){
+			// object exists
+			if(options && options.overwrite === false){
+				throw new Error("Object already exists");
+			}
+			// replace the entry in data
+			data[index[id]] = object;
+		}else{
+			// add the new object
+			index[id] = data.push(object) - 1;
+		}
+		return id;
+	},
+	add: function(object, options){
+		// summary:
+		//		Creates an object, throws an error if the object already exists
+		// object: Object
+		//		The object to store.
+		// options: dojo/store/api/Store.PutDirectives?
+		//		Additional metadata for storing the data.  Includes an "id"
+		//		property if a specific id is to be used.
+		// returns: Number
+		(options = options || {}).overwrite = false;
+		// call put with overwrite being false
+		return this.put(object, options);
+	},
+	remove: function(id){
+		// summary:
+		//		Deletes an object by its identity
+		// id: Number
+		//		The identity to use to delete the object
+		// returns: Boolean
+		//		Returns true if an object was removed, falsy (undefined) if no object matched the id
+		var index = this.index;
+		var data = this.data;
+		if(id in index){
+			data.splice(index[id], 1);
+			// now we have to reindex
+			this.setData(data);
+			return true;
+		}
+	},
+	query: function(query, options){
+		// summary:
+		//		Queries the store for objects.
+		// query: Object
+		//		The query to use for retrieving objects from the store.
+		// options: dojo/store/api/Store.QueryOptions?
+		//		The optional arguments to apply to the resultset.
+		// returns: dojo/store/api/Store.QueryResults
+		//		The results of the query, extended with iterative methods.
+		//
+		// example:
+		//		Given the following store:
+		//
+		// 	|	var store = new Memory({
+		// 	|		data: [
+		// 	|			{id: 1, name: "one", prime: false },
+		//	|			{id: 2, name: "two", even: true, prime: true},
+		//	|			{id: 3, name: "three", prime: true},
+		//	|			{id: 4, name: "four", even: true, prime: false},
+		//	|			{id: 5, name: "five", prime: true}
+		//	|		]
+		//	|	});
+		//
+		//	...find all items where "prime" is true:
+		//
+		//	|	var results = store.query({ prime: true });
+		//
+		//	...or find all items where "even" is true:
+		//
+		//	|	var results = store.query({ even: true });
+		return QueryResults(this.queryEngine(query, options)(this.data));
+	},
+	setData: function(data){
+		// summary:
+		//		Sets the given data as the source for this store, and indexes it
+		// data: Object[]
+		//		An array of objects to use as the source of data.
+		if(data.items){
+			// just for convenience with the data format IFRS expects
+			this.idProperty = data.identifier;
+			data = this.data = data.items;
+		}else{
+			this.data = data;
+		}
+		this.index = {};
+		for(var i = 0, l = data.length; i < l; i++){
+			this.index[data[i][this.idProperty]] = i;
+		}
+	}
+});
+
+});

debian/missing-sources/dojo/store/Observable.js

@@ -0,0 +1,187 @@
+define(["../_base/kernel", "../_base/lang", "../when", "../_base/array" /*=====, "./api/Store" =====*/
+], function(kernel, lang, when, array /*=====, Store =====*/){
+
+// module:
+//		dojo/store/Observable
+
+var Observable = function(/*Store*/ store){
+	// summary:
+	//		The Observable store wrapper takes a store and sets an observe method on query()
+	//		results that can be used to monitor results for changes.
+	//
+	// description:
+	//		Observable wraps an existing store so that notifications can be made when a query
+	//		is performed.
+	//
+	// example:
+	//		Create a Memory store that returns an observable query, and then log some
+	//		information about that query.
+	//
+	//	|	var store = Observable(new Memory({
+	//	|		data: [
+	//	|			{id: 1, name: "one", prime: false},
+	//	|			{id: 2, name: "two", even: true, prime: true},
+	//	|			{id: 3, name: "three", prime: true},
+	//	|			{id: 4, name: "four", even: true, prime: false},
+	//	|			{id: 5, name: "five", prime: true}
+	//	|		]
+	//	|	}));
+	//	|	var changes = [], results = store.query({ prime: true });
+	//	|	var observer = results.observe(function(object, previousIndex, newIndex){
+	//	|		changes.push({previousIndex:previousIndex, newIndex:newIndex, object:object});
+	//	|	});
+	//
+	//		See the Observable tests for more information.
+
+	var undef, queryUpdaters = [], revision = 0;
+	// a Comet driven store could directly call notify to notify observers when data has
+	// changed on the backend
+	// create a new instance
+	store = lang.delegate(store);
+	
+	store.notify = function(object, existingId){
+		revision++;
+		var updaters = queryUpdaters.slice();
+		for(var i = 0, l = updaters.length; i < l; i++){
+			updaters[i](object, existingId);
+		}
+	};
+	var originalQuery = store.query;
+	store.query = function(query, options){
+		options = options || {};
+		var results = originalQuery.apply(this, arguments);
+		if(results && results.forEach){
+			var nonPagedOptions = lang.mixin({}, options);
+			delete nonPagedOptions.start;
+			delete nonPagedOptions.count;
+
+			var queryExecutor = store.queryEngine && store.queryEngine(query, nonPagedOptions);
+			var queryRevision = revision;
+			var listeners = [], queryUpdater;
+			results.observe = function(listener, includeObjectUpdates){
+				if(listeners.push(listener) == 1){
+					// first listener was added, create the query checker and updater
+					queryUpdaters.push(queryUpdater = function(changed, existingId){
+						when(results, function(resultsArray){
+							var atEnd = resultsArray.length != options.count;
+							var i, l, listener;
+							if(++queryRevision != revision){
+								throw new Error("Query is out of date, you must observe() the query prior to any data modifications");
+							}
+							var removedObject, removedFrom = -1, insertedInto = -1;
+							if(existingId !== undef){
+								// remove the old one
+								for(i = 0, l = resultsArray.length; i < l; i++){
+									var object = resultsArray[i];
+									if(store.getIdentity(object) == existingId){
+										removedObject = object;
+										removedFrom = i;
+										if(queryExecutor || !changed){// if it was changed and we don't have a queryExecutor, we shouldn't remove it because updated objects would be eliminated
+											resultsArray.splice(i, 1);
+										}
+										break;
+									}
+								}
+							}
+							if(queryExecutor){
+								// add the new one
+								if(changed &&
+										// if a matches function exists, use that (probably more efficient)
+										(queryExecutor.matches ? queryExecutor.matches(changed) : queryExecutor([changed]).length)){
+
+									var firstInsertedInto = removedFrom > -1 ? 
+										removedFrom : // put back in the original slot so it doesn't move unless it needs to (relying on a stable sort below)
+										resultsArray.length;
+									resultsArray.splice(firstInsertedInto, 0, changed); // add the new item
+									insertedInto = array.indexOf(queryExecutor(resultsArray), changed); // sort it
+									// we now need to push the chagne back into the original results array
+									resultsArray.splice(firstInsertedInto, 1); // remove the inserted item from the previous index
+									
+									if((options.start && insertedInto == 0) ||
+										(!atEnd && insertedInto == resultsArray.length)){
+										// if it is at the end of the page, assume it goes into the prev or next page
+										insertedInto = -1;
+									}else{
+										resultsArray.splice(insertedInto, 0, changed); // and insert into the results array with the correct index
+									}
+								}
+							}else if(changed){
+								// we don't have a queryEngine, so we can't provide any information
+								// about where it was inserted or moved to. If it is an update, we leave it's position alone, other we at least indicate a new object
+								if(existingId !== undef){
+									// an update, keep the index the same
+									insertedInto = removedFrom;
+								}else if(!options.start){
+									// a new object
+									insertedInto = store.defaultIndex || 0;
+									resultsArray.splice(insertedInto, 0, changed);
+								}
+							}
+							if((removedFrom > -1 || insertedInto > -1) &&
+									(includeObjectUpdates || !queryExecutor || (removedFrom != insertedInto))){
+								var copyListeners = listeners.slice();
+								for(i = 0;listener = copyListeners[i]; i++){
+									listener(changed || removedObject, removedFrom, insertedInto);
+								}
+							}
+						});
+					});
+				}
+				var handle = {};
+				// TODO: Remove cancel in 2.0.
+				handle.remove = handle.cancel = function(){
+					// remove this listener
+					var index = array.indexOf(listeners, listener);
+					if(index > -1){ // check to make sure we haven't already called cancel
+						listeners.splice(index, 1);
+						if(!listeners.length){
+							// no more listeners, remove the query updater too
+							queryUpdaters.splice(array.indexOf(queryUpdaters, queryUpdater), 1);
+						}
+					}
+				};
+				return handle;
+			};
+		}
+		return results;
+	};
+	var inMethod;
+	function whenFinished(method, action){
+		var original = store[method];
+		if(original){
+			store[method] = function(value){
+				if(inMethod){
+					// if one method calls another (like add() calling put()) we don't want two events
+					return original.apply(this, arguments);
+				}
+				inMethod = true;
+				try{
+					var results = original.apply(this, arguments);
+					when(results, function(results){
+						action((typeof results == "object" && results) || value);
+					});
+					return results;
+				}finally{
+					inMethod = false;
+				}
+			};
+		}
+	}
+	// monitor for updates by listening to these methods
+	whenFinished("put", function(object){
+		store.notify(object, store.getIdentity(object));
+	});
+	whenFinished("add", function(object){
+		store.notify(object);
+	});
+	whenFinished("remove", function(id){
+		store.notify(undefined, id);
+	});
+
+	return store;
+};
+
+lang.setObject("dojo.store.Observable", Observable);
+
+return Observable;
+});

debian/missing-sources/dojo/string.js

@@ -0,0 +1,162 @@
+define([
+	"./_base/kernel",	// kernel.global
+	"./_base/lang"
+], function(kernel, lang){
+
+// module:
+//		dojo/string
+
+var string = {
+	// summary:
+	//		String utilities for Dojo
+};
+lang.setObject("dojo.string", string);
+
+string.rep = function(/*String*/str, /*Integer*/num){
+	// summary:
+	//		Efficiently replicate a string `n` times.
+	// str:
+	//		the string to replicate
+	// num:
+	//		number of times to replicate the string
+
+	if(num <= 0 || !str){ return ""; }
+
+	var buf = [];
+	for(;;){
+		if(num & 1){
+			buf.push(str);
+		}
+		if(!(num >>= 1)){ break; }
+		str += str;
+	}
+	return buf.join("");	// String
+};
+
+string.pad = function(/*String*/text, /*Integer*/size, /*String?*/ch, /*Boolean?*/end){
+	// summary:
+	//		Pad a string to guarantee that it is at least `size` length by
+	//		filling with the character `ch` at either the start or end of the
+	//		string. Pads at the start, by default.
+	// text:
+	//		the string to pad
+	// size:
+	//		length to provide padding
+	// ch:
+	//		character to pad, defaults to '0'
+	// end:
+	//		adds padding at the end if true, otherwise pads at start
+	// example:
+	//	|	// Fill the string to length 10 with "+" characters on the right.  Yields "Dojo++++++".
+	//	|	string.pad("Dojo", 10, "+", true);
+
+	if(!ch){
+		ch = '0';
+	}
+	var out = String(text),
+		pad = string.rep(ch, Math.ceil((size - out.length) / ch.length));
+	return end ? out + pad : pad + out;	// String
+};
+
+string.substitute = function(	/*String*/		template,
+									/*Object|Array*/map,
+									/*Function?*/	transform,
+									/*Object?*/		thisObject){
+	// summary:
+	//		Performs parameterized substitutions on a string. Throws an
+	//		exception if any parameter is unmatched.
+	// template:
+	//		a string with expressions in the form `${key}` to be replaced or
+	//		`${key:format}` which specifies a format function. keys are case-sensitive.
+	// map:
+	//		hash to search for substitutions
+	// transform:
+	//		a function to process all parameters before substitution takes
+	//		place, e.g. mylib.encodeXML
+	// thisObject:
+	//		where to look for optional format function; default to the global
+	//		namespace
+	// example:
+	//		Substitutes two expressions in a string from an Array or Object
+	//	|	// returns "File 'foo.html' is not found in directory '/temp'."
+	//	|	// by providing substitution data in an Array
+	//	|	string.substitute(
+	//	|		"File '${0}' is not found in directory '${1}'.",
+	//	|		["foo.html","/temp"]
+	//	|	);
+	//	|
+	//	|	// also returns "File 'foo.html' is not found in directory '/temp'."
+	//	|	// but provides substitution data in an Object structure.  Dotted
+	//	|	// notation may be used to traverse the structure.
+	//	|	string.substitute(
+	//	|		"File '${name}' is not found in directory '${info.dir}'.",
+	//	|		{ name: "foo.html", info: { dir: "/temp" } }
+	//	|	);
+	// example:
+	//		Use a transform function to modify the values:
+	//	|	// returns "file 'foo.html' is not found in directory '/temp'."
+	//	|	string.substitute(
+	//	|		"${0} is not found in ${1}.",
+	//	|		["foo.html","/temp"],
+	//	|		function(str){
+	//	|			// try to figure out the type
+	//	|			var prefix = (str.charAt(0) == "/") ? "directory": "file";
+	//	|			return prefix + " '" + str + "'";
+	//	|		}
+	//	|	);
+	// example:
+	//		Use a formatter
+	//	|	// returns "thinger -- howdy"
+	//	|	string.substitute(
+	//	|		"${0:postfix}", ["thinger"], null, {
+	//	|			postfix: function(value, key){
+	//	|				return value + " -- howdy";
+	//	|			}
+	//	|		}
+	//	|	);
+
+	thisObject = thisObject || kernel.global;
+	transform = transform ?
+		lang.hitch(thisObject, transform) : function(v){ return v; };
+
+	return template.replace(/\$\{([^\s\:\}]+)(?:\:([^\s\:\}]+))?\}/g,
+		function(match, key, format){
+			var value = lang.getObject(key, false, map);
+			if(format){
+				value = lang.getObject(format, false, thisObject).call(thisObject, value, key);
+			}
+			return transform(value, key).toString();
+		}); // String
+};
+
+string.trim = String.prototype.trim ?
+	lang.trim : // aliasing to the native function
+	function(str){
+		str = str.replace(/^\s+/, '');
+		for(var i = str.length - 1; i >= 0; i--){
+			if(/\S/.test(str.charAt(i))){
+				str = str.substring(0, i + 1);
+				break;
+			}
+		}
+		return str;
+	};
+
+/*=====
+ string.trim = function(str){
+	 // summary:
+	 //		Trims whitespace from both sides of the string
+	 // str: String
+	 //		String to be trimmed
+	 // returns: String
+	 //		Returns the trimmed string
+	 // description:
+	 //		This version of trim() was taken from [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript).
+	 //		The short yet performant version of this function is dojo.trim(),
+	 //		which is part of Dojo base.  Uses String.prototype.trim instead, if available.
+	 return "";	// String
+ };
+ =====*/
+
+	return string;
+});

debian/missing-sources/dojo/topic.js

@@ -0,0 +1,38 @@
+define(["./Evented"], function(Evented){
+
+	// module:
+	//		dojo/topic
+
+	var hub = new Evented;
+	return {
+		// summary:
+		//		Pubsub hub.
+		// example:
+		//		| 	topic.subscribe("some/topic", function(event){
+		//		|	... do something with event
+		//		|	});
+		//		|	topic.publish("some/topic", {name:"some event", ...});
+
+		publish: function(topic, event){
+			// summary:
+			//		Publishes a message to a topic on the pub/sub hub. All arguments after
+			//		the first will be passed to the subscribers, so any number of arguments
+			//		can be provided (not just event).
+			// topic: String
+			//		The name of the topic to publish to
+			// event: Object
+			//		An event to distribute to the topic listeners
+			return hub.emit.apply(hub, arguments);
+		},
+
+		subscribe: function(topic, listener){
+			// summary:
+			//		Subscribes to a topic on the pub/sub hub
+			// topic: String
+			//		The topic to subscribe to
+			// listener: Function
+			//		A function to call when a message is published to the given topic
+			return hub.on.apply(hub, arguments);
+		}
+	};
+});

debian/missing-sources/patternfly.js

@@ -0,0 +1,212 @@
+// PatternFly Namespace
+var PatternFly = PatternFly || {};
+
+// Util: PatternFly Sidebar 
+// Set height of sidebar-pf to height of document minus height of navbar-pf if not mobile
+(function($) {
+  sidebar = function() {
+    var documentHeight = 0;
+    var navbarpfHeight = 0;
+    var colHeight = 0;
+    if ( $('.navbar-pf .navbar-toggle').is(':hidden') ) {
+      documentHeight = $(document).height();
+      navbarpfHeight = $('.navbar-pf').outerHeight();
+      colHeight = documentHeight - navbarpfHeight;
+    }
+    $('.sidebar-pf').parent('.row').children('[class*="col-"]').css({ "min-height":colHeight});
+  }
+  $(document).ready(function() {
+    // Call sidebar() on ready if .sidebar-pf exists and .datatable does not exist
+    if ($('.sidebar-pf').length > 0 && $('.datatable').length == 0) {
+      sidebar();
+    }
+  });
+  $(window).resize(function() {
+    // Call sidebar() on resize if .sidebar-pf exists
+    if ($('.sidebar-pf').length > 0) {
+      sidebar();
+    }
+  });
+})(jQuery);
+
+// Util: PatternFly Popovers
+// Add data-close="true" to insert close X icon
+(function($) {
+  PatternFly.popovers = function( selector ) {
+    var allpopovers = $(selector);
+    
+    // Initialize
+    allpopovers.popover();
+    
+    // Add close icons
+    allpopovers.filter('[data-close=true]').each(function(index, element) {
+      var $this = $(element),
+        title = $this.attr('data-original-title') + '<button type="button" class="close" aria-hidden="true"><span class="pficon pficon-close"></span></button>';
+
+      $this.attr('data-original-title', title);
+    });
+    
+    // Bind Close Icon to Toggle Display
+    allpopovers.on('click', function(e) {
+      var $this = $(this);
+        $title = $this.next('.popover').find('.popover-title');
+      
+      // Only if data-close is true add class "x" to title for right padding
+      $title.find('.close').parent('.popover-title').addClass('closable');
+      
+      // Bind x icon to close popover
+      $title.find('.close').on('click', function() {
+        $this.popover('toggle');
+      });
+      
+      // Prevent href="#" page scroll to top
+      e.preventDefault();
+    });
+  };
+})(jQuery);
+
+
+// Util: DataTables Settings
+(function($) {
+  if ($.fn.dataTableExt) {
+    /* Set the defaults for DataTables initialisation */
+    $.extend( true, $.fn.dataTable.defaults, {
+      "bDestroy": true,
+      "bAutoWidth": false,
+      "iDisplayLength": 20,
+      "sDom": 
+        "<'dataTables_header' f i r >" + 
+        "<'table-responsive'  t >" + 
+        "<'dataTables_footer' p >",
+      "oLanguage": {
+        "sInfo": "Showing <b>_START_</b> to <b>_END_</b> of <b>_TOTAL_</b> Items",
+        "sInfoFiltered" : "(of <b>_MAX_</b>)",
+        "sInfoEmpty" : "Showing <b>0</b> Results",
+        "sZeroRecords": 
+          "<p>Suggestions</p>" + 
+          "<ul>" + 
+            "<li>Check the syntax of the search term.</li>" +
+            "<li>Check that the correct menu option is chosen (token ID vs. user ID).</li>" +
+            "<li>Use wildcards (* to match zero or more characters or ? to match a single character).</li>" +
+            "<li>Clear the search field, then click Search to return to the 20 most recent records.</li>" +
+          "</ul>",
+        "sSearch": ""
+      },
+      "sPaginationType": "bootstrap_input"
+    });
+
+    /* Default class modification */
+    $.extend( $.fn.dataTableExt.oStdClasses, {
+      "sWrapper": "dataTables_wrapper"
+    });
+
+    /* API method to get paging information */
+    $.fn.dataTableExt.oApi.fnPagingInfo = function ( oSettings ) {
+      return {
+        "iStart":         oSettings._iDisplayStart,
+        "iEnd":           oSettings.fnDisplayEnd(),
+        "iLength":        oSettings._iDisplayLength,
+        "iTotal":         oSettings.fnRecordsTotal(),
+        "iFilteredTotal": oSettings.fnRecordsDisplay(),
+        "iPage":          oSettings._iDisplayLength === -1 ?
+          0 : Math.ceil( oSettings._iDisplayStart / oSettings._iDisplayLength ),
+        "iTotalPages":    oSettings._iDisplayLength === -1 ?
+          0 : Math.ceil( oSettings.fnRecordsDisplay() / oSettings._iDisplayLength )
+      };
+    };
+
+    /* Combination of Bootstrap + Input Text style pagination control */
+    $.extend( $.fn.dataTableExt.oPagination, {
+      "bootstrap_input": {
+        "fnInit": function( oSettings, nPaging, fnDraw ) {
+          var oLang = oSettings.oLanguage.oPaginate;
+          var fnClickHandler = function ( e ) {
+            e.preventDefault();
+            if ( oSettings.oApi._fnPageChange(oSettings, e.data.action) ) {
+              fnDraw( oSettings );
+            }
+          };
+
+          $(nPaging).append(
+            '<ul class="pagination">'+
+              '<li class="first disabled"><span class="i fa fa-angle-double-left"></span></li>' +
+              '<li class="prev disabled"><span class="i fa fa-angle-left"></span></li>' +
+            '</ul>' + 
+            '<div class="pagination-input">' + 
+              '<input type="text" class="paginate_input">' + 
+              '<span class="paginate_of">of <b>3</b></span>' + 
+            '</div>' + 
+            '<ul class="pagination">'+
+              '<li class="next disabled"><span class="i fa fa-angle-right"></span></li>' +
+              '<li class="last disabled"><span class="i fa fa-angle-double-right"></span></li>' +
+            '</ul>'
+          );
+          
+          var els = $('li', nPaging);
+          $(els[0]).bind( 'click.DT', { action: "first" }, fnClickHandler );
+          $(els[1]).bind( 'click.DT', { action: "previous" }, fnClickHandler );
+          $(els[2]).bind( 'click.DT', { action: "next" }, fnClickHandler );
+          $(els[3]).bind( 'click.DT', { action: "last" }, fnClickHandler );
+          
+          var nInput = $('input', nPaging);
+          $(nInput).keyup( function (e) {
+              if ( e.which == 38 || e.which == 39 ) {
+                this.value++;
+              }
+              else if ( (e.which == 37 || e.which == 40) && this.value > 1 ) {
+                this.value--;
+              }
+                
+              if ( this.value == "" || this.value.match(/[^0-9]/) ) {
+                /* Nothing entered or non-numeric character */
+                return;
+              }
+                
+              var iNewStart = oSettings._iDisplayLength * (this.value - 1);
+              if ( iNewStart > oSettings.fnRecordsDisplay() ) {
+                /* Display overrun */
+                oSettings._iDisplayStart = (Math.ceil((oSettings.fnRecordsDisplay()-1) /
+                  oSettings._iDisplayLength)-1) * oSettings._iDisplayLength;
+                fnDraw( oSettings );
+                return;
+              }
+                
+              oSettings._iDisplayStart = iNewStart;
+              fnDraw( oSettings );
+          });
+        },
+
+        "fnUpdate": function ( oSettings, fnDraw ) {
+          var oPaging = oSettings.oInstance.fnPagingInfo(),
+            an = oSettings.aanFeatures.p,
+            i,
+            ien,
+            iPages = Math.ceil((oSettings.fnRecordsDisplay()) / oSettings._iDisplayLength),
+            iCurrentPage = Math.ceil(oSettings._iDisplayStart / oSettings._iDisplayLength) + 1;
+
+          for ( i=0, ien=an.length ; i<ien ; i++ ) {
+            $('.paginate_input').val(iCurrentPage);
+            $('.paginate_of b').html(iPages);
+            
+            // Add / remove disabled classes from the static elements
+            if ( oPaging.iPage === 0 ) {
+              $('li.first', an[i]).addClass('disabled');
+              $('li.prev', an[i]).addClass('disabled');
+            } else {
+              $('li.first', an[i]).removeClass('disabled');
+              $('li.prev', an[i]).removeClass('disabled');
+            }
+
+            if ( oPaging.iPage === oPaging.iTotalPages-1 || oPaging.iTotalPages === 0 ) {
+              $('li.next', an[i]).addClass('disabled');
+              $('li.last', an[i]).addClass('disabled');
+            } else {
+              $('li.next', an[i]).removeClass('disabled');
+              $('li.last', an[i]).removeClass('disabled');
+            }
+          }
+        }
+      }
+    });
+  }
+})(jQuery);

debian/missing-sources/qrcode.js

@@ -0,0 +1,614 @@
+/**
+ * @fileoverview
+ * - Using the 'QRCode for Javascript library'
+ * - Fixed dataset of 'QRCode for Javascript library' for support full-spec.
+ * - this library has no dependencies.
+ * 
+ * @author davidshimjs
+ * @see <a href="http://www.d-project.com/" target="_blank">http://www.d-project.com/</a>
+ * @see <a href="http://jeromeetienne.github.com/jquery-qrcode/" target="_blank">http://jeromeetienne.github.com/jquery-qrcode/</a>
+ */
+var QRCode;
+
+(function () {
+	//---------------------------------------------------------------------
+	// QRCode for JavaScript
+	//
+	// Copyright (c) 2009 Kazuhiko Arase
+	//
+	// URL: http://www.d-project.com/
+	//
+	// Licensed under the MIT license:
+	//   http://www.opensource.org/licenses/mit-license.php
+	//
+	// The word "QR Code" is registered trademark of 
+	// DENSO WAVE INCORPORATED
+	//   http://www.denso-wave.com/qrcode/faqpatent-e.html
+	//
+	//---------------------------------------------------------------------
+	function QR8bitByte(data) {
+		this.mode = QRMode.MODE_8BIT_BYTE;
+		this.data = data;
+		this.parsedData = [];
+
+		// Added to support UTF-8 Characters
+		for (var i = 0, l = this.data.length; i < l; i++) {
+			var byteArray = [];
+			var code = this.data.charCodeAt(i);
+
+			if (code > 0x10000) {
+				byteArray[0] = 0xF0 | ((code & 0x1C0000) >>> 18);
+				byteArray[1] = 0x80 | ((code & 0x3F000) >>> 12);
+				byteArray[2] = 0x80 | ((code & 0xFC0) >>> 6);
+				byteArray[3] = 0x80 | (code & 0x3F);
+			} else if (code > 0x800) {
+				byteArray[0] = 0xE0 | ((code & 0xF000) >>> 12);
+				byteArray[1] = 0x80 | ((code & 0xFC0) >>> 6);
+				byteArray[2] = 0x80 | (code & 0x3F);
+			} else if (code > 0x80) {
+				byteArray[0] = 0xC0 | ((code & 0x7C0) >>> 6);
+				byteArray[1] = 0x80 | (code & 0x3F);
+			} else {
+				byteArray[0] = code;
+			}
+
+			this.parsedData.push(byteArray);
+		}
+
+		this.parsedData = Array.prototype.concat.apply([], this.parsedData);
+
+		if (this.parsedData.length != this.data.length) {
+			this.parsedData.unshift(191);
+			this.parsedData.unshift(187);
+			this.parsedData.unshift(239);
+		}
+	}
+
+	QR8bitByte.prototype = {
+		getLength: function (buffer) {
+			return this.parsedData.length;
+		},
+		write: function (buffer) {
+			for (var i = 0, l = this.parsedData.length; i < l; i++) {
+				buffer.put(this.parsedData[i], 8);
+			}
+		}
+	};
+
+	function QRCodeModel(typeNumber, errorCorrectLevel) {
+		this.typeNumber = typeNumber;
+		this.errorCorrectLevel = errorCorrectLevel;
+		this.modules = null;
+		this.moduleCount = 0;
+		this.dataCache = null;
+		this.dataList = [];
+	}
+
+	QRCodeModel.prototype={addData:function(data){var newData=new QR8bitByte(data);this.dataList.push(newData);this.dataCache=null;},isDark:function(row,col){if(row<0||this.moduleCount<=row||col<0||this.moduleCount<=col){throw new Error(row+","+col);}
+	return this.modules[row][col];},getModuleCount:function(){return this.moduleCount;},make:function(){this.makeImpl(false,this.getBestMaskPattern());},makeImpl:function(test,maskPattern){this.moduleCount=this.typeNumber*4+17;this.modules=new Array(this.moduleCount);for(var row=0;row<this.moduleCount;row++){this.modules[row]=new Array(this.moduleCount);for(var col=0;col<this.moduleCount;col++){this.modules[row][col]=null;}}
+	this.setupPositionProbePattern(0,0);this.setupPositionProbePattern(this.moduleCount-7,0);this.setupPositionProbePattern(0,this.moduleCount-7);this.setupPositionAdjustPattern();this.setupTimingPattern();this.setupTypeInfo(test,maskPattern);if(this.typeNumber>=7){this.setupTypeNumber(test);}
+	if(this.dataCache==null){this.dataCache=QRCodeModel.createData(this.typeNumber,this.errorCorrectLevel,this.dataList);}
+	this.mapData(this.dataCache,maskPattern);},setupPositionProbePattern:function(row,col){for(var r=-1;r<=7;r++){if(row+r<=-1||this.moduleCount<=row+r)continue;for(var c=-1;c<=7;c++){if(col+c<=-1||this.moduleCount<=col+c)continue;if((0<=r&&r<=6&&(c==0||c==6))||(0<=c&&c<=6&&(r==0||r==6))||(2<=r&&r<=4&&2<=c&&c<=4)){this.modules[row+r][col+c]=true;}else{this.modules[row+r][col+c]=false;}}}},getBestMaskPattern:function(){var minLostPoint=0;var pattern=0;for(var i=0;i<8;i++){this.makeImpl(true,i);var lostPoint=QRUtil.getLostPoint(this);if(i==0||minLostPoint>lostPoint){minLostPoint=lostPoint;pattern=i;}}
+	return pattern;},createMovieClip:function(target_mc,instance_name,depth){var qr_mc=target_mc.createEmptyMovieClip(instance_name,depth);var cs=1;this.make();for(var row=0;row<this.modules.length;row++){var y=row*cs;for(var col=0;col<this.modules[row].length;col++){var x=col*cs;var dark=this.modules[row][col];if(dark){qr_mc.beginFill(0,100);qr_mc.moveTo(x,y);qr_mc.lineTo(x+cs,y);qr_mc.lineTo(x+cs,y+cs);qr_mc.lineTo(x,y+cs);qr_mc.endFill();}}}
+	return qr_mc;},setupTimingPattern:function(){for(var r=8;r<this.moduleCount-8;r++){if(this.modules[r][6]!=null){continue;}
+	this.modules[r][6]=(r%2==0);}
+	for(var c=8;c<this.moduleCount-8;c++){if(this.modules[6][c]!=null){continue;}
+	this.modules[6][c]=(c%2==0);}},setupPositionAdjustPattern:function(){var pos=QRUtil.getPatternPosition(this.typeNumber);for(var i=0;i<pos.length;i++){for(var j=0;j<pos.length;j++){var row=pos[i];var col=pos[j];if(this.modules[row][col]!=null){continue;}
+	for(var r=-2;r<=2;r++){for(var c=-2;c<=2;c++){if(r==-2||r==2||c==-2||c==2||(r==0&&c==0)){this.modules[row+r][col+c]=true;}else{this.modules[row+r][col+c]=false;}}}}}},setupTypeNumber:function(test){var bits=QRUtil.getBCHTypeNumber(this.typeNumber);for(var i=0;i<18;i++){var mod=(!test&&((bits>>i)&1)==1);this.modules[Math.floor(i/3)][i%3+this.moduleCount-8-3]=mod;}
+	for(var i=0;i<18;i++){var mod=(!test&&((bits>>i)&1)==1);this.modules[i%3+this.moduleCount-8-3][Math.floor(i/3)]=mod;}},setupTypeInfo:function(test,maskPattern){var data=(this.errorCorrectLevel<<3)|maskPattern;var bits=QRUtil.getBCHTypeInfo(data);for(var i=0;i<15;i++){var mod=(!test&&((bits>>i)&1)==1);if(i<6){this.modules[i][8]=mod;}else if(i<8){this.modules[i+1][8]=mod;}else{this.modules[this.moduleCount-15+i][8]=mod;}}
+	for(var i=0;i<15;i++){var mod=(!test&&((bits>>i)&1)==1);if(i<8){this.modules[8][this.moduleCount-i-1]=mod;}else if(i<9){this.modules[8][15-i-1+1]=mod;}else{this.modules[8][15-i-1]=mod;}}
+	this.modules[this.moduleCount-8][8]=(!test);},mapData:function(data,maskPattern){var inc=-1;var row=this.moduleCount-1;var bitIndex=7;var byteIndex=0;for(var col=this.moduleCount-1;col>0;col-=2){if(col==6)col--;while(true){for(var c=0;c<2;c++){if(this.modules[row][col-c]==null){var dark=false;if(byteIndex<data.length){dark=(((data[byteIndex]>>>bitIndex)&1)==1);}
+	var mask=QRUtil.getMask(maskPattern,row,col-c);if(mask){dark=!dark;}
+	this.modules[row][col-c]=dark;bitIndex--;if(bitIndex==-1){byteIndex++;bitIndex=7;}}}
+	row+=inc;if(row<0||this.moduleCount<=row){row-=inc;inc=-inc;break;}}}}};QRCodeModel.PAD0=0xEC;QRCodeModel.PAD1=0x11;QRCodeModel.createData=function(typeNumber,errorCorrectLevel,dataList){var rsBlocks=QRRSBlock.getRSBlocks(typeNumber,errorCorrectLevel);var buffer=new QRBitBuffer();for(var i=0;i<dataList.length;i++){var data=dataList[i];buffer.put(data.mode,4);buffer.put(data.getLength(),QRUtil.getLengthInBits(data.mode,typeNumber));data.write(buffer);}
+	var totalDataCount=0;for(var i=0;i<rsBlocks.length;i++){totalDataCount+=rsBlocks[i].dataCount;}
+	if(buffer.getLengthInBits()>totalDataCount*8){throw new Error("code length overflow. ("
+	+buffer.getLengthInBits()
+	+">"
+	+totalDataCount*8
+	+")");}
+	if(buffer.getLengthInBits()+4<=totalDataCount*8){buffer.put(0,4);}
+	while(buffer.getLengthInBits()%8!=0){buffer.putBit(false);}
+	while(true){if(buffer.getLengthInBits()>=totalDataCount*8){break;}
+	buffer.put(QRCodeModel.PAD0,8);if(buffer.getLengthInBits()>=totalDataCount*8){break;}
+	buffer.put(QRCodeModel.PAD1,8);}
+	return QRCodeModel.createBytes(buffer,rsBlocks);};QRCodeModel.createBytes=function(buffer,rsBlocks){var offset=0;var maxDcCount=0;var maxEcCount=0;var dcdata=new Array(rsBlocks.length);var ecdata=new Array(rsBlocks.length);for(var r=0;r<rsBlocks.length;r++){var dcCount=rsBlocks[r].dataCount;var ecCount=rsBlocks[r].totalCount-dcCount;maxDcCount=Math.max(maxDcCount,dcCount);maxEcCount=Math.max(maxEcCount,ecCount);dcdata[r]=new Array(dcCount);for(var i=0;i<dcdata[r].length;i++){dcdata[r][i]=0xff&buffer.buffer[i+offset];}
+	offset+=dcCount;var rsPoly=QRUtil.getErrorCorrectPolynomial(ecCount);var rawPoly=new QRPolynomial(dcdata[r],rsPoly.getLength()-1);var modPoly=rawPoly.mod(rsPoly);ecdata[r]=new Array(rsPoly.getLength()-1);for(var i=0;i<ecdata[r].length;i++){var modIndex=i+modPoly.getLength()-ecdata[r].length;ecdata[r][i]=(modIndex>=0)?modPoly.get(modIndex):0;}}
+	var totalCodeCount=0;for(var i=0;i<rsBlocks.length;i++){totalCodeCount+=rsBlocks[i].totalCount;}
+	var data=new Array(totalCodeCount);var index=0;for(var i=0;i<maxDcCount;i++){for(var r=0;r<rsBlocks.length;r++){if(i<dcdata[r].length){data[index++]=dcdata[r][i];}}}
+	for(var i=0;i<maxEcCount;i++){for(var r=0;r<rsBlocks.length;r++){if(i<ecdata[r].length){data[index++]=ecdata[r][i];}}}
+	return data;};var QRMode={MODE_NUMBER:1<<0,MODE_ALPHA_NUM:1<<1,MODE_8BIT_BYTE:1<<2,MODE_KANJI:1<<3};var QRErrorCorrectLevel={L:1,M:0,Q:3,H:2};var QRMaskPattern={PATTERN000:0,PATTERN001:1,PATTERN010:2,PATTERN011:3,PATTERN100:4,PATTERN101:5,PATTERN110:6,PATTERN111:7};var QRUtil={PATTERN_POSITION_TABLE:[[],[6,18],[6,22],[6,26],[6,30],[6,34],[6,22,38],[6,24,42],[6,26,46],[6,28,50],[6,30,54],[6,32,58],[6,34,62],[6,26,46,66],[6,26,48,70],[6,26,50,74],[6,30,54,78],[6,30,56,82],[6,30,58,86],[6,34,62,90],[6,28,50,72,94],[6,26,50,74,98],[6,30,54,78,102],[6,28,54,80,106],[6,32,58,84,110],[6,30,58,86,114],[6,34,62,90,118],[6,26,50,74,98,122],[6,30,54,78,102,126],[6,26,52,78,104,130],[6,30,56,82,108,134],[6,34,60,86,112,138],[6,30,58,86,114,142],[6,34,62,90,118,146],[6,30,54,78,102,126,150],[6,24,50,76,102,128,154],[6,28,54,80,106,132,158],[6,32,58,84,110,136,162],[6,26,54,82,110,138,166],[6,30,58,86,114,142,170]],G15:(1<<10)|(1<<8)|(1<<5)|(1<<4)|(1<<2)|(1<<1)|(1<<0),G18:(1<<12)|(1<<11)|(1<<10)|(1<<9)|(1<<8)|(1<<5)|(1<<2)|(1<<0),G15_MASK:(1<<14)|(1<<12)|(1<<10)|(1<<4)|(1<<1),getBCHTypeInfo:function(data){var d=data<<10;while(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G15)>=0){d^=(QRUtil.G15<<(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G15)));}
+	return((data<<10)|d)^QRUtil.G15_MASK;},getBCHTypeNumber:function(data){var d=data<<12;while(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G18)>=0){d^=(QRUtil.G18<<(QRUtil.getBCHDigit(d)-QRUtil.getBCHDigit(QRUtil.G18)));}
+	return(data<<12)|d;},getBCHDigit:function(data){var digit=0;while(data!=0){digit++;data>>>=1;}
+	return digit;},getPatternPosition:function(typeNumber){return QRUtil.PATTERN_POSITION_TABLE[typeNumber-1];},getMask:function(maskPattern,i,j){switch(maskPattern){case QRMaskPattern.PATTERN000:return(i+j)%2==0;case QRMaskPattern.PATTERN001:return i%2==0;case QRMaskPattern.PATTERN010:return j%3==0;case QRMaskPattern.PATTERN011:return(i+j)%3==0;case QRMaskPattern.PATTERN100:return(Math.floor(i/2)+Math.floor(j/3))%2==0;case QRMaskPattern.PATTERN101:return(i*j)%2+(i*j)%3==0;case QRMaskPattern.PATTERN110:return((i*j)%2+(i*j)%3)%2==0;case QRMaskPattern.PATTERN111:return((i*j)%3+(i+j)%2)%2==0;default:throw new Error("bad maskPattern:"+maskPattern);}},getErrorCorrectPolynomial:function(errorCorrectLength){var a=new QRPolynomial([1],0);for(var i=0;i<errorCorrectLength;i++){a=a.multiply(new QRPolynomial([1,QRMath.gexp(i)],0));}
+	return a;},getLengthInBits:function(mode,type){if(1<=type&&type<10){switch(mode){case QRMode.MODE_NUMBER:return 10;case QRMode.MODE_ALPHA_NUM:return 9;case QRMode.MODE_8BIT_BYTE:return 8;case QRMode.MODE_KANJI:return 8;default:throw new Error("mode:"+mode);}}else if(type<27){switch(mode){case QRMode.MODE_NUMBER:return 12;case QRMode.MODE_ALPHA_NUM:return 11;case QRMode.MODE_8BIT_BYTE:return 16;case QRMode.MODE_KANJI:return 10;default:throw new Error("mode:"+mode);}}else if(type<41){switch(mode){case QRMode.MODE_NUMBER:return 14;case QRMode.MODE_ALPHA_NUM:return 13;case QRMode.MODE_8BIT_BYTE:return 16;case QRMode.MODE_KANJI:return 12;default:throw new Error("mode:"+mode);}}else{throw new Error("type:"+type);}},getLostPoint:function(qrCode){var moduleCount=qrCode.getModuleCount();var lostPoint=0;for(var row=0;row<moduleCount;row++){for(var col=0;col<moduleCount;col++){var sameCount=0;var dark=qrCode.isDark(row,col);for(var r=-1;r<=1;r++){if(row+r<0||moduleCount<=row+r){continue;}
+	for(var c=-1;c<=1;c++){if(col+c<0||moduleCount<=col+c){continue;}
+	if(r==0&&c==0){continue;}
+	if(dark==qrCode.isDark(row+r,col+c)){sameCount++;}}}
+	if(sameCount>5){lostPoint+=(3+sameCount-5);}}}
+	for(var row=0;row<moduleCount-1;row++){for(var col=0;col<moduleCount-1;col++){var count=0;if(qrCode.isDark(row,col))count++;if(qrCode.isDark(row+1,col))count++;if(qrCode.isDark(row,col+1))count++;if(qrCode.isDark(row+1,col+1))count++;if(count==0||count==4){lostPoint+=3;}}}
+	for(var row=0;row<moduleCount;row++){for(var col=0;col<moduleCount-6;col++){if(qrCode.isDark(row,col)&&!qrCode.isDark(row,col+1)&&qrCode.isDark(row,col+2)&&qrCode.isDark(row,col+3)&&qrCode.isDark(row,col+4)&&!qrCode.isDark(row,col+5)&&qrCode.isDark(row,col+6)){lostPoint+=40;}}}
+	for(var col=0;col<moduleCount;col++){for(var row=0;row<moduleCount-6;row++){if(qrCode.isDark(row,col)&&!qrCode.isDark(row+1,col)&&qrCode.isDark(row+2,col)&&qrCode.isDark(row+3,col)&&qrCode.isDark(row+4,col)&&!qrCode.isDark(row+5,col)&&qrCode.isDark(row+6,col)){lostPoint+=40;}}}
+	var darkCount=0;for(var col=0;col<moduleCount;col++){for(var row=0;row<moduleCount;row++){if(qrCode.isDark(row,col)){darkCount++;}}}
+	var ratio=Math.abs(100*darkCount/moduleCount/moduleCount-50)/5;lostPoint+=ratio*10;return lostPoint;}};var QRMath={glog:function(n){if(n<1){throw new Error("glog("+n+")");}
+	return QRMath.LOG_TABLE[n];},gexp:function(n){while(n<0){n+=255;}
+	while(n>=256){n-=255;}
+	return QRMath.EXP_TABLE[n];},EXP_TABLE:new Array(256),LOG_TABLE:new Array(256)};for(var i=0;i<8;i++){QRMath.EXP_TABLE[i]=1<<i;}
+	for(var i=8;i<256;i++){QRMath.EXP_TABLE[i]=QRMath.EXP_TABLE[i-4]^QRMath.EXP_TABLE[i-5]^QRMath.EXP_TABLE[i-6]^QRMath.EXP_TABLE[i-8];}
+	for(var i=0;i<255;i++){QRMath.LOG_TABLE[QRMath.EXP_TABLE[i]]=i;}
+	function QRPolynomial(num,shift){if(num.length==undefined){throw new Error(num.length+"/"+shift);}
+	var offset=0;while(offset<num.length&&num[offset]==0){offset++;}
+	this.num=new Array(num.length-offset+shift);for(var i=0;i<num.length-offset;i++){this.num[i]=num[i+offset];}}
+	QRPolynomial.prototype={get:function(index){return this.num[index];},getLength:function(){return this.num.length;},multiply:function(e){var num=new Array(this.getLength()+e.getLength()-1);for(var i=0;i<this.getLength();i++){for(var j=0;j<e.getLength();j++){num[i+j]^=QRMath.gexp(QRMath.glog(this.get(i))+QRMath.glog(e.get(j)));}}
+	return new QRPolynomial(num,0);},mod:function(e){if(this.getLength()-e.getLength()<0){return this;}
+	var ratio=QRMath.glog(this.get(0))-QRMath.glog(e.get(0));var num=new Array(this.getLength());for(var i=0;i<this.getLength();i++){num[i]=this.get(i);}
+	for(var i=0;i<e.getLength();i++){num[i]^=QRMath.gexp(QRMath.glog(e.get(i))+ratio);}
+	return new QRPolynomial(num,0).mod(e);}};function QRRSBlock(totalCount,dataCount){this.totalCount=totalCount;this.dataCount=dataCount;}
+	QRRSBlock.RS_BLOCK_TABLE=[[1,26,19],[1,26,16],[1,26,13],[1,26,9],[1,44,34],[1,44,28],[1,44,22],[1,44,16],[1,70,55],[1,70,44],[2,35,17],[2,35,13],[1,100,80],[2,50,32],[2,50,24],[4,25,9],[1,134,108],[2,67,43],[2,33,15,2,34,16],[2,33,11,2,34,12],[2,86,68],[4,43,27],[4,43,19],[4,43,15],[2,98,78],[4,49,31],[2,32,14,4,33,15],[4,39,13,1,40,14],[2,121,97],[2,60,38,2,61,39],[4,40,18,2,41,19],[4,40,14,2,41,15],[2,146,116],[3,58,36,2,59,37],[4,36,16,4,37,17],[4,36,12,4,37,13],[2,86,68,2,87,69],[4,69,43,1,70,44],[6,43,19,2,44,20],[6,43,15,2,44,16],[4,101,81],[1,80,50,4,81,51],[4,50,22,4,51,23],[3,36,12,8,37,13],[2,116,92,2,117,93],[6,58,36,2,59,37],[4,46,20,6,47,21],[7,42,14,4,43,15],[4,133,107],[8,59,37,1,60,38],[8,44,20,4,45,21],[12,33,11,4,34,12],[3,145,115,1,146,116],[4,64,40,5,65,41],[11,36,16,5,37,17],[11,36,12,5,37,13],[5,109,87,1,110,88],[5,65,41,5,66,42],[5,54,24,7,55,25],[11,36,12],[5,122,98,1,123,99],[7,73,45,3,74,46],[15,43,19,2,44,20],[3,45,15,13,46,16],[1,135,107,5,136,108],[10,74,46,1,75,47],[1,50,22,15,51,23],[2,42,14,17,43,15],[5,150,120,1,151,121],[9,69,43,4,70,44],[17,50,22,1,51,23],[2,42,14,19,43,15],[3,141,113,4,142,114],[3,70,44,11,71,45],[17,47,21,4,48,22],[9,39,13,16,40,14],[3,135,107,5,136,108],[3,67,41,13,68,42],[15,54,24,5,55,25],[15,43,15,10,44,16],[4,144,116,4,145,117],[17,68,42],[17,50,22,6,51,23],[19,46,16,6,47,17],[2,139,111,7,140,112],[17,74,46],[7,54,24,16,55,25],[34,37,13],[4,151,121,5,152,122],[4,75,47,14,76,48],[11,54,24,14,55,25],[16,45,15,14,46,16],[6,147,117,4,148,118],[6,73,45,14,74,46],[11,54,24,16,55,25],[30,46,16,2,47,17],[8,132,106,4,133,107],[8,75,47,13,76,48],[7,54,24,22,55,25],[22,45,15,13,46,16],[10,142,114,2,143,115],[19,74,46,4,75,47],[28,50,22,6,51,23],[33,46,16,4,47,17],[8,152,122,4,153,123],[22,73,45,3,74,46],[8,53,23,26,54,24],[12,45,15,28,46,16],[3,147,117,10,148,118],[3,73,45,23,74,46],[4,54,24,31,55,25],[11,45,15,31,46,16],[7,146,116,7,147,117],[21,73,45,7,74,46],[1,53,23,37,54,24],[19,45,15,26,46,16],[5,145,115,10,146,116],[19,75,47,10,76,48],[15,54,24,25,55,25],[23,45,15,25,46,16],[13,145,115,3,146,116],[2,74,46,29,75,47],[42,54,24,1,55,25],[23,45,15,28,46,16],[17,145,115],[10,74,46,23,75,47],[10,54,24,35,55,25],[19,45,15,35,46,16],[17,145,115,1,146,116],[14,74,46,21,75,47],[29,54,24,19,55,25],[11,45,15,46,46,16],[13,145,115,6,146,116],[14,74,46,23,75,47],[44,54,24,7,55,25],[59,46,16,1,47,17],[12,151,121,7,152,122],[12,75,47,26,76,48],[39,54,24,14,55,25],[22,45,15,41,46,16],[6,151,121,14,152,122],[6,75,47,34,76,48],[46,54,24,10,55,25],[2,45,15,64,46,16],[17,152,122,4,153,123],[29,74,46,14,75,47],[49,54,24,10,55,25],[24,45,15,46,46,16],[4,152,122,18,153,123],[13,74,46,32,75,47],[48,54,24,14,55,25],[42,45,15,32,46,16],[20,147,117,4,148,118],[40,75,47,7,76,48],[43,54,24,22,55,25],[10,45,15,67,46,16],[19,148,118,6,149,119],[18,75,47,31,76,48],[34,54,24,34,55,25],[20,45,15,61,46,16]];QRRSBlock.getRSBlocks=function(typeNumber,errorCorrectLevel){var rsBlock=QRRSBlock.getRsBlockTable(typeNumber,errorCorrectLevel);if(rsBlock==undefined){throw new Error("bad rs block @ typeNumber:"+typeNumber+"/errorCorrectLevel:"+errorCorrectLevel);}
+	var length=rsBlock.length/3;var list=[];for(var i=0;i<length;i++){var count=rsBlock[i*3+0];var totalCount=rsBlock[i*3+1];var dataCount=rsBlock[i*3+2];for(var j=0;j<count;j++){list.push(new QRRSBlock(totalCount,dataCount));}}
+	return list;};QRRSBlock.getRsBlockTable=function(typeNumber,errorCorrectLevel){switch(errorCorrectLevel){case QRErrorCorrectLevel.L:return QRRSBlock.RS_BLOCK_TABLE[(typeNumber-1)*4+0];case QRErrorCorrectLevel.M:return QRRSBlock.RS_BLOCK_TABLE[(typeNumber-1)*4+1];case QRErrorCorrectLevel.Q:return QRRSBlock.RS_BLOCK_TABLE[(typeNumber-1)*4+2];case QRErrorCorrectLevel.H:return QRRSBlock.RS_BLOCK_TABLE[(typeNumber-1)*4+3];default:return undefined;}};function QRBitBuffer(){this.buffer=[];this.length=0;}
+	QRBitBuffer.prototype={get:function(index){var bufIndex=Math.floor(index/8);return((this.buffer[bufIndex]>>>(7-index%8))&1)==1;},put:function(num,length){for(var i=0;i<length;i++){this.putBit(((num>>>(length-i-1))&1)==1);}},getLengthInBits:function(){return this.length;},putBit:function(bit){var bufIndex=Math.floor(this.length/8);if(this.buffer.length<=bufIndex){this.buffer.push(0);}
+	if(bit){this.buffer[bufIndex]|=(0x80>>>(this.length%8));}
+	this.length++;}};var QRCodeLimitLength=[[17,14,11,7],[32,26,20,14],[53,42,32,24],[78,62,46,34],[106,84,60,44],[134,106,74,58],[154,122,86,64],[192,152,108,84],[230,180,130,98],[271,213,151,119],[321,251,177,137],[367,287,203,155],[425,331,241,177],[458,362,258,194],[520,412,292,220],[586,450,322,250],[644,504,364,280],[718,560,394,310],[792,624,442,338],[858,666,482,382],[929,711,509,403],[1003,779,565,439],[1091,857,611,461],[1171,911,661,511],[1273,997,715,535],[1367,1059,751,593],[1465,1125,805,625],[1528,1190,868,658],[1628,1264,908,698],[1732,1370,982,742],[1840,1452,1030,790],[1952,1538,1112,842],[2068,1628,1168,898],[2188,1722,1228,958],[2303,1809,1283,983],[2431,1911,1351,1051],[2563,1989,1423,1093],[2699,2099,1499,1139],[2809,2213,1579,1219],[2953,2331,1663,1273]];
+	
+	function _isSupportCanvas() {
+		return typeof CanvasRenderingContext2D != "undefined";
+	}
+	
+	// android 2.x doesn't support Data-URI spec
+	function _getAndroid() {
+		var android = false;
+		var sAgent = navigator.userAgent;
+		
+		if (/android/i.test(sAgent)) { // android
+			android = true;
+			var aMat = sAgent.toString().match(/android ([0-9]\.[0-9])/i);
+			
+			if (aMat && aMat[1]) {
+				android = parseFloat(aMat[1]);
+			}
+		}
+		
+		return android;
+	}
+	
+	var svgDrawer = (function() {
+
+		var Drawing = function (el, htOption) {
+			this._el = el;
+			this._htOption = htOption;
+		};
+
+		Drawing.prototype.draw = function (oQRCode) {
+			var _htOption = this._htOption;
+			var _el = this._el;
+			var nCount = oQRCode.getModuleCount();
+			var nWidth = Math.floor(_htOption.width / nCount);
+			var nHeight = Math.floor(_htOption.height / nCount);
+
+			this.clear();
+
+			function makeSVG(tag, attrs) {
+				var el = document.createElementNS('http://www.w3.org/2000/svg', tag);
+				for (var k in attrs)
+					if (attrs.hasOwnProperty(k)) el.setAttribute(k, attrs[k]);
+				return el;
+			}
+
+			var svg = makeSVG("svg" , {'viewBox': '0 0 ' + String(nCount) + " " + String(nCount), 'width': '100%', 'height': '100%', 'fill': _htOption.colorLight});
+			svg.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xlink", "http://www.w3.org/1999/xlink");
+			_el.appendChild(svg);
+
+			svg.appendChild(makeSVG("rect", {"fill": _htOption.colorLight, "width": "100%", "height": "100%"}));
+			svg.appendChild(makeSVG("rect", {"fill": _htOption.colorDark, "width": "1", "height": "1", "id": "template"}));
+
+			for (var row = 0; row < nCount; row++) {
+				for (var col = 0; col < nCount; col++) {
+					if (oQRCode.isDark(row, col)) {
+						var child = makeSVG("use", {"x": String(col), "y": String(row)});
+						child.setAttributeNS("http://www.w3.org/1999/xlink", "href", "#template")
+						svg.appendChild(child);
+					}
+				}
+			}
+		};
+		Drawing.prototype.clear = function () {
+			while (this._el.hasChildNodes())
+				this._el.removeChild(this._el.lastChild);
+		};
+		return Drawing;
+	})();
+
+	var useSVG = document.documentElement.tagName.toLowerCase() === "svg";
+
+	// Drawing in DOM by using Table tag
+	var Drawing = useSVG ? svgDrawer : !_isSupportCanvas() ? (function () {
+		var Drawing = function (el, htOption) {
+			this._el = el;
+			this._htOption = htOption;
+		};
+			
+		/**
+		 * Draw the QRCode
+		 * 
+		 * @param {QRCode} oQRCode
+		 */
+		Drawing.prototype.draw = function (oQRCode) {
+            var _htOption = this._htOption;
+            var _el = this._el;
+			var nCount = oQRCode.getModuleCount();
+			var nWidth = Math.floor(_htOption.width / nCount);
+			var nHeight = Math.floor(_htOption.height / nCount);
+			var aHTML = ['<table style="border:0;border-collapse:collapse;">'];
+			
+			for (var row = 0; row < nCount; row++) {
+				aHTML.push('<tr>');
+				
+				for (var col = 0; col < nCount; col++) {
+					aHTML.push('<td style="border:0;border-collapse:collapse;padding:0;margin:0;width:' + nWidth + 'px;height:' + nHeight + 'px;background-color:' + (oQRCode.isDark(row, col) ? _htOption.colorDark : _htOption.colorLight) + ';"></td>');
+				}
+				
+				aHTML.push('</tr>');
+			}
+			
+			aHTML.push('</table>');
+			_el.innerHTML = aHTML.join('');
+			
+			// Fix the margin values as real size.
+			var elTable = _el.childNodes[0];
+			var nLeftMarginTable = (_htOption.width - elTable.offsetWidth) / 2;
+			var nTopMarginTable = (_htOption.height - elTable.offsetHeight) / 2;
+			
+			if (nLeftMarginTable > 0 && nTopMarginTable > 0) {
+				elTable.style.margin = nTopMarginTable + "px " + nLeftMarginTable + "px";	
+			}
+		};
+		
+		/**
+		 * Clear the QRCode
+		 */
+		Drawing.prototype.clear = function () {
+			this._el.innerHTML = '';
+		};
+		
+		return Drawing;
+	})() : (function () { // Drawing in Canvas
+		function _onMakeImage() {
+			this._elImage.src = this._elCanvas.toDataURL("image/png");
+			this._elImage.style.display = "block";
+			this._elCanvas.style.display = "none";			
+		}
+		
+		// Android 2.1 bug workaround
+		// http://code.google.com/p/android/issues/detail?id=5141
+		if (this._android && this._android <= 2.1) {
+	    	var factor = 1 / window.devicePixelRatio;
+	        var drawImage = CanvasRenderingContext2D.prototype.drawImage; 
+	    	CanvasRenderingContext2D.prototype.drawImage = function (image, sx, sy, sw, sh, dx, dy, dw, dh) {
+	    		if (("nodeName" in image) && /img/i.test(image.nodeName)) {
+		        	for (var i = arguments.length - 1; i >= 1; i--) {
+		            	arguments[i] = arguments[i] * factor;
+		        	}
+	    		} else if (typeof dw == "undefined") {
+	    			arguments[1] *= factor;
+	    			arguments[2] *= factor;
+	    			arguments[3] *= factor;
+	    			arguments[4] *= factor;
+	    		}
+	    		
+	        	drawImage.apply(this, arguments); 
+	    	};
+		}
+		
+		/**
+		 * Check whether the user's browser supports Data URI or not
+		 * 
+		 * @private
+		 * @param {Function} fSuccess Occurs if it supports Data URI
+		 * @param {Function} fFail Occurs if it doesn't support Data URI
+		 */
+		function _safeSetDataURI(fSuccess, fFail) {
+            var self = this;
+            self._fFail = fFail;
+            self._fSuccess = fSuccess;
+
+            // Check it just once
+            if (self._bSupportDataURI === null) {
+                var el = document.createElement("img");
+                var fOnError = function() {
+                    self._bSupportDataURI = false;
+
+                    if (self._fFail) {
+                        self._fFail.call(self);
+                    }
+                };
+                var fOnSuccess = function() {
+                    self._bSupportDataURI = true;
+
+                    if (self._fSuccess) {
+                        self._fSuccess.call(self);
+                    }
+                };
+
+                el.onabort = fOnError;
+                el.onerror = fOnError;
+                el.onload = fOnSuccess;
+                el.src = "data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg=="; // the Image contains 1px data.
+                return;
+            } else if (self._bSupportDataURI === true && self._fSuccess) {
+                self._fSuccess.call(self);
+            } else if (self._bSupportDataURI === false && self._fFail) {
+                self._fFail.call(self);
+            }
+		};
+		
+		/**
+		 * Drawing QRCode by using canvas
+		 * 
+		 * @constructor
+		 * @param {HTMLElement} el
+		 * @param {Object} htOption QRCode Options 
+		 */
+		var Drawing = function (el, htOption) {
+    		this._bIsPainted = false;
+    		this._android = _getAndroid();
+		
+			this._htOption = htOption;
+			this._elCanvas = document.createElement("canvas");
+			this._elCanvas.width = htOption.width;
+			this._elCanvas.height = htOption.height;
+			el.appendChild(this._elCanvas);
+			this._el = el;
+			this._oContext = this._elCanvas.getContext("2d");
+			this._bIsPainted = false;
+			this._elImage = document.createElement("img");
+			this._elImage.alt = "Scan me!";
+			this._elImage.style.display = "none";
+			this._el.appendChild(this._elImage);
+			this._bSupportDataURI = null;
+		};
+			
+		/**
+		 * Draw the QRCode
+		 * 
+		 * @param {QRCode} oQRCode 
+		 */
+		Drawing.prototype.draw = function (oQRCode) {
+            var _elImage = this._elImage;
+            var _oContext = this._oContext;
+            var _htOption = this._htOption;
+            
+			var nCount = oQRCode.getModuleCount();
+			var nWidth = _htOption.width / nCount;
+			var nHeight = _htOption.height / nCount;
+			var nRoundedWidth = Math.round(nWidth);
+			var nRoundedHeight = Math.round(nHeight);
+
+			_elImage.style.display = "none";
+			this.clear();
+			
+			for (var row = 0; row < nCount; row++) {
+				for (var col = 0; col < nCount; col++) {
+					var bIsDark = oQRCode.isDark(row, col);
+					var nLeft = col * nWidth;
+					var nTop = row * nHeight;
+					_oContext.strokeStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;
+					_oContext.lineWidth = 1;
+					_oContext.fillStyle = bIsDark ? _htOption.colorDark : _htOption.colorLight;					
+					_oContext.fillRect(nLeft, nTop, nWidth, nHeight);
+					
+					// 안티 앨리어싱 방지 처리
+					_oContext.strokeRect(
+						Math.floor(nLeft) + 0.5,
+						Math.floor(nTop) + 0.5,
+						nRoundedWidth,
+						nRoundedHeight
+					);
+					
+					_oContext.strokeRect(
+						Math.ceil(nLeft) - 0.5,
+						Math.ceil(nTop) - 0.5,
+						nRoundedWidth,
+						nRoundedHeight
+					);
+				}
+			}
+			
+			this._bIsPainted = true;
+		};
+			
+		/**
+		 * Make the image from Canvas if the browser supports Data URI.
+		 */
+		Drawing.prototype.makeImage = function () {
+			if (this._bIsPainted) {
+				_safeSetDataURI.call(this, _onMakeImage);
+			}
+		};
+			
+		/**
+		 * Return whether the QRCode is painted or not
+		 * 
+		 * @return {Boolean}
+		 */
+		Drawing.prototype.isPainted = function () {
+			return this._bIsPainted;
+		};
+		
+		/**
+		 * Clear the QRCode
+		 */
+		Drawing.prototype.clear = function () {
+			this._oContext.clearRect(0, 0, this._elCanvas.width, this._elCanvas.height);
+			this._bIsPainted = false;
+		};
+		
+		/**
+		 * @private
+		 * @param {Number} nNumber
+		 */
+		Drawing.prototype.round = function (nNumber) {
+			if (!nNumber) {
+				return nNumber;
+			}
+			
+			return Math.floor(nNumber * 1000) / 1000;
+		};
+		
+		return Drawing;
+	})();
+	
+	/**
+	 * Get the type by string length
+	 * 
+	 * @private
+	 * @param {String} sText
+	 * @param {Number} nCorrectLevel
+	 * @return {Number} type
+	 */
+	function _getTypeNumber(sText, nCorrectLevel) {			
+		var nType = 1;
+		var length = _getUTF8Length(sText);
+		
+		for (var i = 0, len = QRCodeLimitLength.length; i <= len; i++) {
+			var nLimit = 0;
+			
+			switch (nCorrectLevel) {
+				case QRErrorCorrectLevel.L :
+					nLimit = QRCodeLimitLength[i][0];
+					break;
+				case QRErrorCorrectLevel.M :
+					nLimit = QRCodeLimitLength[i][1];
+					break;
+				case QRErrorCorrectLevel.Q :
+					nLimit = QRCodeLimitLength[i][2];
+					break;
+				case QRErrorCorrectLevel.H :
+					nLimit = QRCodeLimitLength[i][3];
+					break;
+			}
+			
+			if (length <= nLimit) {
+				break;
+			} else {
+				nType++;
+			}
+		}
+		
+		if (nType > QRCodeLimitLength.length) {
+			throw new Error("Too long data");
+		}
+		
+		return nType;
+	}
+
+	function _getUTF8Length(sText) {
+		var replacedText = encodeURI(sText).toString().replace(/\%[0-9a-fA-F]{2}/g, 'a');
+		return replacedText.length + (replacedText.length != sText ? 3 : 0);
+	}
+	
+	/**
+	 * @class QRCode
+	 * @constructor
+	 * @example 
+	 * new QRCode(document.getElementById("test"), "http://jindo.dev.naver.com/collie");
+	 *
+	 * @example
+	 * var oQRCode = new QRCode("test", {
+	 *    text : "http://naver.com",
+	 *    width : 128,
+	 *    height : 128
+	 * });
+	 * 
+	 * oQRCode.clear(); // Clear the QRCode.
+	 * oQRCode.makeCode("http://map.naver.com"); // Re-create the QRCode.
+	 *
+	 * @param {HTMLElement|String} el target element or 'id' attribute of element.
+	 * @param {Object|String} vOption
+	 * @param {String} vOption.text QRCode link data
+	 * @param {Number} [vOption.width=256]
+	 * @param {Number} [vOption.height=256]
+	 * @param {String} [vOption.colorDark="#000000"]
+	 * @param {String} [vOption.colorLight="#ffffff"]
+	 * @param {QRCode.CorrectLevel} [vOption.correctLevel=QRCode.CorrectLevel.H] [L|M|Q|H] 
+	 */
+	QRCode = function (el, vOption) {
+		this._htOption = {
+			width : 256, 
+			height : 256,
+			typeNumber : 4,
+			colorDark : "#000000",
+			colorLight : "#ffffff",
+			correctLevel : QRErrorCorrectLevel.H
+		};
+		
+		if (typeof vOption === 'string') {
+			vOption	= {
+				text : vOption
+			};
+		}
+		
+		// Overwrites options
+		if (vOption) {
+			for (var i in vOption) {
+				this._htOption[i] = vOption[i];
+			}
+		}
+		
+		if (typeof el == "string") {
+			el = document.getElementById(el);
+		}
+
+		if (this._htOption.useSVG) {
+			Drawing = svgDrawer;
+		}
+		
+		this._android = _getAndroid();
+		this._el = el;
+		this._oQRCode = null;
+		this._oDrawing = new Drawing(this._el, this._htOption);
+		
+		if (this._htOption.text) {
+			this.makeCode(this._htOption.text);	
+		}
+	};
+	
+	/**
+	 * Make the QRCode
+	 * 
+	 * @param {String} sText link data
+	 */
+	QRCode.prototype.makeCode = function (sText) {
+		this._oQRCode = new QRCodeModel(_getTypeNumber(sText, this._htOption.correctLevel), this._htOption.correctLevel);
+		this._oQRCode.addData(sText);
+		this._oQRCode.make();
+		this._el.title = sText;
+		this._oDrawing.draw(this._oQRCode);			
+		this.makeImage();
+	};
+	
+	/**
+	 * Make the Image from Canvas element
+	 * - It occurs automatically
+	 * - Android below 3 doesn't support Data-URI spec.
+	 * 
+	 * @private
+	 */
+	QRCode.prototype.makeImage = function () {
+		if (typeof this._oDrawing.makeImage == "function" && (!this._android || this._android >= 3)) {
+			this._oDrawing.makeImage();
+		}
+	};
+	
+	/**
+	 * Clear the QRCode
+	 */
+	QRCode.prototype.clear = function () {
+		this._oDrawing.clear();
+	};
+	
+	/**
+	 * @name QRCode.CorrectLevel
+	 */
+	QRCode.CorrectLevel = QRErrorCorrectLevel;
+})();

debian/watch

@@ -1,2 +1,3 @@
 version=3
+options=dversionmangle=s/\+dfsg$//,uversionmangle=s/$/+dfsg1/,compression=xz \
 http://freeipa.org/page/Downloads http://freeipa.org/downloads/src/freeipa-(.+).tar.gz