Mailing-List: contact commits-help@myfaces.apache.org; run by ezmlm
Precedence: bulk
Reply-To: "MyFaces Development" <dev@myfaces.apache.org>
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: svn commit: r495409 [4/47] - in
 /myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource:
 ./ src/ src/animation/ src/cal/ src/charting/ src/charting/svg/
 src/charting/vml/ src/collections/ src/crypto/ src/data/ src/data/c...
Date: Thu, 11 Jan 2007 22:36:18 -0000
To: commits@myfaces.apache.org
From: cagatay@apache.org
Message-Id: <20070111223640.2709A1A9825@eris.apache.org>

Added: myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/dojo.js.uncompressed.js
URL: http://svn.apache.org/viewvc/myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/dojo.js.uncompressed.js?view=auto&rev=495409
==============================================================================
--- myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/dojo.js.uncompressed.js (added)
+++ myfaces/tomahawk/trunk/core/src/main/resources/org/apache/myfaces/custom/dojo/resource/dojo.js.uncompressed.js Thu Jan 11 14:35:53 2007
@@ -0,0 +1,17982 @@
+if(typeof dojo == "undefined"){
+
+/**
+* @file bootstrap1.js
+*
+* summary: First file that is loaded that 'bootstraps' the entire dojo library suite.
+* note:  Must run before hostenv_*.js file.
+*
+* @author  Copyright 2004 Mark D. Anderson (mda@discerning.com)
+* TODOC: should the copyright be changed to Dojo Foundation?
+* @license Licensed under the Academic Free License 2.1 http://www.opensource.org/licenses/afl-2.1.php
+*
+* $Id: bootstrap1.js 6824 2006-12-06 09:34:32Z alex $
+*/
+
+// TODOC: HOW TO DOC THE BELOW?
+// @global: djConfig
+// summary:
+//		Application code can set the global 'djConfig' prior to loading
+//		the library to override certain global settings for how dojo works.
+// description:  The variables that can be set are as follows:
+//			- isDebug: false
+//			- allowQueryConfig: false
+//			- baseScriptUri: ""
+//			- baseRelativePath: ""
+//			- libraryScriptUri: ""
+//			- iePreventClobber: false
+//			- ieClobberMinimal: true
+//			- locale: undefined
+//			- extraLocale: undefined
+//			- preventBackButtonFix: true
+//			- searchIds: []
+//			- parseWidgets: true
+// TODOC: HOW TO DOC THESE VARIABLES?
+// TODOC: IS THIS A COMPLETE LIST?
+// note:
+//		'djConfig' does not exist under 'dojo.*' so that it can be set before the
+//		'dojo' variable exists.
+// note:
+//		Setting any of these variables *after* the library has loaded does nothing at all.
+// TODOC: is this still true?  Release notes for 0.3 indicated they could be set after load.
+//
+
+
+//TODOC:  HOW TO DOC THIS?
+// @global: dj_global
+// summary:
+//		an alias for the top-level global object in the host environment
+//		(e.g., the window object in a browser).
+// description:
+//		Refer to 'dj_global' rather than referring to window to ensure your
+//		code runs correctly in contexts other than web browsers (eg: Rhino on a server).
+var dj_global = this;
+
+//TODOC:  HOW TO DOC THIS?
+// @global: dj_currentContext
+// summary:
+//		Private global context object. Where 'dj_global' always refers to the boot-time
+//    global context, 'dj_currentContext' can be modified for temporary context shifting.
+//    dojo.global() returns dj_currentContext.
+// description:
+//		Refer to dojo.global() rather than referring to dj_global to ensure your
+//		code runs correctly in managed contexts.
+var dj_currentContext = this;
+
+
+// ****************************************************************
+// global public utils
+// TODOC: DO WE WANT TO NOTE THAT THESE ARE GLOBAL PUBLIC UTILS?
+// ****************************************************************
+
+function dj_undef(/*String*/ name, /*Object?*/ object){
+	//summary: Returns true if 'name' is defined on 'object' (or globally if 'object' is null).
+	//description: Note that 'defined' and 'exists' are not the same concept.
+	return (typeof (object || dj_currentContext)[name] == "undefined");	// Boolean
+}
+
+// make sure djConfig is defined
+if(dj_undef("djConfig", this)){
+	var djConfig = {};
+}
+
+//TODOC:  HOW TO DOC THIS?
+// dojo is the root variable of (almost all) our public symbols -- make sure it is defined.
+if(dj_undef("dojo", this)){
+	var dojo = {};
+}
+
+dojo.global = function(){
+	// summary:
+	//		return the current global context object
+	//		(e.g., the window object in a browser).
+	// description:
+	//		Refer to 'dojo.global()' rather than referring to window to ensure your
+	//		code runs correctly in contexts other than web browsers (eg: Rhino on a server).
+	return dj_currentContext;
+}
+
+// Override locale setting, if specified
+dojo.locale  = djConfig.locale;
+
+//TODOC:  HOW TO DOC THIS?
+dojo.version = {
+	// summary: version number of this instance of dojo.
+	major: 0, minor: 4, patch: 1, flag: "",
+	revision: Number("$Rev: 6824 $".match(/[0-9]+/)[0]),
+	toString: function(){
+		with(dojo.version){
+			return major + "." + minor + "." + patch + flag + " (" + revision + ")";	// String
+		}
+	}
+}
+
+dojo.evalProp = function(/*String*/ name, /*Object*/ object, /*Boolean?*/ create){
+	// summary: Returns 'object[name]'.  If not defined and 'create' is true, will return a new Object.
+	// description:
+	//		Returns null if 'object[name]' is not defined and 'create' is not true.
+	// 		Note: 'defined' and 'exists' are not the same concept.
+	if((!object)||(!name)) return undefined; // undefined
+	if(!dj_undef(name, object)) return object[name]; // mixed
+	return (create ? (object[name]={}) : undefined);	// mixed
+}
+
+dojo.parseObjPath = function(/*String*/ path, /*Object?*/ context, /*Boolean?*/ create){
+	// summary: Parse string path to an object, and return corresponding object reference and property name.
+	// description:
+	//		Returns an object with two properties, 'obj' and 'prop'.
+	//		'obj[prop]' is the reference indicated by 'path'.
+	// path: Path to an object, in the form "A.B.C".
+	// context: Object to use as root of path.  Defaults to 'dojo.global()'.
+	// create: If true, Objects will be created at any point along the 'path' that is undefined.
+	var object = (context || dojo.global());
+	var names = path.split('.');
+	var prop = names.pop();
+	for (var i=0,l=names.length;i<l && object;i++){
+		object = dojo.evalProp(names[i], object, create);
+	}
+	return {obj: object, prop: prop};	// Object: {obj: Object, prop: String}
+}
+
+dojo.evalObjPath = function(/*String*/ path, /*Boolean?*/ create){
+	// summary: Return the value of object at 'path' in the global scope, without using 'eval()'.
+	// path: Path to an object, in the form "A.B.C".
+	// create: If true, Objects will be created at any point along the 'path' that is undefined.
+	if(typeof path != "string"){
+		return dojo.global();
+	}
+	// fast path for no periods
+	if(path.indexOf('.') == -1){
+		return dojo.evalProp(path, dojo.global(), create);		// mixed
+	}
+
+	//MOW: old 'with' syntax was confusing and would throw an error if parseObjPath returned null.
+	var ref = dojo.parseObjPath(path, dojo.global(), create);
+	if(ref){
+		return dojo.evalProp(ref.prop, ref.obj, create);	// mixed
+	}
+	return null;
+}
+
+dojo.errorToString = function(/*Error*/ exception){
+	// summary: Return an exception's 'message', 'description' or text.
+
+	// TODO: overriding Error.prototype.toString won't accomplish this?
+ 	// 		... since natively generated Error objects do not always reflect such things?
+	if(!dj_undef("message", exception)){
+		return exception.message;		// String
+	}else if(!dj_undef("description", exception)){
+		return exception.description;	// String
+	}else{
+		return exception;				// Error
+	}
+}
+
+dojo.raise = function(/*String*/ message, /*Error?*/ exception){
+	// summary: Common point for raising exceptions in Dojo to enable logging.
+	//	Throws an error message with text of 'exception' if provided, or
+	//	rethrows exception object.
+
+	if(exception){
+		message = message + ": "+dojo.errorToString(exception);
+	}else{
+		message = dojo.errorToString(message);
+	}
+
+	// print the message to the user if hostenv.println is defined
+	try { if(djConfig.isDebug){ dojo.hostenv.println("FATAL exception raised: "+message); } } catch (e) {}
+
+	throw exception || Error(message);
+}
+
+//Stub functions so things don't break.
+//TODOC:  HOW TO DOC THESE?
+dojo.debug = function(){};
+dojo.debugShallow = function(obj){};
+dojo.profile = { start: function(){}, end: function(){}, stop: function(){}, dump: function(){} };
+
+function dj_eval(/*String*/ scriptFragment){
+	// summary: Perform an evaluation in the global scope.  Use this rather than calling 'eval()' directly.
+	// description: Placed in a separate function to minimize size of trapped evaluation context.
+	// note:
+	//	 - JSC eval() takes an optional second argument which can be 'unsafe'.
+	//	 - Mozilla/SpiderMonkey eval() takes an optional second argument which is the
+	//  	 scope object for new symbols.
+	return dj_global.eval ? dj_global.eval(scriptFragment) : eval(scriptFragment); 	// mixed
+}
+
+dojo.unimplemented = function(/*String*/ funcname, /*String?*/ extra){
+	// summary: Throw an exception because some function is not implemented.
+	// extra: Text to append to the exception message.
+	var message = "'" + funcname + "' not implemented";
+	if (extra != null) { message += " " + extra; }
+	dojo.raise(message);
+}
+
+dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
+	// summary: Log a debug message to indicate that a behavior has been deprecated.
+	// extra: Text to append to the message.
+	// removal: Text to indicate when in the future the behavior will be removed.
+	var message = "DEPRECATED: " + behaviour;
+	if(extra){ message += " " + extra; }
+	if(removal){ message += " -- will be removed in version: " + removal; }
+	dojo.debug(message);
+}
+
+dojo.render = (function(){
+	//TODOC: HOW TO DOC THIS?
+	// summary: Details rendering support, OS and browser of the current environment.
+	// TODOC: is this something many folks will interact with?  If so, we should doc the structure created...
+	function vscaffold(prefs, names){
+		var tmp = {
+			capable: false,
+			support: {
+				builtin: false,
+				plugin: false
+			},
+			prefixes: prefs
+		};
+		for(var i=0; i<names.length; i++){
+			tmp[names[i]] = false;
+		}
+		return tmp;
+	}
+
+	return {
+		name: "",
+		ver: dojo.version,
+		os: { win: false, linux: false, osx: false },
+		html: vscaffold(["html"], ["ie", "opera", "khtml", "safari", "moz"]),
+		svg: vscaffold(["svg"], ["corel", "adobe", "batik"]),
+		vml: vscaffold(["vml"], ["ie"]),
+		swf: vscaffold(["Swf", "Flash", "Mm"], ["mm"]),
+		swt: vscaffold(["Swt"], ["ibm"])
+	};
+})();
+
+// ****************************************************************
+// dojo.hostenv methods that must be defined in hostenv_*.js
+// ****************************************************************
+
+/**
+ * The interface definining the interaction with the EcmaScript host environment.
+*/
+
+/*
+ * None of these methods should ever be called directly by library users.
+ * Instead public methods such as loadModule should be called instead.
+ */
+dojo.hostenv = (function(){
+	// TODOC:  HOW TO DOC THIS?
+	// summary: Provides encapsulation of behavior that changes across different 'host environments'
+	//			(different browsers, server via Rhino, etc).
+	// description: None of these methods should ever be called directly by library users.
+	//				Use public methods such as 'loadModule' instead.
+
+	// default configuration options
+	var config = {
+		isDebug: false,
+		allowQueryConfig: false,
+		baseScriptUri: "",
+		baseRelativePath: "",
+		libraryScriptUri: "",
+		iePreventClobber: false,
+		ieClobberMinimal: true,
+		preventBackButtonFix: true,
+		delayMozLoadingFix: false,
+		searchIds: [],
+		parseWidgets: true
+	};
+
+	if (typeof djConfig == "undefined") { djConfig = config; }
+	else {
+		for (var option in config) {
+			if (typeof djConfig[option] == "undefined") {
+				djConfig[option] = config[option];
+			}
+		}
+	}
+
+	return {
+		name_: '(unset)',
+		version_: '(unset)',
+
+
+		getName: function(){
+			// sumary: Return the name of the host environment.
+			return this.name_; 	// String
+		},
+
+
+		getVersion: function(){
+			// summary: Return the version of the hostenv.
+			return this.version_; // String
+		},
+
+		getText: function(/*String*/ uri){
+			// summary:	Read the plain/text contents at the specified 'uri'.
+			// description:
+			//			If 'getText()' is not implemented, then it is necessary to override
+			//			'loadUri()' with an implementation that doesn't rely on it.
+
+			dojo.unimplemented('getText', "uri=" + uri);
+		}
+	};
+})();
+
+
+dojo.hostenv.getBaseScriptUri = function(){
+	// summary: Return the base script uri that other scripts are found relative to.
+	// TODOC: HUH?  This comment means nothing to me.  What other scripts? Is this the path to other dojo libraries?
+	//		MAYBE:  Return the base uri to scripts in the dojo library.	 ???
+	// return: Empty string or a path ending in '/'.
+	if(djConfig.baseScriptUri.length){
+		return djConfig.baseScriptUri;
+	}
+
+	// MOW: Why not:
+	//			uri = djConfig.libraryScriptUri || djConfig.baseRelativePath
+	//		??? Why 'new String(...)'
+	var uri = new String(djConfig.libraryScriptUri||djConfig.baseRelativePath);
+	if (!uri) { dojo.raise("Nothing returned by getLibraryScriptUri(): " + uri); }
+
+	// MOW: uri seems to not be actually used.  Seems to be hard-coding to djConfig.baseRelativePath... ???
+	var lastslash = uri.lastIndexOf('/');		// MOW ???
+	djConfig.baseScriptUri = djConfig.baseRelativePath;
+	return djConfig.baseScriptUri;	// String
+}
+
+/*
+ * loader.js - A bootstrap module.  Runs before the hostenv_*.js file. Contains all of the package loading methods.
+ */
+
+//A semi-colon is at the start of the line because after doing a build, this function definition
+//get compressed onto the same line as the last line in bootstrap1.js. That list line is just a
+//curly bracket, and the browser complains about that syntax. The semicolon fixes it. Putting it
+//here instead of at the end of bootstrap1.js, since it is more of an issue for this file, (using
+//the closure), and bootstrap1.js could change in the future.
+;(function(){
+	//Additional properties for dojo.hostenv
+	var _addHostEnv = {
+		pkgFileName: "__package__",
+	
+		// for recursion protection
+		loading_modules_: {},
+		loaded_modules_: {},
+		addedToLoadingCount: [],
+		removedFromLoadingCount: [],
+	
+		inFlightCount: 0,
+	
+		// FIXME: it should be possible to pull module prefixes in from djConfig
+		modulePrefixes_: {
+			dojo: {name: "dojo", value: "src"}
+		},
+
+		setModulePrefix: function(/*String*/module, /*String*/prefix){
+			// summary: establishes module/prefix pair
+			this.modulePrefixes_[module] = {name: module, value: prefix};
+		},
+
+		moduleHasPrefix: function(/*String*/module){
+			// summary: checks to see if module has been established
+			var mp = this.modulePrefixes_;
+			return Boolean(mp[module] && mp[module].value); // Boolean
+		},
+
+		getModulePrefix: function(/*String*/module){
+			// summary: gets the prefix associated with module
+			if(this.moduleHasPrefix(module)){
+				return this.modulePrefixes_[module].value; // String
+			}
+			return module; // String
+		},
+
+		getTextStack: [],
+		loadUriStack: [],
+		loadedUris: [],
+	
+		//WARNING: This variable is referenced by packages outside of bootstrap: FloatingPane.js and undo/browser.js
+		post_load_: false,
+		
+		//Egad! Lots of test files push on this directly instead of using dojo.addOnLoad.
+		modulesLoadedListeners: [],
+		unloadListeners: [],
+		loadNotifying: false
+	};
+	
+	//Add all of these properties to dojo.hostenv
+	for(var param in _addHostEnv){
+		dojo.hostenv[param] = _addHostEnv[param];
+	}
+})();
+
+dojo.hostenv.loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){
+// summary:
+//	Load a Javascript module given a relative path
+//
+// description:
+//	Loads and interprets the script located at relpath, which is relative to the
+//	script root directory.  If the script is found but its interpretation causes
+//	a runtime exception, that exception is not caught by us, so the caller will
+//	see it.  We return a true value if and only if the script is found.
+//
+//	For now, we do not have an implementation of a true search path.  We
+//	consider only the single base script uri, as returned by getBaseScriptUri().
+//
+// relpath: A relative path to a script (no leading '/', and typically
+// 	ending in '.js').
+// module: A module whose existance to check for after loading a path.
+//	Can be used to determine success or failure of the load.
+// cb: a callback function to pass the result of evaluating the script
+
+	var uri;
+	if(relpath.charAt(0) == '/' || relpath.match(/^\w+:/)){
+		// dojo.raise("relpath '" + relpath + "'; must be relative");
+		uri = relpath;
+	}else{
+		uri = this.getBaseScriptUri() + relpath;
+	}
+	if(djConfig.cacheBust && dojo.render.html.capable){
+		uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,"");
+	}
+	try{
+		return !module ? this.loadUri(uri, cb) : this.loadUriAndCheck(uri, module, cb); // Boolean
+	}catch(e){
+		dojo.debug(e);
+		return false; // Boolean
+	}
+}
+
+dojo.hostenv.loadUri = function(/*String (URL)*/uri, /*Function?*/cb){
+// summary:
+//	Loads JavaScript from a URI
+//
+// description:
+//	Reads the contents of the URI, and evaluates the contents.  This is used to load modules as well
+//	as resource bundles.  Returns true if it succeeded. Returns false if the URI reading failed.
+//	Throws if the evaluation throws.
+//
+// uri: a uri which points at the script to be loaded
+// cb: a callback function to process the result of evaluating the script as an expression, typically
+//	used by the resource bundle loader to load JSON-style resources
+
+	if(this.loadedUris[uri]){
+		return true; // Boolean
+	}
+	var contents = this.getText(uri, null, true);
+	if(!contents){ return false; } // Boolean
+	this.loadedUris[uri] = true;
+	if(cb){ contents = '('+contents+')'; }
+	var value = dj_eval(contents);
+	if(cb){ cb(value); }
+	return true; // Boolean
+}
+
+// FIXME: probably need to add logging to this method
+dojo.hostenv.loadUriAndCheck = function(/*String (URL)*/uri, /*String*/moduleName, /*Function?*/cb){
+	// summary: calls loadUri then findModule and returns true if both succeed
+	var ok = true;
+	try{
+		ok = this.loadUri(uri, cb);
+	}catch(e){
+		dojo.debug("failed loading ", uri, " with error: ", e);
+	}
+	return Boolean(ok && this.findModule(moduleName, false)); // Boolean
+}
+
+dojo.loaded = function(){ }
+dojo.unloaded = function(){ }
+
+dojo.hostenv.loaded = function(){
+	this.loadNotifying = true;
+	this.post_load_ = true;
+	var mll = this.modulesLoadedListeners;
+	for(var x=0; x<mll.length; x++){
+		mll[x]();
+	}
+
+	//Clear listeners so new ones can be added
+	//For other xdomain package loads after the initial load.
+	this.modulesLoadedListeners = [];
+	this.loadNotifying = false;
+
+	dojo.loaded();
+}
+
+dojo.hostenv.unloaded = function(){
+	var mll = this.unloadListeners;
+	while(mll.length){
+		(mll.pop())();
+	}
+	dojo.unloaded();
+}
+
+dojo.addOnLoad = function(/*Object?*/obj, /*String|Function*/functionName) {
+// summary:
+//	Registers a function to be triggered after the DOM has finished loading 
+//	and widgets declared in markup have been instantiated.  Images and CSS files
+//	may or may not have finished downloading when the specified function is called.
+//	(Note that widgets' CSS and HTML code is guaranteed to be downloaded before said
+//	widgets are instantiated.)
+//
+// usage:
+//	dojo.addOnLoad(functionPointer)
+//	dojo.addOnLoad(object, "functionName")
+
+	var dh = dojo.hostenv;
+	if(arguments.length == 1) {
+		dh.modulesLoadedListeners.push(obj);
+	} else if(arguments.length > 1) {
+		dh.modulesLoadedListeners.push(function() {
+			obj[functionName]();
+		});
+	}
+
+	//Added for xdomain loading. dojo.addOnLoad is used to
+	//indicate callbacks after doing some dojo.require() statements.
+	//In the xdomain case, if all the requires are loaded (after initial
+	//page load), then immediately call any listeners.
+	if(dh.post_load_ && dh.inFlightCount == 0 && !dh.loadNotifying){
+		dh.callLoaded();
+	}
+}
+
+dojo.addOnUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
+// summary: registers a function to be triggered when the page unloads
+//
+// usage:
+//	dojo.addOnLoad(functionPointer)
+//	dojo.addOnLoad(object, "functionName")
+	var dh = dojo.hostenv;
+	if(arguments.length == 1){
+		dh.unloadListeners.push(obj);
+	} else if(arguments.length > 1) {
+		dh.unloadListeners.push(function() {
+			obj[functionName]();
+		});
+	}
+}
+
+dojo.hostenv.modulesLoaded = function(){
+	if(this.post_load_){ return; }
+	if(this.loadUriStack.length==0 && this.getTextStack.length==0){
+		if(this.inFlightCount > 0){ 
+			dojo.debug("files still in flight!");
+			return;
+		}
+		dojo.hostenv.callLoaded();
+	}
+}
+
+dojo.hostenv.callLoaded = function(){
+	if(typeof setTimeout == "object"){
+		setTimeout("dojo.hostenv.loaded();", 0);
+	}else{
+		dojo.hostenv.loaded();
+	}
+}
+
+dojo.hostenv.getModuleSymbols = function(/*String*/modulename){
+// summary:
+//	Converts a module name in dotted JS notation to an array representing the path in the source tree
+	var syms = modulename.split(".");
+	for(var i = syms.length; i>0; i--){
+		var parentModule = syms.slice(0, i).join(".");
+		if((i==1) && !this.moduleHasPrefix(parentModule)){		
+			// Support default module directory (sibling of dojo) for top-level modules 
+			syms[0] = "../" + syms[0];
+		}else{
+			var parentModulePath = this.getModulePrefix(parentModule);
+			if(parentModulePath != parentModule){
+				syms.splice(0, i, parentModulePath);
+				break;
+			}
+		}
+	}
+	return syms; // Array
+}
+
+dojo.hostenv._global_omit_module_check = false;
+dojo.hostenv.loadModule = function(/*String*/moduleName, /*Boolean?*/exactOnly, /*Boolean?*/omitModuleCheck){
+// summary:
+//	loads a Javascript module from the appropriate URI
+//
+// description:
+//	loadModule("A.B") first checks to see if symbol A.B is defined. 
+//	If it is, it is simply returned (nothing to do).
+//	
+//	If it is not defined, it will look for "A/B.js" in the script root directory,
+//	followed by "A.js".
+//	
+//	It throws if it cannot find a file to load, or if the symbol A.B is not
+//	defined after loading.
+//	
+//	It returns the object A.B.
+//	
+//	This does nothing about importing symbols into the current package.
+//	It is presumed that the caller will take care of that. For example, to import
+//	all symbols:
+//	
+//	   with (dojo.hostenv.loadModule("A.B")) {
+//	      ...
+//	   }
+//	
+//	And to import just the leaf symbol:
+//	
+//	   var B = dojo.hostenv.loadModule("A.B");
+//	   ...
+//	
+//	dj_load is an alias for dojo.hostenv.loadModule
+
+	if(!moduleName){ return; }
+	omitModuleCheck = this._global_omit_module_check || omitModuleCheck;
+	var module = this.findModule(moduleName, false);
+	if(module){
+		return module;
+	}
+
+	// protect against infinite recursion from mutual dependencies
+	if(dj_undef(moduleName, this.loading_modules_)){
+		this.addedToLoadingCount.push(moduleName);
+	}
+	this.loading_modules_[moduleName] = 1;
+
+	// convert periods to slashes
+	var relpath = moduleName.replace(/\./g, '/') + '.js';
+
+	var nsyms = moduleName.split(".");
+	
+	// this line allowed loading of a module manifest as if it were a namespace
+	// it's an interesting idea, but shouldn't be combined with 'namespaces' proper
+	// and leads to unwanted dependencies
+	// the effect can be achieved in other (albeit less-flexible) ways now, so I am
+	// removing this pending further design work
+	// perhaps we can explicitly define this idea of a 'module manifest', and subclass
+	// 'namespace manifest' from that
+	//dojo.getNamespace(nsyms[0]);
+
+	var syms = this.getModuleSymbols(moduleName);
+	var startedRelative = ((syms[0].charAt(0) != '/') && !syms[0].match(/^\w+:/));
+	var last = syms[syms.length - 1];
+	var ok;
+	// figure out if we're looking for a full package, if so, we want to do
+	// things slightly diffrently
+	if(last=="*"){
+		moduleName = nsyms.slice(0, -1).join('.');
+		while(syms.length){
+			syms.pop();
+			syms.push(this.pkgFileName);
+			relpath = syms.join("/") + '.js';
+			if(startedRelative && relpath.charAt(0)=="/"){
+				relpath = relpath.slice(1);
+			}
+			ok = this.loadPath(relpath, !omitModuleCheck ? moduleName : null);
+			if(ok){ break; }
+			syms.pop();
+		}
+	}else{
+		relpath = syms.join("/") + '.js';
+		moduleName = nsyms.join('.');
+		var modArg = !omitModuleCheck ? moduleName : null;
+		ok = this.loadPath(relpath, modArg);
+		if(!ok && !exactOnly){
+			syms.pop();
+			while(syms.length){
+				relpath = syms.join('/') + '.js';
+				ok = this.loadPath(relpath, modArg);
+				if(ok){ break; }
+				syms.pop();
+				relpath = syms.join('/') + '/'+this.pkgFileName+'.js';
+				if(startedRelative && relpath.charAt(0)=="/"){
+					relpath = relpath.slice(1);
+				}
+				ok = this.loadPath(relpath, modArg);
+				if(ok){ break; }
+			}
+		}
+
+		if(!ok && !omitModuleCheck){
+			dojo.raise("Could not load '" + moduleName + "'; last tried '" + relpath + "'");
+		}
+	}
+
+	// check that the symbol was defined
+	//Don't bother if we're doing xdomain (asynchronous) loading.
+	if(!omitModuleCheck && !this["isXDomain"]){
+		// pass in false so we can give better error
+		module = this.findModule(moduleName, false);
+		if(!module){
+			dojo.raise("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'"); 
+		}
+	}
+
+	return module;
+}
+
+dojo.hostenv.startPackage = function(/*String*/packageName){
+// summary:
+//	Creates a JavaScript package
+//
+// description:
+//	startPackage("A.B") follows the path, and at each level creates a new empty
+//	object or uses what already exists. It returns the result.
+//
+// packageName: the package to be created as a String in dot notation
+
+	//Make sure we have a string.
+	var fullPkgName = String(packageName);
+	var strippedPkgName = fullPkgName;
+
+	var syms = packageName.split(/\./);
+	if(syms[syms.length-1]=="*"){
+		syms.pop();
+		strippedPkgName = syms.join(".");
+	}
+	var evaledPkg = dojo.evalObjPath(strippedPkgName, true);
+	this.loaded_modules_[fullPkgName] = evaledPkg;
+	this.loaded_modules_[strippedPkgName] = evaledPkg;
+	
+	return evaledPkg; // Object
+}
+
+dojo.hostenv.findModule = function(/*String*/moduleName, /*Boolean?*/mustExist){
+// summary:
+//	Returns the Object representing the module, if it exists, otherwise null.
+//
+// moduleName A fully qualified module including package name, like 'A.B'.
+// mustExist Optional, default false. throw instead of returning null
+//	if the module does not currently exist.
+
+	var lmn = String(moduleName);
+
+	if(this.loaded_modules_[lmn]){
+		return this.loaded_modules_[lmn]; // Object
+	}
+
+	if(mustExist){
+		dojo.raise("no loaded module named '" + moduleName + "'");
+	}
+	return null; // null
+}
+
+//Start of old bootstrap2:
+
+dojo.kwCompoundRequire = function(/*Object containing Arrays*/modMap){
+// description:
+//	This method taks a "map" of arrays which one can use to optionally load dojo
+//	modules. The map is indexed by the possible dojo.hostenv.name_ values, with
+//	two additional values: "default" and "common". The items in the "default"
+//	array will be loaded if none of the other items have been choosen based on
+//	the hostenv.name_ item. The items in the "common" array will _always_ be
+//	loaded, regardless of which list is chosen.  Here's how it's normally
+//	called:
+//	
+//	dojo.kwCompoundRequire({
+//		browser: [
+//			["foo.bar.baz", true, true], // an example that passes multiple args to loadModule()
+//			"foo.sample.*",
+//			"foo.test,
+//		],
+//		default: [ "foo.sample.*" ],
+//		common: [ "really.important.module.*" ]
+//	});
+
+	var common = modMap["common"]||[];
+	var result = modMap[dojo.hostenv.name_] ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]);
+
+	for(var x=0; x<result.length; x++){
+		var curr = result[x];
+		if(curr.constructor == Array){
+			dojo.hostenv.loadModule.apply(dojo.hostenv, curr);
+		}else{
+			dojo.hostenv.loadModule(curr);
+		}
+	}
+}
+
+dojo.require = function(/*String*/ resourceName){
+	// summary
+	//	Ensure that the given resource (ie, javascript
+	//	source file) has been loaded.
+	// description
+	//	dojo.require() is similar to C's #include command or java's "import" command.
+	//	You call dojo.require() to pull in the resources (ie, javascript source files)
+	//	that define the functions you are using. 
+	//
+	//	Note that in the case of a build, many resources have already been included
+	//	into dojo.js (ie, many of the javascript source files have been compressed and
+	//	concatened into dojo.js), so many dojo.require() calls will simply return
+	//	without downloading anything.
+	dojo.hostenv.loadModule.apply(dojo.hostenv, arguments);
+}
+
+dojo.requireIf = function(/*Boolean*/ condition, /*String*/ resourceName){
+	// summary
+	//	If the condition is true then call dojo.require() for the specified resource
+	var arg0 = arguments[0];
+	if((arg0 === true)||(arg0=="common")||(arg0 && dojo.render[arg0].capable)){
+		var args = [];
+		for (var i = 1; i < arguments.length; i++) { args.push(arguments[i]); }
+		dojo.require.apply(dojo, args);
+	}
+}
+
+dojo.requireAfterIf = dojo.requireIf;
+
+dojo.provide = function(/*String*/ resourceName){
+	// summary
+	//	Each javascript source file must have (exactly) one dojo.provide()
+	//	call at the top of the file, corresponding to the file name.
+	//	For example, dojo/src/foo.js must have dojo.provide("dojo.foo"); at the top of the file.
+	//
+	// description
+	//	Each javascript source file is called a resource.  When a resource
+	//	is loaded by the browser, dojo.provide() registers that it has
+	//	been loaded.
+	//	
+	//	For backwards compatibility reasons, in addition to registering the resource,
+	//	dojo.provide() also ensures that the javascript object for the module exists.  For
+	//	example, dojo.provide("dojo.html.common"), in addition to registering that common.js
+	//	is a resource for the dojo.html module, will ensure that the dojo.html javascript object
+	//	exists, so that calls like dojo.html.foo = function(){ ... } don't fail.
+	//
+	//	In the case of a build (or in the future, a rollup), where multiple javascript source
+	//	files are combined into one bigger file (similar to a .lib or .jar file), that file
+	//	will contain multiple dojo.provide() calls, to note that it includes
+	//	multiple resources.
+	return dojo.hostenv.startPackage.apply(dojo.hostenv, arguments);
+}
+
+dojo.registerModulePath = function(/*String*/module, /*String*/prefix){
+	// summary: maps a module name to a path
+	// description: An unregistered module is given the default path of ../<module>,
+	//	relative to Dojo root. For example, module acme is mapped to ../acme.
+	//	If you want to use a different module name, use dojo.registerModulePath. 
+	return dojo.hostenv.setModulePrefix(module, prefix);
+}
+
+dojo.setModulePrefix = function(/*String*/module, /*String*/prefix){
+	// summary: maps a module name to a path
+	dojo.deprecated('dojo.setModulePrefix("' + module + '", "' + prefix + '")', "replaced by dojo.registerModulePath", "0.5");
+	return dojo.registerModulePath(module, prefix);
+}
+
+dojo.exists = function(/*Object*/obj, /*String*/name){
+	// 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
+	var p = name.split(".");
+	for(var i = 0; i < p.length; i++){
+		if(!obj[p[i]]){ return false; } // Boolean
+		obj = obj[p[i]];
+	}
+	return true; // Boolean
+}
+
+// Localization routines
+
+dojo.hostenv.normalizeLocale = function(/*String?*/locale){
+//	summary:
+//		Returns canonical form of locale, as used by Dojo.  All variants are case-insensitive and are separated by '-'
+//		as specified in RFC 3066. If no locale is specified, the user agent's default is returned.
+
+	var result = locale ? locale.toLowerCase() : dojo.locale;
+	if(result == "root"){
+		result = "ROOT";
+	}
+	return result;// String
+};
+
+dojo.hostenv.searchLocalePath = function(/*String*/locale, /*Boolean*/down, /*Function*/searchFunc){
+//	summary:
+//		A helper method to assist in searching for locale-based resources.  Will iterate through
+//		the variants of a particular locale, either up or down, executing a callback function.
+//		For example, "en-us" and true will try "en-us" followed by "en" and finally "ROOT".
+
+	locale = dojo.hostenv.normalizeLocale(locale);
+
+	var elements = locale.split('-');
+	var searchlist = [];
+	for(var i = elements.length; i > 0; i--){
+		searchlist.push(elements.slice(0, i).join('-'));
+	}
+	searchlist.push(false);
+	if(down){searchlist.reverse();}
+
+	for(var j = searchlist.length - 1; j >= 0; j--){
+		var loc = searchlist[j] || "ROOT";
+		var stop = searchFunc(loc);
+		if(stop){ break; }
+	}
+}
+
+//These two functions are placed outside of preloadLocalizations
+//So that the xd loading can use/override them.
+dojo.hostenv.localesGenerated /***BUILD:localesGenerated***/; // value will be inserted here at build time, if necessary
+
+dojo.hostenv.registerNlsPrefix = function(){
+// summary:
+//	Register module "nls" to point where Dojo can find pre-built localization files
+	dojo.registerModulePath("nls","nls");	
+}
+
+dojo.hostenv.preloadLocalizations = function(){
+// summary:
+//	Load built, flattened resource bundles, if available for all locales used in the page.
+//	Execute only once.  Note that this is a no-op unless there is a build.
+
+	if(dojo.hostenv.localesGenerated){
+		dojo.hostenv.registerNlsPrefix();
+
+		function preload(locale){
+			locale = dojo.hostenv.normalizeLocale(locale);
+			dojo.hostenv.searchLocalePath(locale, true, function(loc){
+				for(var i=0; i<dojo.hostenv.localesGenerated.length;i++){
+					if(dojo.hostenv.localesGenerated[i] == loc){
+						dojo["require"]("nls.dojo_"+loc);
+						return true; // Boolean
+					}
+				}
+				return false; // Boolean
+			});
+		}
+		preload();
+		var extra = djConfig.extraLocale||[];
+		for(var i=0; i<extra.length; i++){
+			preload(extra[i]);
+		}
+	}
+	dojo.hostenv.preloadLocalizations = function(){};
+}
+
+dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){
+// summary:
+//	Declares translated resources and loads them if necessary, in the same style as dojo.require.
+//	Contents of the resource bundle are typically strings, but may be any name/value pair,
+//	represented in JSON format.  See also dojo.i18n.getLocalization.
+//
+// moduleName: name of the package containing the "nls" directory in which the bundle is found
+// bundleName: bundle name, i.e. the filename without the '.js' suffix
+// locale: the locale to load (optional)  By default, the browser's user locale as defined by dojo.locale
+// availableFlatLocales: A comma-separated list of the available, flattened locales for this bundle.
+// This argument should only be set by the build process.
+//
+// description:
+//	Load translated resource bundles provided underneath the "nls" directory within a package.
+//	Translated resources may be located in different packages throughout the source tree.  For example,
+//	a particular widget may define one or more resource bundles, structured in a program as follows,
+//	where moduleName is mycode.mywidget and bundleNames available include bundleone and bundletwo:
+//	...
+//	mycode/
+//	 mywidget/
+//	  nls/
+//	   bundleone.js (the fallback translation, English in this example)
+//	   bundletwo.js (also a fallback translation)
+//	   de/
+//	    bundleone.js
+//	    bundletwo.js
+//	   de-at/
+//	    bundleone.js
+//	   en/
+//	    (empty; use the fallback translation)
+//	   en-us/
+//	    bundleone.js
+//	   en-gb/
+//	    bundleone.js
+//	   es/
+//	    bundleone.js
+//	    bundletwo.js
+//	  ...etc
+//	...
+//	Each directory is named for a locale as specified by RFC 3066, (http://www.ietf.org/rfc/rfc3066.txt),
+//	normalized in lowercase.  Note that the two bundles in the example do not define all the same variants.
+//	For a given locale, bundles will be loaded for that locale and all more general locales above it, including
+//	a fallback at the root directory.  For example, a declaration for the "de-at" locale will first
+//	load nls/de-at/bundleone.js, then nls/de/bundleone.js and finally nls/bundleone.js.  The data will
+//	be flattened into a single Object so that lookups will follow this cascading pattern.  An optional build
+//	step can preload the bundles to avoid data redundancy and the multiple network hits normally required to
+//	load these resources.
+
+	dojo.hostenv.preloadLocalizations();
+	var targetLocale = dojo.hostenv.normalizeLocale(locale);
+ 	var bundlePackage = [moduleName, "nls", bundleName].join(".");
+//NOTE: When loading these resources, the packaging does not match what is on disk.  This is an
+// implementation detail, as this is just a private data structure to hold the loaded resources.
+// e.g. tests/hello/nls/en-us/salutations.js is loaded as the object tests.hello.nls.salutations.en_us={...}
+// The structure on disk is intended to be most convenient for developers and translators, but in memory
+// it is more logical and efficient to store in a different order.  Locales cannot use dashes, since the
+// resulting path will not evaluate as valid JS, so we translate them to underscores.
+	
+	//Find the best-match locale to load if we have available flat locales.
+	var bestLocale = "";
+	if(availableFlatLocales){
+		var flatLocales = availableFlatLocales.split(",");
+		for(var i = 0; i < flatLocales.length; i++){
+			//Locale must match from start of string.
+			if(targetLocale.indexOf(flatLocales[i]) == 0){
+				if(flatLocales[i].length > bestLocale.length){
+					bestLocale = flatLocales[i];
+				}
+			}
+		}
+		if(!bestLocale){
+			bestLocale = "ROOT";
+		}		
+	}
+
+	//See if the desired locale is already loaded.
+	var tempLocale = availableFlatLocales ? bestLocale : targetLocale;
+	var bundle = dojo.hostenv.findModule(bundlePackage);
+	var localizedBundle = null;
+	if(bundle){
+		if(djConfig.localizationComplete && bundle._built){return;}
+		var jsLoc = tempLocale.replace('-', '_');
+		var translationPackage = bundlePackage+"."+jsLoc;
+		localizedBundle = dojo.hostenv.findModule(translationPackage);
+	}
+
+	if(!localizedBundle){
+		bundle = dojo.hostenv.startPackage(bundlePackage);
+		var syms = dojo.hostenv.getModuleSymbols(moduleName);
+		var modpath = syms.concat("nls").join("/");
+		var parent;
+
+		dojo.hostenv.searchLocalePath(tempLocale, availableFlatLocales, function(loc){
+			var jsLoc = loc.replace('-', '_');
+			var translationPackage = bundlePackage + "." + jsLoc;
+			var loaded = false;
+			if(!dojo.hostenv.findModule(translationPackage)){
+				// Mark loaded whether it's found or not, so that further load attempts will not be made
+				dojo.hostenv.startPackage(translationPackage);
+				var module = [modpath];
+				if(loc != "ROOT"){module.push(loc);}
+				module.push(bundleName);
+				var filespec = module.join("/") + '.js';
+				loaded = dojo.hostenv.loadPath(filespec, null, function(hash){
+					// Use singleton with prototype to point to parent bundle, then mix-in result from loadPath
+					var clazz = function(){};
+					clazz.prototype = parent;
+					bundle[jsLoc] = new clazz();
+					for(var j in hash){ bundle[jsLoc][j] = hash[j]; }
+				});
+			}else{
+				loaded = true;
+			}
+			if(loaded && bundle[jsLoc]){
+				parent = bundle[jsLoc];
+			}else{
+				bundle[jsLoc] = parent;
+			}
+			
+			if(availableFlatLocales){
+				//Stop the locale path searching if we know the availableFlatLocales, since
+				//the first call to this function will load the only bundle that is needed.
+				return true;
+			}
+		});
+	}
+
+	//Save the best locale bundle as the target locale bundle when we know the
+	//the available bundles.
+	if(availableFlatLocales && targetLocale != bestLocale){
+		bundle[targetLocale.replace('-', '_')] = bundle[bestLocale.replace('-', '_')];
+	}
+};
+
+(function(){
+	// If other locales are used, dojo.requireLocalization should load them as well, by default.
+	// Override dojo.requireLocalization to do load the default bundle, then iterate through the
+	// extraLocale list and load those translations as well, unless a particular locale was requested.
+
+	var extra = djConfig.extraLocale;
+	if(extra){
+		if(!extra instanceof Array){
+			extra = [extra];
+		}
+
+		var req = dojo.requireLocalization;
+		dojo.requireLocalization = function(m, b, locale, availableFlatLocales){
+			req(m,b,locale, availableFlatLocales);
+			if(locale){return;}
+			for(var i=0; i<extra.length; i++){
+				req(m,b,extra[i], availableFlatLocales);
+			}
+		};
+	}
+})();
+
+};
+
+if(typeof window != 'undefined'){
+
+	// attempt to figure out the path to dojo if it isn't set in the config
+	(function(){
+		// before we get any further with the config options, try to pick them out
+		// of the URL. Most of this code is from NW
+		if(djConfig.allowQueryConfig){
+			var baseUrl = document.location.toString(); // FIXME: use location.query instead?
+			var params = baseUrl.split("?", 2);
+			if(params.length > 1){
+				var paramStr = params[1];
+				var pairs = paramStr.split("&");
+				for(var x in pairs){
+					var sp = pairs[x].split("=");
+					// FIXME: is this eval dangerous?
+					if((sp[0].length > 9)&&(sp[0].substr(0, 9) == "djConfig.")){
+						var opt = sp[0].substr(9);
+						try{
+							djConfig[opt]=eval(sp[1]);
+						}catch(e){
+							djConfig[opt]=sp[1];
+						}
+					}
+				}
+			}
+		}
+
+		if(
+			((djConfig["baseScriptUri"] == "")||(djConfig["baseRelativePath"] == "")) && 
+			(document && document.getElementsByTagName)
+		){
+			var scripts = document.getElementsByTagName("script");
+			var rePkg = /(__package__|dojo|bootstrap1)\.js([\?\.]|$)/i;
+			for(var i = 0; i < scripts.length; i++) {
+				var src = scripts[i].getAttribute("src");
+				if(!src) { continue; }
+				var m = src.match(rePkg);
+				if(m) {
+					var root = src.substring(0, m.index);
+					if(src.indexOf("bootstrap1") > -1) { root += "../"; }
+					if(!this["djConfig"]) { djConfig = {}; }
+					if(djConfig["baseScriptUri"] == "") { djConfig["baseScriptUri"] = root; }
+					if(djConfig["baseRelativePath"] == "") { djConfig["baseRelativePath"] = root; }
+					break;
+				}
+			}
+		}
+
+		// fill in the rendering support information in dojo.render.*
+		var dr = dojo.render;
+		var drh = dojo.render.html;
+		var drs = dojo.render.svg;
+		var dua = (drh.UA = navigator.userAgent);
+		var dav = (drh.AV = navigator.appVersion);
+		var t = true;
+		var f = false;
+		drh.capable = t;
+		drh.support.builtin = t;
+
+		dr.ver = parseFloat(drh.AV);
+		dr.os.mac = dav.indexOf("Macintosh") >= 0;
+		dr.os.win = dav.indexOf("Windows") >= 0;
+		// could also be Solaris or something, but it's the same browser
+		dr.os.linux = dav.indexOf("X11") >= 0;
+
+		drh.opera = dua.indexOf("Opera") >= 0;
+		drh.khtml = (dav.indexOf("Konqueror") >= 0)||(dav.indexOf("Safari") >= 0);
+		drh.safari = dav.indexOf("Safari") >= 0;
+		var geckoPos = dua.indexOf("Gecko");
+		drh.mozilla = drh.moz = (geckoPos >= 0)&&(!drh.khtml);
+		if (drh.mozilla) {
+			// gecko version is YYYYMMDD
+			drh.geckoVersion = dua.substring(geckoPos + 6, geckoPos + 14);
+		}
+		drh.ie = (document.all)&&(!drh.opera);
+		drh.ie50 = drh.ie && dav.indexOf("MSIE 5.0")>=0;
+		drh.ie55 = drh.ie && dav.indexOf("MSIE 5.5")>=0;
+		drh.ie60 = drh.ie && dav.indexOf("MSIE 6.0")>=0;
+		drh.ie70 = drh.ie && dav.indexOf("MSIE 7.0")>=0;
+
+		var cm = document["compatMode"];
+		drh.quirks = (cm == "BackCompat")||(cm == "QuirksMode")||drh.ie55||drh.ie50;
+
+		// TODO: is the HTML LANG attribute relevant?
+		dojo.locale = dojo.locale || (drh.ie ? navigator.userLanguage : navigator.language).toLowerCase();
+
+		dr.vml.capable=drh.ie;
+		drs.capable = f;
+		drs.support.plugin = f;
+		drs.support.builtin = f;
+		var tdoc = window["document"];
+		var tdi = tdoc["implementation"];
+
+		if((tdi)&&(tdi["hasFeature"])&&(tdi.hasFeature("org.w3c.dom.svg", "1.0"))){
+			drs.capable = t;
+			drs.support.builtin = t;
+			drs.support.plugin = f;
+		}
+		// webkits after 420 support SVG natively. The test string is "AppleWebKit/420+"
+		if(drh.safari){
+			var tmp = dua.split("AppleWebKit/")[1];
+			var ver = parseFloat(tmp.split(" ")[0]);
+			if(ver >= 420){
+				drs.capable = t;
+				drs.support.builtin = t;
+				drs.support.plugin = f;
+			}
+		}else{
+		}
+	})();
+
+	dojo.hostenv.startPackage("dojo.hostenv");
+
+	dojo.render.name = dojo.hostenv.name_ = 'browser';
+	dojo.hostenv.searchIds = [];
+
+	// These are in order of decreasing likelihood; this will change in time.
+	dojo.hostenv._XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
+
+	dojo.hostenv.getXmlhttpObject = function(){
+		// summary: does the work of portably generating a new XMLHTTPRequest object.
+		var http = null;
+		var last_e = null;
+		try{ http = new XMLHttpRequest(); }catch(e){}
+		if(!http){
+			for(var i=0; i<3; ++i){
+				var progid = dojo.hostenv._XMLHTTP_PROGIDS[i];
+				try{
+					http = new ActiveXObject(progid);
+				}catch(e){
+					last_e = e;
+				}
+
+				if(http){
+					dojo.hostenv._XMLHTTP_PROGIDS = [progid];  // so faster next time
+					break;
+				}
+			}
+
+			/*if(http && !http.toString) {
+				http.toString = function() { "[object XMLHttpRequest]"; }
+			}*/
+		}
+
+		if(!http){
+			return dojo.raise("XMLHTTP not available", last_e);
+		}
+
+		return http; // XMLHTTPRequest instance
+	}
+
+	dojo.hostenv._blockAsync = false;
+	dojo.hostenv.getText = function(uri, async_cb, fail_ok){
+		// summary: Read the contents of the specified uri and return those contents.
+		// uri:
+		//		A relative or absolute uri. If absolute, it still must be in
+		//		the same "domain" as we are.
+		// async_cb:
+		//		If not specified, load synchronously. If specified, load
+		//		asynchronously, and use async_cb as the progress handler which
+		//		takes the xmlhttp object as its argument. If async_cb, this
+		//		function returns null.
+		// fail_ok:
+		//		Default false. If fail_ok and !async_cb and loading fails,
+		//		return null instead of throwing.
+
+		// need to block async callbacks from snatching this thread as the result
+		// of an async callback might call another sync XHR, this hangs khtml forever
+		// hostenv._blockAsync must also be checked in BrowserIO's watchInFlight()
+		// NOTE: must be declared before scope switches ie. this.getXmlhttpObject()
+		if(!async_cb){ this._blockAsync = true; }
+
+		var http = this.getXmlhttpObject();
+
+		function isDocumentOk(http){
+			var stat = http["status"];
+			// allow a 304 use cache, needed in konq (is this compliant with the http spec?)
+			return Boolean((!stat)||((200 <= stat)&&(300 > stat))||(stat==304));
+		}
+
+		if(async_cb){
+			var _this = this, timer = null, gbl = dojo.global();
+			var xhr = dojo.evalObjPath("dojo.io.XMLHTTPTransport");
+			http.onreadystatechange = function(){
+				if(timer){ gbl.clearTimeout(timer); timer = null; }
+				if(_this._blockAsync || (xhr && xhr._blockAsync)){
+					timer = gbl.setTimeout(function () { http.onreadystatechange.apply(this); }, 10);
+				}else{
+					if(4==http.readyState){
+						if(isDocumentOk(http)){
+							// dojo.debug("LOADED URI: "+uri);
+							async_cb(http.responseText);
+						}
+					}
+				}
+			}
+		}
+
+		http.open('GET', uri, async_cb ? true : false);
+		try{
+			http.send(null);
+			if(async_cb){
+				return null;
+			}
+			if(!isDocumentOk(http)){
+				var err = Error("Unable to load "+uri+" status:"+ http.status);
+				err.status = http.status;
+				err.responseText = http.responseText;
+				throw err;
+			}
+		}catch(e){
+			this._blockAsync = false;
+			if((fail_ok)&&(!async_cb)){
+				return null;
+			}else{
+				throw e;
+			}
+		}
+
+		this._blockAsync = false;
+		return http.responseText; // String
+	}
+
+	dojo.hostenv.defaultDebugContainerId = 'dojoDebug';
+	dojo.hostenv._println_buffer = [];
+	dojo.hostenv._println_safe = false;
+	dojo.hostenv.println = function(/*String*/line){
+		// summary:
+		//		prints the provided line to whatever logging container is
+		//		available. If the page isn't loaded yet, the line may be added
+		//		to a buffer for printing later.
+		if(!dojo.hostenv._println_safe){
+			dojo.hostenv._println_buffer.push(line);
+		}else{
+			try {
+				var console = document.getElementById(djConfig.debugContainerId ?
+					djConfig.debugContainerId : dojo.hostenv.defaultDebugContainerId);
+				if(!console) { console = dojo.body(); }
+
+				var div = document.createElement("div");
+				div.appendChild(document.createTextNode(line));
+				console.appendChild(div);
+			} catch (e) {
+				try{
+					// safari needs the output wrapped in an element for some reason
+					document.write("<div>" + line + "</div>");
+				}catch(e2){
+					window.status = line;
+				}
+			}
+		}
+	}
+
+	dojo.addOnLoad(function(){
+		dojo.hostenv._println_safe = true;
+		while(dojo.hostenv._println_buffer.length > 0){
+			dojo.hostenv.println(dojo.hostenv._println_buffer.shift());
+		}
+	});
+
+	function dj_addNodeEvtHdlr(/*DomNode*/node, /*String*/evtName, /*Function*/fp){
+		// summary:
+		//		non-destructively adds the specified function to the node's
+		//		evtName handler.
+		// node: the DomNode to add the handler to
+		// evtName: should be in the form "click" for "onclick" handlers
+		var oldHandler = node["on"+evtName] || function(){};
+		node["on"+evtName] = function(){
+			fp.apply(node, arguments);
+			oldHandler.apply(node, arguments);
+		}
+		return true;
+	}
+
+	//	BEGIN DOMContentLoaded, from Dean Edwards (http://dean.edwards.name/weblog/2006/06/again/)
+	function dj_load_init(e){
+		// allow multiple calls, only first one will take effect
+		// A bug in khtml calls events callbacks for document for event which isnt supported
+		// for example a created contextmenu event calls DOMContentLoaded, workaround
+		var type = (e && e.type) ? e.type.toLowerCase() : "load";
+		if(arguments.callee.initialized || (type!="domcontentloaded" && type!="load")){ return; }
+		arguments.callee.initialized = true;
+		if(typeof(_timer) != 'undefined'){
+			clearInterval(_timer);
+			delete _timer;
+		}
+
+		var initFunc = function(){
+			//perform initialization
+			if(dojo.render.html.ie){
+				dojo.hostenv.makeWidgets();
+			}
+		};
+
+		if(dojo.hostenv.inFlightCount == 0){
+			initFunc();
+			dojo.hostenv.modulesLoaded();
+		}else{
+			//This else case should be xdomain loading.
+			//Make sure this is the first thing in the load listener array.
+			//Part of the dojo.addOnLoad guarantee is that when the listeners are notified,
+			//It means the DOM (or page) has loaded and that widgets have been parsed.
+			dojo.hostenv.modulesLoadedListeners.unshift(initFunc);
+		}
+	}
+
+	//	START DOMContentLoaded
+	// Mozilla and Opera 9 expose the event we could use
+	if(document.addEventListener){
+		if(dojo.render.html.opera || (dojo.render.html.moz && !djConfig.delayMozLoadingFix)){
+			document.addEventListener("DOMContentLoaded", dj_load_init, null);
+		}
+
+		//	mainly for Opera 8.5, won't be fired if DOMContentLoaded fired already.
+		//  also used for Mozilla because of trac #1640
+		window.addEventListener("load", dj_load_init, null);
+	}
+
+	// 	for Internet Explorer. readyState will not be achieved on init call, but dojo doesn't need it
+	//	however, we'll include it because we don't know if there are other functions added that might.
+	//	Note that this has changed because the build process strips all comments--including conditional
+	//		ones.
+	if(dojo.render.html.ie && dojo.render.os.win){
+		document.attachEvent("onreadystatechange", function(e){
+			if(document.readyState == "complete"){
+				dj_load_init();
+			}
+		});
+	}
+
+	if (/(WebKit|khtml)/i.test(navigator.userAgent)) { // sniff
+		var _timer = setInterval(function() {
+			if (/loaded|complete/.test(document.readyState)) {
+				dj_load_init(); // call the onload handler
+			}
+		}, 10);
+	}
+	//	END DOMContentLoaded
+
+	// IE WebControl hosted in an application can fire "beforeunload" and "unload"
+	// events when control visibility changes, causing Dojo to unload too soon. The
+	// following code fixes the problem
+	// Reference: http://support.microsoft.com/default.aspx?scid=kb;en-us;199155
+	if(dojo.render.html.ie){
+		dj_addNodeEvtHdlr(window, "beforeunload", function(){
+			dojo.hostenv._unloading = true;
+			window.setTimeout(function() {
+				dojo.hostenv._unloading = false;
+			}, 0);
+		});
+	}
+
+	dj_addNodeEvtHdlr(window, "unload", function(){
+		dojo.hostenv.unloaded();
+		if((!dojo.render.html.ie)||(dojo.render.html.ie && dojo.hostenv._unloading)){
+			dojo.hostenv.unloaded();
+		}
+	});
+
+	dojo.hostenv.makeWidgets = function(){
+		// you can put searchIds in djConfig and dojo.hostenv at the moment
+		// we should probably eventually move to one or the other
+		var sids = [];
+		if(djConfig.searchIds && djConfig.searchIds.length > 0) {
+			sids = sids.concat(djConfig.searchIds);
+		}
+		if(dojo.hostenv.searchIds && dojo.hostenv.searchIds.length > 0) {
+			sids = sids.concat(dojo.hostenv.searchIds);
+		}
+
+		if((djConfig.parseWidgets)||(sids.length > 0)){
+			if(dojo.evalObjPath("dojo.widget.Parse")){
+				// we must do this on a delay to avoid:
+				//	http://www.shaftek.org/blog/archives/000212.html
+				// (IE bug)
+					var parser = new dojo.xml.Parse();
+					if(sids.length > 0){
+						for(var x=0; x<sids.length; x++){
+							var tmpNode = document.getElementById(sids[x]);
+							if(!tmpNode){ continue; }
+							var frag = parser.parseElement(tmpNode, null, true);
+							dojo.widget.getParser().createComponents(frag);
+						}
+					}else if(djConfig.parseWidgets){
+						var frag  = parser.parseElement(dojo.body(), null, true);
+						dojo.widget.getParser().createComponents(frag);
+					}
+			}
+		}
+	}
+
+	dojo.addOnLoad(function(){
+		if(!dojo.render.html.ie) {
+			dojo.hostenv.makeWidgets();
+		}
+	});
+
+	try{
+		if(dojo.render.html.ie){
+			document.namespaces.add("v","urn:schemas-microsoft-com:vml");
+			document.createStyleSheet().addRule("v\\:*", "behavior:url(#default#VML)");
+		}
+	}catch(e){ }
+
+	// stub, over-ridden by debugging code. This will at least keep us from
+	// breaking when it's not included
+	dojo.hostenv.writeIncludes = function(){}
+
+	//TODOC:  HOW TO DOC THIS?
+	// @global: dj_currentDocument
+	// summary:
+	//		Current document object. 'dj_currentDocument' can be modified for temporary context shifting.
+	// description:
+	//    dojo.doc() returns dojo.currentDocument.
+	//		Refer to dojo.doc() rather than referring to 'window.document' to ensure your
+	//		code runs correctly in managed contexts.
+	if(!dj_undef("document", this)){
+		dj_currentDocument = this.document;
+	}
+
+	dojo.doc = function(){
+		// summary:
+		//		return the document object associated with the dojo.global()
+		return dj_currentDocument;
+	}
+
+	dojo.body = function(){
+		// summary:
+		//		return the body object associated with dojo.doc()
+		// Note: document.body is not defined for a strict xhtml document
+		return dojo.doc().body || dojo.doc().getElementsByTagName("body")[0];
+	}
+
+	dojo.byId = function(/*String*/id, /*DocumentElement*/doc){
+		// summary:
+		// 		similar to other library's "$" function, takes a string
+		// 		representing a DOM id or a DomNode and returns the
+		// 		corresponding DomNode. If a Node is passed, this function is a
+		// 		no-op. Returns a single DOM node or null, working around
+		// 		several browser-specific bugs to do so.
+		// id: DOM id or DOM Node
+		// doc:
+		//		optional, defaults to the current value of dj_currentDocument.
+		//		Can be used to retreive node references from other documents.
+		if((id)&&((typeof id == "string")||(id instanceof String))){
+			if(!doc){ doc = dj_currentDocument; }
+			var ele = doc.getElementById(id);
+			// workaround bug in IE and Opera 8.2 where getElementById returns wrong element
+			if(ele && (ele.id != id) && doc.all){
+				ele = null;
+				// get all matching elements with this id
+				eles = doc.all[id];
+				if(eles){
+					// if more than 1, choose first with the correct id
+					if(eles.length){
+						for(var i=0; i<eles.length; i++){
+							if(eles[i].id == id){
+								ele = eles[i];
+								break;
+							}
+						}
+					// return 1 and only element
+					}else{
+						ele = eles;
+					}
+				}
+			}
+			return ele; // DomNode
+		}
+		return id; // DomNode
+	}
+
+	dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){
+		// summary:
+		//		changes the behavior of many core Dojo functions that deal with
+		//		namespace and DOM lookup, changing them to work in a new global
+		//		context. The varibles dj_currentContext and dj_currentDocument
+		//		are modified as a result of calling this function.
+		dj_currentContext = globalObject;
+		dj_currentDocument = globalDocument;
+	};
+
+	dojo._fireCallback = function(callback, context, cbArguments){
+		if((context)&&((typeof callback == "string")||(callback instanceof String))){
+			callback=context[callback];
+		}
+		return (context ? callback.apply(context, cbArguments || [ ]) : callback());
+	}
+
+	dojo.withGlobal = function(/*Object*/globalObject, /*Function*/callback, /*Object?*/thisObject, /*Array?*/cbArguments){
+		// summary:
+		//		Call callback with globalObject as dojo.global() and globalObject.document
+		//		as dojo.doc(). If provided, globalObject will be executed in the context of
+		//		object thisObject
+		// description:
+		//		When callback() returns or throws an error, the dojo.global() and dojo.doc() will
+		//		be restored to its previous state.
+		var rval;
+		var oldGlob = dj_currentContext;
+		var oldDoc = dj_currentDocument;
+		try{
+			dojo.setContext(globalObject, globalObject.document);
+			rval = dojo._fireCallback(callback, thisObject, cbArguments);
+		}finally{
+			dojo.setContext(oldGlob, oldDoc);
+		}
+		return rval;
+	}
+
+	dojo.withDoc = function (/*Object*/documentObject, /*Function*/callback, /*Object?*/thisObject, /*Array?*/cbArguments) {
+		// summary:
+		//		Call callback with documentObject as dojo.doc(). If provided, callback will be executed
+		//		in the context of object thisObject
+		// description:
+		//		When callback() returns or throws an error, the dojo.doc() will
+		//		be restored to its previous state.
+		var rval;
+		var oldDoc = dj_currentDocument;
+		try{
+			dj_currentDocument = documentObject;
+			rval = dojo._fireCallback(callback, thisObject, cbArguments);
+		}finally{
+			dj_currentDocument = oldDoc;
+		}
+		return rval;
+	}
+
+} //if (typeof window != 'undefined')
+
+//Semicolon is for when this file is integrated with a custom build on one line
+//with some other file's contents. Sometimes that makes things not get defined
+//properly, particularly with the using the closure below to do all the work.
+;(function(){
+	//Don't do this work if dojo.js has already done it.
+	if(typeof dj_usingBootstrap != "undefined"){
+		return;
+	}
+
+	var isRhino = false;
+	var isSpidermonkey = false;
+	var isDashboard = false;
+	if((typeof this["load"] == "function")&&((typeof this["Packages"] == "function")||(typeof this["Packages"] == "object"))){
+		isRhino = true;
+	}else if(typeof this["load"] == "function"){
+		isSpidermonkey  = true;
+	}else if(window.widget){
+		isDashboard = true;
+	}
+
+	var tmps = [];
+	if((this["djConfig"])&&((djConfig["isDebug"])||(djConfig["debugAtAllCosts"]))){
+		tmps.push("debug.js");
+	}
+
+	if((this["djConfig"])&&(djConfig["debugAtAllCosts"])&&(!isRhino)&&(!isDashboard)){
+		tmps.push("browser_debug.js");
+	}
+
+	var loaderRoot = djConfig["baseScriptUri"];
+	if((this["djConfig"])&&(djConfig["baseLoaderUri"])){
+		loaderRoot = djConfig["baseLoaderUri"];
+	}
+
+	for(var x=0; x < tmps.length; x++){
+		var spath = loaderRoot+"src/"+tmps[x];
+		if(isRhino||isSpidermonkey){
+			load(spath);
+		} else {
+			try {
+				document.write("<scr"+"ipt type='text/javascript' src='"+spath+"'></scr"+"ipt>");
+			} catch (e) {
+				var script = document.createElement("script");
+				script.src = spath;
+				document.getElementsByTagName("head")[0].appendChild(script);
+			}
+		}
+	}
+})();
+
+dojo.provide("dojo.lang.common");
+
+dojo.lang.inherits = function(/*Function*/subclass, /*Function*/superclass){
+	// summary: Set up inheritance between two classes.
+	if(!dojo.lang.isFunction(superclass)){ 
+		dojo.raise("dojo.inherits: superclass argument ["+superclass+"] must be a function (subclass: ["+subclass+"']");
+	}
+	subclass.prototype = new superclass();
+	subclass.prototype.constructor = subclass;
+	subclass.superclass = superclass.prototype;
+	// DEPRECATED: super is a reserved word, use 'superclass'
+	subclass['super'] = superclass.prototype;
+}
+
+dojo.lang._mixin = function(/*Object*/ obj, /*Object*/ props){
+	// summary:
+	//		Adds all properties and methods of props to obj. This addition is
+	//		"prototype extension safe", so that instances of objects will not
+	//		pass along prototype defaults.
+	var tobj = {};
+	for(var x in props){
+		// the "tobj" condition avoid copying properties in "props"
+		// inherited from Object.prototype.  For example, if obj has a custom
+		// toString() method, don't overwrite it with the toString() method
+		// that props inherited from Object.protoype
+		if((typeof tobj[x] == "undefined") || (tobj[x] != props[x])){
+			obj[x] = props[x];
+		}
+	}
+	// IE doesn't recognize custom toStrings in for..in
+	if(dojo.render.html.ie 
+		&& (typeof(props["toString"]) == "function")
+		&& (props["toString"] != obj["toString"])
+		&& (props["toString"] != tobj["toString"]))
+	{
+		obj.toString = props.toString;
+	}
+	return obj; // Object
+}
+
+dojo.lang.mixin = function(/*Object*/obj, /*Object...*/props){
+	// summary:	Adds all properties and methods of props to obj. 
+	for(var i=1, l=arguments.length; i<l; i++){
+		dojo.lang._mixin(obj, arguments[i]);
+	}
+	return obj; // Object
+}
+
+dojo.lang.extend = function(/*Object*/ constructor, /*Object...*/ props){
+	// summary:
+	//		Adds all properties and methods of props to constructor's
+	//		prototype, making them available to all instances created with
+	//		constructor.
+	for(var i=1, l=arguments.length; i<l; i++){
+		dojo.lang._mixin(constructor.prototype, arguments[i]);
+	}
+	return constructor; // Object
+}
+
+// Promote to dojo module
+dojo.inherits = dojo.lang.inherits;
+//dojo.lang._mixin = dojo.lang._mixin;
+dojo.mixin = dojo.lang.mixin;
+dojo.extend = dojo.lang.extend;
+
+dojo.lang.find = function(	/*Array*/		array, 
+							/*Object*/		value,
+							/*Boolean?*/	identity,
+							/*Boolean?*/	findLast){
+	// summary:	
+	//		Return the index of value in array, returning -1 if not found.
+	// array: just what you think
+	// value: the value to locate
+	// identity: 
+	//		If true, matches with identity comparison (===). If false, uses
+	//		normal comparison (==).
+	// findLast: 
+	//		If true, returns index of last instance of value.
+	// examples:
+	//		find(array, value[, identity [findLast]]) // recommended
+ 	//		find(value, array[, identity [findLast]]) // deprecated
+							
+	// support both (array, value) and (value, array)
+	if(!dojo.lang.isArrayLike(array) && dojo.lang.isArrayLike(value)) {
+		dojo.deprecated('dojo.lang.find(value, array)', 'use dojo.lang.find(array, value) instead', "0.5");
+		var temp = array;
+		array = value;
+		value = temp;
+	}
+	var isString = dojo.lang.isString(array);
+	if(isString) { array = array.split(""); }
+
+	if(findLast) {
+		var step = -1;
+		var i = array.length - 1;
+		var end = -1;
+	} else {
+		var step = 1;
+		var i = 0;
+		var end = array.length;
+	}
+	if(identity){
+		while(i != end) {
+			if(array[i] === value){ return i; }
+			i += step;
+		}
+	}else{
+		while(i != end) {
+			if(array[i] == value){ return i; }
+			i += step;
+		}
+	}
+	return -1;	// number
+}
+
+dojo.lang.indexOf = dojo.lang.find;
+
+dojo.lang.findLast = function(/*Array*/array, /*Object*/value, /*boolean?*/identity){
+	// summary:
+	//		Return index of last occurance of value in array, returning -1 if
+	//		not found. This is a shortcut for dojo.lang.find() with a true
+	//		value for its "findLast" parameter.
+	// identity:
+	//		If true, matches with identity comparison (===). If false, uses
+	//		normal comparison (==).
+	return dojo.lang.find(array, value, identity, true); // number
+}
+
+dojo.lang.lastIndexOf = dojo.lang.findLast;
+
+dojo.lang.inArray = function(array /*Array*/, value /*Object*/){
+	// summary:	Return true if value is present in array.
+	return dojo.lang.find(array, value) > -1; // boolean
+}
+
+/**
+ * Partial implmentation of is* functions from
+ * http://www.crockford.com/javascript/recommend.html
+ * NOTE: some of these may not be the best thing to use in all situations
+ * as they aren't part of core JS and therefore can't work in every case.
+ * See WARNING messages inline for tips.
+ *
+ * The following is* functions are fairly "safe"
+ */
+
+dojo.lang.isObject = function(/*anything*/ it){
+	// summary:	Return true if it is an Object, Array or Function.
+	if(typeof it == "undefined"){ return false; }
+	return (typeof it == "object" || it === null || dojo.lang.isArray(it) || dojo.lang.isFunction(it)); // Boolean
+}
+
+dojo.lang.isArray = function(/*anything*/ it){
+	// summary:	Return true if it is an Array.
+	return (it && it instanceof Array || typeof it == "array"); // Boolean
+}
+
+dojo.lang.isArrayLike = function(/*anything*/ it){
+	// summary:	
+	//		Return true if it can be used as an array (i.e. is an object with
+	//		an integer length property).
+	if((!it)||(dojo.lang.isUndefined(it))){ return false; }
+	if(dojo.lang.isString(it)){ return false; }
+	if(dojo.lang.isFunction(it)){ return false; } // keeps out built-in constructors (Number, String, ...) which have length properties
+	if(dojo.lang.isArray(it)){ return true; }
+	// form node itself is ArrayLike, but not always iterable. Use form.elements instead.
+	if((it.tagName)&&(it.tagName.toLowerCase()=='form')){ return false; }
+	if(dojo.lang.isNumber(it.length) && isFinite(it.length)){ return true; }
+	return false; // Boolean
+}
+
+dojo.lang.isFunction = function(/*anything*/ it){
+	// summary:	Return true if it is a Function.
+	return (it instanceof Function || typeof it == "function"); // Boolean
+};
+
+(function(){
+	// webkit treats NodeList as a function, which is bad
+	if((dojo.render.html.capable)&&(dojo.render.html["safari"])){
+		dojo.lang.isFunction = function(/*anything*/ it){
+			if((typeof(it) == "function") && (it == "[object NodeList]")) { return false; }
+			return (it instanceof Function || typeof it == "function"); // Boolean
+		}
+	}
+})();
+
+dojo.lang.isString = function(/*anything*/ it){
+	// summary:	Return true if it is a String.
+	return (typeof it == "string" || it instanceof String);
+}
+
+dojo.lang.isAlien = function(/*anything*/ it){
+	// summary: Return true if it is not a built-in function. False if not.
+	if(!it){ return false; }
+	return !dojo.lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
+}
+
+dojo.lang.isBoolean = function(/*anything*/ it){
+	// summary:	Return true if it is a Boolean.
+	return (it instanceof Boolean || typeof it == "boolean"); // Boolean
+}
+
+/**
+ * The following is***() functions are somewhat "unsafe". Fortunately,
+ * there are workarounds the the language provides and are mentioned
+ * in the WARNING messages.
+ *
+ */
+dojo.lang.isNumber = function(/*anything*/ it){
+	// summary:	Return true if it is a number.
+	// description: 
+	//		WARNING - In most cases, isNaN(it) is sufficient to determine whether or not
+	// 		something is a number or can be used as such. For example, a number or string
+	// 		can be used interchangably when accessing array items (array["1"] is the same as
+	// 		array[1]) and isNaN will return false for both values ("1" and 1). However,
+	// 		isNumber("1")  will return false, which is generally not too useful.
+	// 		Also, isNumber(NaN) returns true, again, this isn't generally useful, but there
+	// 		are corner cases (like when you want to make sure that two things are really
+	// 		the same type of thing). That is really where isNumber "shines".
+	//
+	// Recommendation - Use isNaN(it) when possible
+	
+	return (it instanceof Number || typeof it == "number"); // Boolean
+}
+
+/*
+ * FIXME: Should isUndefined go away since it is error prone?
+ */
+dojo.lang.isUndefined = function(/*anything*/ it){
+	// summary: Return true if it is not defined.
+	// description: 
+	//		WARNING - In some cases, isUndefined will not behave as you
+	// 		might expect. If you do isUndefined(foo) and there is no earlier
+	// 		reference to foo, an error will be thrown before isUndefined is
+	// 		called. It behaves correctly if you scope yor object first, i.e.
+	// 		isUndefined(foo.bar) where foo is an object and bar isn't a
+	// 		property of the object.
+	//
+	// Recommendation - Use typeof foo == "undefined" when possible
+
+	return ((typeof(it) == "undefined")&&(it == undefined)); // Boolean
+}
+
+// end Crockford functions
+
+dojo.provide("dojo.lang");
+
+dojo.deprecated("dojo.lang", "replaced by dojo.lang.common", "0.5");
+
+dojo.provide("dojo.dom");
+
+dojo.dom.ELEMENT_NODE                  = 1;
+dojo.dom.ATTRIBUTE_NODE                = 2;
+dojo.dom.TEXT_NODE                     = 3;
+dojo.dom.CDATA_SECTION_NODE            = 4;
+dojo.dom.ENTITY_REFERENCE_NODE         = 5;
+dojo.dom.ENTITY_NODE                   = 6;
+dojo.dom.PROCESSING_INSTRUCTION_NODE   = 7;
+dojo.dom.COMMENT_NODE                  = 8;
+dojo.dom.DOCUMENT_NODE                 = 9;
+dojo.dom.DOCUMENT_TYPE_NODE            = 10;
+dojo.dom.DOCUMENT_FRAGMENT_NODE        = 11;
+dojo.dom.NOTATION_NODE                 = 12;
+	
+dojo.dom.dojoml = "http://www.dojotoolkit.org/2004/dojoml";
+
+/**
+ *	comprehensive list of XML namespaces
+**/
+dojo.dom.xmlns = {
+	//	summary
+	//	aliases for various common XML namespaces
+	svg : "http://www.w3.org/2000/svg",
+	smil : "http://www.w3.org/2001/SMIL20/",
+	mml : "http://www.w3.org/1998/Math/MathML",
+	cml : "http://www.xml-cml.org",
+	xlink : "http://www.w3.org/1999/xlink",
+	xhtml : "http://www.w3.org/1999/xhtml",
+	xul : "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
+	xbl : "http://www.mozilla.org/xbl",
+	fo : "http://www.w3.org/1999/XSL/Format",
+	xsl : "http://www.w3.org/1999/XSL/Transform",
+	xslt : "http://www.w3.org/1999/XSL/Transform",
+	xi : "http://www.w3.org/2001/XInclude",
+	xforms : "http://www.w3.org/2002/01/xforms",
+	saxon : "http://icl.com/saxon",
+	xalan : "http://xml.apache.org/xslt",
+	xsd : "http://www.w3.org/2001/XMLSchema",
+	dt: "http://www.w3.org/2001/XMLSchema-datatypes",
+	xsi : "http://www.w3.org/2001/XMLSchema-instance",
+	rdf : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+	rdfs : "http://www.w3.org/2000/01/rdf-schema#",
+	dc : "http://purl.org/dc/elements/1.1/",
+	dcq: "http://purl.org/dc/qualifiers/1.0",
+	"soap-env" : "http://schemas.xmlsoap.org/soap/envelope/",
+	wsdl : "http://schemas.xmlsoap.org/wsdl/",
+	AdobeExtensions : "http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"
+};
+
+dojo.dom.isNode = function(/* object */wh){
+	//	summary:
+	//		checks to see if wh is actually a node.
+	if(typeof Element == "function") {
+		try {
+			return wh instanceof Element;	//	boolean
+		} catch(e) {}
+	} else {
+		// best-guess
+		return wh && !isNaN(wh.nodeType);	//	boolean
+	}
+}
+
+dojo.dom.getUniqueId = function(){
+	//	summary:
+	//		returns a unique string for use with any DOM element
+	var _document = dojo.doc();
+	do {
+		var id = "dj_unique_" + (++arguments.callee._idIncrement);
+	}while(_document.getElementById(id));
+	return id;	//	string
+}
+dojo.dom.getUniqueId._idIncrement = 0;
+
+dojo.dom.firstElement = dojo.dom.getFirstChildElement = function(/* Element */parentNode, /* string? */tagName){
+	//	summary:
+	//		returns the first child element matching tagName
+	var node = parentNode.firstChild;
+	while(node && node.nodeType != dojo.dom.ELEMENT_NODE){
+		node = node.nextSibling;
+	}
+	if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) {
+		node = dojo.dom.nextElement(node, tagName);
+	}
+	return node;	//	Element
+}
+
+dojo.dom.lastElement = dojo.dom.getLastChildElement = function(/* Element */parentNode, /* string? */tagName){
+	//	summary:
+	//		returns the last child element matching tagName
+	var node = parentNode.lastChild;
+	while(node && node.nodeType != dojo.dom.ELEMENT_NODE) {
+		node = node.previousSibling;
+	}
+	if(tagName && node && node.tagName && node.tagName.toLowerCase() != tagName.toLowerCase()) {
+		node = dojo.dom.prevElement(node, tagName);
+	}
+	return node;	//	Element
+}
+
+dojo.dom.nextElement = dojo.dom.getNextSiblingElement = function(/* Node */node, /* string? */tagName){
+	//	summary:
+	//		returns the next sibling element matching tagName
+	if(!node) { return null; }
+	do {
+		node = node.nextSibling;
+	} while(node && node.nodeType != dojo.dom.ELEMENT_NODE);
+
+	if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) {
+		return dojo.dom.nextElement(node, tagName);
+	}
+	return node;	//	Element
+}
+
+dojo.dom.prevElement = dojo.dom.getPreviousSiblingElement = function(/* Node */node, /* string? */tagName){
+	//	summary:
+	//		returns the previous sibling element matching tagName
+	if(!node) { return null; }
+	if(tagName) { tagName = tagName.toLowerCase(); }
+	do {
+		node = node.previousSibling;
+	} while(node && node.nodeType != dojo.dom.ELEMENT_NODE);
+
+	if(node && tagName && tagName.toLowerCase() != node.tagName.toLowerCase()) {
+		return dojo.dom.prevElement(node, tagName);
+	}
+	return node;	//	Element
+}
+
+// TODO: hmph
+/*this.forEachChildTag = function(node, unaryFunc) {
+	var child = this.getFirstChildTag(node);
+	while(child) {
+		if(unaryFunc(child) == "break") { break; }
+		child = this.getNextSiblingTag(child);
+	}
+}*/
+
+dojo.dom.moveChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){
+	//	summary:
+	//		Moves children from srcNode to destNode and returns the count of
+	//		children moved; will trim off text nodes if trim == true
+	var count = 0;
+	if(trim) {
+		while(srcNode.hasChildNodes() &&
+			srcNode.firstChild.nodeType == dojo.dom.TEXT_NODE) {
+			srcNode.removeChild(srcNode.firstChild);
+		}
+		while(srcNode.hasChildNodes() &&
+			srcNode.lastChild.nodeType == dojo.dom.TEXT_NODE) {
+			srcNode.removeChild(srcNode.lastChild);
+		}
+	}
+	while(srcNode.hasChildNodes()){
+		destNode.appendChild(srcNode.firstChild);
+		count++;
+	}
+	return count;	//	number
+}
+
+dojo.dom.copyChildren = function(/*Element*/srcNode, /*Element*/destNode, /*boolean?*/trim){
+	//	summary:
+	//		Copies children from srcNde to destNode and returns the count of
+	//		children copied; will trim off text nodes if trim == true
+	var clonedNode = srcNode.cloneNode(true);
+	return this.moveChildren(clonedNode, destNode, trim);	//	number
+}
+
+dojo.dom.replaceChildren = function(/*Element*/node, /*Node*/newChild){
+	//	summary:
+	//		Removes all children of node and appends newChild. All the existing
+	//		children will be destroyed.
+	// FIXME: what if newChild is an array-like object?
+	var nodes = [];
+	if(dojo.render.html.ie){
+		for(var i=0;i<node.childNodes.length;i++){
+			nodes.push(node.childNodes[i]);
+		}
+	}
+	dojo.dom.removeChildren(node);
+	node.appendChild(newChild);
+	for(var i=0;i<nodes.length;i++){
+		dojo.dom.destroyNode(nodes[i]);
+	}
+}
+
+dojo.dom.removeChildren = function(/*Element*/node){
+	//	summary:
+	//		removes all children from node and returns the count of children removed.
+	//		The children nodes are not destroyed. Be sure to call destroyNode on them
+	//		after they are not used anymore.
+	var count = node.childNodes.length;
+	while(node.hasChildNodes()){ dojo.dom.removeNode(node.firstChild); }
+	return count; // int
+}
+
+dojo.dom.replaceNode = function(/*Element*/node, /*Element*/newNode){
+	//	summary:
+	//		replaces node with newNode and returns a reference to the removed node.
+	//		To prevent IE memory leak, call destroyNode on the returned node when
+	//		it is no longer needed.
+	return node.parentNode.replaceChild(newNode, node); // Node
+}
+
+dojo.dom.destroyNode = function(/*Node*/node){
+	// summary:
+	//		destroy a node (it can not be used any more). For IE, this is the
+	//		right function to call to prevent memory leaks. While for other
+	//		browsers, this is identical to dojo.dom.removeNode
+	if(node.parentNode){
+		node = dojo.dom.removeNode(node);
+	}
+	if(node.nodeType != 3){ // ingore TEXT_NODE
+		if(dojo.evalObjPath("dojo.event.browser.clean", false)){
+			dojo.event.browser.clean(node);
+		}
+		if(dojo.render.html.ie){
+			node.outerHTML=''; //prevent ugly IE mem leak associated with Node.removeChild (ticket #1727)
+		}
+	}
+}
+
+dojo.dom.removeNode = function(/*Node*/node){
+	// summary:
+	//		if node has a parent, removes node from parent and returns a
+	//		reference to the removed child.
+	//		To prevent IE memory leak, call destroyNode on the returned node when
+	//		it is no longer needed.
+	//	node:
+	//		the node to remove from its parent.
+
+	if(node && node.parentNode){
+		// return a ref to the removed child
+		return node.parentNode.removeChild(node); //Node
+	}
+}
+
+dojo.dom.getAncestors = function(/*Node*/node, /*function?*/filterFunction, /*boolean?*/returnFirstHit){
+	//	summary:
+	//		returns all ancestors matching optional filterFunction; will return
+	//		only the first if returnFirstHit
+	var ancestors = [];
+	var isFunction = (filterFunction && (filterFunction instanceof Function || typeof filterFunction == "function"));
+	while(node){
+		if(!isFunction || filterFunction(node)){
+			ancestors.push(node);
+		}
+		if(returnFirstHit && ancestors.length > 0){ 
+			return ancestors[0]; 	//	Node
+		}
+		
+		node = node.parentNode;
+	}
+	if(returnFirstHit){ return null; }
+	return ancestors;	//	array
+}
+
+dojo.dom.getAncestorsByTag = function(/*Node*/node, /*String*/tag, /*boolean?*/returnFirstHit){
+	//	summary:
+	//		returns all ancestors matching tag (as tagName), will only return
+	//		first one if returnFirstHit
+	tag = tag.toLowerCase();
+	return dojo.dom.getAncestors(node, function(el){
+		return ((el.tagName)&&(el.tagName.toLowerCase() == tag));
+	}, returnFirstHit);	//	Node || array
+}
+
+dojo.dom.getFirstAncestorByTag = function(/*Node*/node, /*string*/tag){
+	//	summary:
+	//		Returns first ancestor of node with tag tagName
+	return dojo.dom.getAncestorsByTag(node, tag, true);	//	Node
+}
+
+dojo.dom.isDescendantOf = function(/* Node */node, /* Node */ancestor, /* boolean? */guaranteeDescendant){
+	//	summary
+	//	Returns boolean if node is a descendant of ancestor
+	// guaranteeDescendant allows us to be a "true" isDescendantOf function
+	if(guaranteeDescendant && node) { node = node.parentNode; }
+	while(node) {
+		if(node == ancestor){ 
+			return true; 	//	boolean
+		}
+		node = node.parentNode;
+	}
+	return false;	//	boolean
+}
+
+dojo.dom.innerXML = function(/*Node*/node){
+	//	summary:
+	//		Implementation of MS's innerXML function.
+	if(node.innerXML){
+		return node.innerXML;	//	string
+	}else if (node.xml){
+		return node.xml;		//	string
+	}else if(typeof XMLSerializer != "undefined"){
+		return (new XMLSerializer()).serializeToString(node);	//	string
+	}
+}
+
+dojo.dom.createDocument = function(){
+	//	summary:
+	//		cross-browser implementation of creating an XML document object.
+	var doc = null;
+	var _document = dojo.doc();
+
+	if(!dj_undef("ActiveXObject")){
+		var prefixes = [ "MSXML2", "Microsoft", "MSXML", "MSXML3" ];
+		for(var i = 0; i<prefixes.length; i++){
+			try{
+				doc = new ActiveXObject(prefixes[i]+".XMLDOM");
+			}catch(e){ /* squelch */ };
+
+			if(doc){ break; }
+		}
+	}else if((_document.implementation)&&
+		(_document.implementation.createDocument)){
+		doc = _document.implementation.createDocument("", "", null);
+	}
+	
+	return doc;	//	DOMDocument
+}
+
+dojo.dom.createDocumentFromText = function(/*string*/str, /*string?*/mimetype){
+	//	summary:
+	//		attempts to create a Document object based on optional mime-type,
+	//		using str as the contents of the document
+	if(!mimetype){ mimetype = "text/xml"; }
+	if(!dj_undef("DOMParser")){
+		var parser = new DOMParser();
+		return parser.parseFromString(str, mimetype);	//	DOMDocument
+	}else if(!dj_undef("ActiveXObject")){
+		var domDoc = dojo.dom.createDocument();
+		if(domDoc){
+			domDoc.async = false;
+			domDoc.loadXML(str);
+			return domDoc;	//	DOMDocument
+		}else{
+			dojo.debug("toXml didn't work?");
+		}
+	/*
+	}else if((dojo.render.html.capable)&&(dojo.render.html.safari)){
+		// FIXME: this doesn't appear to work!
+		// from: http://web-graphics.com/mtarchive/001606.php
+		// var xml = '<?xml version="1.0"?>'+str;
+		var mtype = "text/xml";
+		var xml = '<?xml version="1.0"?>'+str;
+		var url = "data:"+mtype+";charset=utf-8,"+encodeURIComponent(xml);
+		var req = new XMLHttpRequest();
+		req.open("GET", url, false);
+		req.overrideMimeType(mtype);
+		req.send(null);
+		return req.responseXML;
+	*/
+	}else{
+		var _document = dojo.doc();
+		if(_document.createElement){
+			// FIXME: this may change all tags to uppercase!
+			var tmp = _document.createElement("xml");
+			tmp.innerHTML = str;
+			if(_document.implementation && _document.implementation.createDocument){
+				var xmlDoc = _document.implementation.createDocument("foo", "", null);
+				for(var i = 0; i < tmp.childNodes.length; i++) {
+					xmlDoc.importNode(tmp.childNodes.item(i), true);
+				}
+				return xmlDoc;	//	DOMDocument
+			}
+			// FIXME: probably not a good idea to have to return an HTML fragment
+			// FIXME: the tmp.doc.firstChild is as tested from IE, so it may not
+			// work that way across the board
+			return ((tmp.document)&&
+				(tmp.document.firstChild ?  tmp.document.firstChild : tmp));	//	DOMDocument
+		}
+	}
+	return null;
+}
+
+dojo.dom.prependChild = function(/*Element*/node, /*Element*/parent){
+	//	summary:
+	//		prepends node to parent's children nodes
+	if(parent.firstChild) {
+		parent.insertBefore(node, parent.firstChild);
+	} else {
+		parent.appendChild(node);
+	}
+	return true;	//	boolean
+}
+
+dojo.dom.insertBefore = function(/*Node*/node, /*Node*/ref, /*boolean?*/force){
+	//	summary:
+	//		Try to insert node before ref
+	if(	(force != true)&&
+		(node === ref || node.nextSibling === ref)){ return false; }
+	var parent = ref.parentNode;
+	parent.insertBefore(node, ref);
+	return true;	//	boolean
+}
+
+dojo.dom.insertAfter = function(/*Node*/node, /*Node*/ref, /*boolean?*/force){
+	//	summary:
+	//		Try to insert node after ref
+	var pn = ref.parentNode;
+	if(ref == pn.lastChild){
+		if((force != true)&&(node === ref)){
+			return false;	//	boolean
+		}
+		pn.appendChild(node);
+	}else{
+		return this.insertBefore(node, ref.nextSibling, force);	//	boolean
+	}
+	return true;	//	boolean
+}
+
+dojo.dom.insertAtPosition = function(/*Node*/node, /*Node*/ref, /*string*/position){
+	//	summary:
+	//		attempt to insert node in relation to ref based on position
+	if((!node)||(!ref)||(!position)){ 
+		return false;	//	boolean 
+	}
+	switch(position.toLowerCase()){
+		case "before":
+			return dojo.dom.insertBefore(node, ref);	//	boolean
+		case "after":
+			return dojo.dom.insertAfter(node, ref);		//	boolean
+		case "first":
+			if(ref.firstChild){
+				return dojo.dom.insertBefore(node, ref.firstChild);	//	boolean
+			}else{
+				ref.appendChild(node);
+				return true;	//	boolean
+			}
+			break;
+		default: // aka: last
+			ref.appendChild(node);
+			return true;	//	boolean
+	}
+}
+
+dojo.dom.insertAtIndex = function(/*Node*/node, /*Element*/containingNode, /*number*/insertionIndex){
+	//	summary:
+	//		insert node into child nodes nodelist of containingNode at
+	//		insertionIndex. insertionIndex should be between 0 and 
+	//		the number of the childNodes in containingNode. insertionIndex
+	//		specifys after how many childNodes in containingNode the node
+	//		shall be inserted. If 0 is given, node will be appended to 
+	//		containingNode.
+	var siblingNodes = containingNode.childNodes;
+
+	// if there aren't any kids yet, just add it to the beginning
+
+	if (!siblingNodes.length || siblingNodes.length == insertionIndex){
+		containingNode.appendChild(node);
+		return true;	//	boolean
+	}
+
+	if(insertionIndex == 0){
+		return dojo.dom.prependChild(node, containingNode);	//	boolean
+	}
+	// otherwise we need to walk the childNodes
+	// and find our spot
+
+	return dojo.dom.insertAfter(node, siblingNodes[insertionIndex-1]);	//	boolean
+}
+	
+dojo.dom.textContent = function(/*Node*/node, /*string*/text){
+	//	summary:
+	//		implementation of the DOM Level 3 attribute; scan node for text
+	if (arguments.length>1) {
+		var _document = dojo.doc();
+		dojo.dom.replaceChildren(node, _document.createTextNode(text));
+		return text;	//	string
+	} else {
+		if(node.textContent != undefined){ //FF 1.5
+			return node.textContent;	//	string
+		}
+		var _result = "";
+		if (node == null) { return _result; }
+		for (var i = 0; i < node.childNodes.length; i++) {
+			switch (node.childNodes[i].nodeType) {
+				case 1: // ELEMENT_NODE
+				case 5: // ENTITY_REFERENCE_NODE
+					_result += dojo.dom.textContent(node.childNodes[i]);
+					break;
+				case 3: // TEXT_NODE
+				case 2: // ATTRIBUTE_NODE
+				case 4: // CDATA_SECTION_NODE
+					_result += node.childNodes[i].nodeValue;
+					break;
+				default:
+					break;
+			}
+		}
+		return _result;	//	string
+	}
+}
+
+dojo.dom.hasParent = function(/*Node*/node){
+	//	summary:
+	//		returns whether or not node is a child of another node.
+	return Boolean(node && node.parentNode && dojo.dom.isNode(node.parentNode));	//	boolean
+}
+
+/**
+ * Examples:
+ *
+ * myFooNode = <foo />
+ * isTag(myFooNode, "foo"); // returns "foo"
+ * isTag(myFooNode, "bar"); // returns ""
+ * isTag(myFooNode, "FOO"); // returns ""
+ * isTag(myFooNode, "hey", "foo", "bar"); // returns "foo"
+**/
+dojo.dom.isTag = function(/* Node */node /* ... */){
+	//	summary:
+	//		determines if node has any of the provided tag names and returns
+	//		the tag name that matches, empty string otherwise.
+	if(node && node.tagName) {
+		for(var i=1; i<arguments.length; i++){
+			if(node.tagName==String(arguments[i])){
+				return String(arguments[i]);	//	string
+			}
+		}
+	}
+	return "";	//	string
+}
+
+dojo.dom.setAttributeNS = function(	/*Element*/elem, /*string*/namespaceURI, 
+									/*string*/attrName, /*string*/attrValue){
+	//	summary:
+	//		implementation of DOM2 setAttributeNS that works cross browser.
+	if(elem == null || ((elem == undefined)&&(typeof elem == "undefined"))){
+		dojo.raise("No element given to dojo.dom.setAttributeNS");
+	}
+	
+	if(!((elem.setAttributeNS == undefined)&&(typeof elem.setAttributeNS == "undefined"))){ // w3c
+		elem.setAttributeNS(namespaceURI, attrName, attrValue);
+	}else{ // IE
+		// get a root XML document
+		var ownerDoc = elem.ownerDocument;
+		var attribute = ownerDoc.createNode(
+			2, // node type
+			attrName,
+			namespaceURI
+		);
+		
+		// set value
+		attribute.nodeValue = attrValue;
+		
+		// attach to element
+		elem.setAttributeNode(attribute);
+	}
+}
+
+dojo.provide("dojo.html.common");
+
+dojo.lang.mixin(dojo.html, dojo.dom);
+
+dojo.html.body = function(){
+	dojo.deprecated("dojo.html.body() moved to dojo.body()", "0.5");
+	return dojo.body();
+}
+
+// FIXME: we are going to assume that we can throw any and every rendering
+// engine into the IE 5.x box model. In Mozilla, we do this w/ CSS.
+// Need to investigate for KHTML and Opera
+
+dojo.html.getEventTarget = function(/* DOMEvent */evt){
+	//	summary
+	//	Returns the target of an event
+	if(!evt) { evt = dojo.global().event || {} };
+	var t = (evt.srcElement ? evt.srcElement : (evt.target ? evt.target : null));
+	while((t)&&(t.nodeType!=1)){ t = t.parentNode; }
+	return t;	//	HTMLElement
+}
+
+dojo.html.getViewport = function(){
+	//	summary
+	//	Returns the dimensions of the viewable area of a browser window
+	var _window = dojo.global();
+	var _document = dojo.doc();
+	var w = 0;
+	var h = 0;
+
+	if(dojo.render.html.mozilla){
+		// mozilla
+		w = _document.documentElement.clientWidth;
+		h = _window.innerHeight;
+	}else if(!dojo.render.html.opera && _window.innerWidth){
+		//in opera9, dojo.body().clientWidth should be used, instead
+		//of window.innerWidth/document.documentElement.clientWidth
+		//so we have to check whether it is opera
+		w = _window.innerWidth;
+		h = _window.innerHeight;
+	} else if (!dojo.render.html.opera && dojo.exists(_document, "documentElement.clientWidth")){
+		// IE6 Strict
+		var w2 = _document.documentElement.clientWidth;
+		// this lets us account for scrollbars
+		if(!w || w2 && w2 < w) {
+			w = w2;
+		}
+		h = _document.documentElement.clientHeight;
+	} else if (dojo.body().clientWidth){
+		// IE, Opera
+		w = dojo.body().clientWidth;
+		h = dojo.body().clientHeight;
+	}
+	return { width: w, height: h };	//	object
+}
+
+dojo.html.getScroll = function(){
+	//	summary
+	//	Returns the scroll position of the document
+	var _window = dojo.global();
+	var _document = dojo.doc();
+	var top = _window.pageYOffset || _document.documentElement.scrollTop || dojo.body().scrollTop || 0;
+	var left = _window.pageXOffset || _document.documentElement.scrollLeft || dojo.body().scrollLeft || 0;
+	return { 
+		top: top, 
+		left: left, 
+		offset:{ x: left, y: top }	//	note the change, NOT an Array with added properties. 
+	};	//	object
+}
+
+dojo.html.getParentByType = function(/* HTMLElement */node, /* string */type) {
+	//	summary
+	//	Returns the first ancestor of node with tagName type.
+	var _document = dojo.doc();
+	var parent = dojo.byId(node);
+	type = type.toLowerCase();
+	while((parent)&&(parent.nodeName.toLowerCase()!=type)){
+		if(parent==(_document["body"]||_document["documentElement"])){

[... 15418 lines stripped ...]