if (!dojo._hasResource["dojo._base.lang"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dojo._base.lang"] = true;
	dojo.provide("dojo._base.lang");

	// Crockford (ish) functions

	dojo.isString = function(/* anything */it) {
		// summary: Return true if it is a String
		return typeof it == "string" || it instanceof String; // Boolean
	}

	dojo.isArray = function(/* anything */it) {
		// summary: Return true if it is an Array
		return it && it instanceof Array || typeof it == "array"; // Boolean
	}

	/*
	 * ===== dojo.isFunction = function(it){ // summary: Return true if it is a
	 * Function // it: anything } =====
	 */

	dojo.isFunction = (function() {
		var _isFunction = function(/* anything */it) {
			return typeof it == "function" || it instanceof Function; // Boolean
		};

		return dojo.isSafari ?
				// only slow this down w/ gratuitious casting in Safari since
				// it's what's b0rken
				function(/* anything */it) {
					if (typeof it == "function" && it == "[object NodeList]") {
						return false;
					}
					return _isFunction(it); // Boolean
				}
				: _isFunction;
	})();

	dojo.isObject = function(/* anything */it) {
		// summary:
		// Returns true if it is a JavaScript object (or an Array, a Function or
		// null)
		return it !== undefined
				&& (it === null || typeof it == "object" || dojo.isArray(it) || dojo
						.isFunction(it)); // Boolean
	}

	dojo.isArrayLike = function(/* anything */it) {
		// summary:
		// similar to dojo.isArray() but more permissive
		// 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
		// dojo.isArrayLike(), but will return false when passed to
		// dojo.isArray().
		// return:
		// If it walks like a duck and quicks like a duck, return true
		var d = dojo;
		return it
				&& it !== undefined
				&&
				// keep out built-in constructors (Number, String, ...) which
				// have length
				// properties
				!d.isString(it) && !d.isFunction(it)
				&& !(it.tagName && it.tagName.toLowerCase() == 'form')
				&& (d.isArray(it) || isFinite(it.length)); // Boolean
	}

	dojo.isAlien = function(/* anything */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 && !dojo.isFunction(it)
				&& /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
	}

	dojo.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._mixin(constructor.prototype, arguments[i]);
		}
		return constructor; // Object
	}

	dojo._hitchArgs = function(scope, method /* ,... */) {
		var pre = dojo._toArray(arguments, 2);
		var named = dojo.isString(method);
		return function() {
			// arrayify arguments
			var args = dojo._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
	}

	dojo.hitch = function(/* Object */scope, /* Function|String */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:
		// The scope to use when method executes. If method is a string,
		// scope is also the object containing method.
		// method:
		// A function to be hitched to scope, or the name of the method in
		// scope to be hitched.
		// example:
		// | dojo.hitch(foo, "bar")();
		// runs foo.bar() in the scope of foo
		// example:
		// | dojo.hitch(foo, myFunction);
		// returns a function that runs myFunction in the scope of foo
		if (arguments.length > 2) {
			return dojo._hitchArgs.apply(dojo, arguments); // Function
		}
		if (!method) {
			method = scope;
			scope = null;
		}
		if (dojo.isString(method)) {
			scope = scope || dojo.global;
			if (!scope[method]) {
				throw (['dojo.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
	}

	/*
	 * ===== dojo.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 implementaton
	 * 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: // The object to delegate to for properties not found
	 * directly on the // return object or in props. // props: // an object
	 * containing properties to assign to the returned object // returns: // an
	 * Object of anonymous type // example: // | var foo = { bar: "baz" }; // |
	 * var thinger = dojo.delegate(foo, { thud: "xyzzy"}); // | thinger.bar ==
	 * "baz"; // delegated to foo // | foo.xyzzy == undefined; // by definition // |
	 * thinger.xyzzy == "xyzzy"; // mixed in from props // | foo.bar = "thonk"; // |
	 * thinger.bar == "thonk"; // still delegated to foo's bar } =====
	 */

	dojo.delegate = dojo._delegate = function(obj, props) {

		// boodman/crockford delegation
		function TMP() {
		};
		TMP.prototype = obj;
		var tmp = new TMP();
		if (props) {
			dojo.mixin(tmp, props);
		}
		return tmp; // Object
	}

	dojo.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 dojo.partial is the functional equivalent of calling:
		// | dojo.hitch(null, funcName, ...);
		var arr = [null];
		return dojo.hitch.apply(dojo, arr.concat(dojo._toArray(arguments))); // Function
	}

	dojo._toArray = function(/* Object */obj, /* Number? */offset, /* Array? */
			startWith) {
		// summary:
		// Converts an array-like object (i.e. arguments, DOMCollection)
		// to an array. Returns a new Array object.
		// obj:
		// the object to "arrayify". We expect the object to have, at a
		// minimum, a length property which corresponds to integer-indexed
		// properties.
		// offset:
		// the location in obj to start iterating from. Defaults to 0. Optional.
		// startWith:
		// 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.
		var arr = startWith || [];
		for (var x = offset || 0; x < obj.length; x++) {
			arr.push(obj[x]);
		}
		return arr; // Array
	}

	dojo.clone = function(/* anything */o) {
		// summary:
		// Clones objects (including DOM nodes) and all children.
		// Warning: do not clone cyclic structures.
		if (!o) {
			return o;
		}
		if (dojo.isArray(o)) {
			var r = [];
			for (var i = 0; i < o.length; ++i) {
				r.push(dojo.clone(o[i]));
			}
			return r; // Array
		}
		if (!dojo.isObject(o)) {
			return o; /* anything */
		}
		if (o.nodeType && o.cloneNode) { // isNode
			return o.cloneNode(true); // Node
		}
		if (o instanceof Date) {
			return new Date(o.getTime()); // Date
		}
		// Generic objects
		var r = new o.constructor(); // specific to dojo.declare()'d classes!
		for (var i in o) {
			if (!(i in r) || r[i] != o[i]) {
				r[i] = dojo.clone(o[i]);
			}
		}
		return r; // Object
	}

	dojo.trim = function(/* String */str) {
		// summary:
		// trims whitespaces from both sides of the 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).
		// The fastest but longest version of this function is located at
		// dojo.string.trim()
		return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); // String
	}

}