diff --git a/_base/loader.js b/_base/loader.js
index 3e4caa1daf..8d5838ca93 100644
--- a/_base/loader.js
+++ b/_base/loader.js
@@ -395,7 +395,7 @@ define(["./kernel", "../has", "require", "module", "./json", "./lang", "./array"
 			    "define(" + dojo.toJson(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});";
 		},
 
-		loaderVars = require.initSyncLoader({load:dojoRequirePlugin}, checkDojoRequirePlugin, transformToAmd, isXdUrl),
+		loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd, isXdUrl),
 
 		sync =
 			loaderVars.sync,
diff --git a/dojo.js b/dojo.js
index 3eeaf407c9..b79f278cd0 100644
--- a/dojo.js
+++ b/dojo.js
@@ -194,7 +194,8 @@
 	if(has("dojo-combo-api")){
 		req.combo = {add:noop};
 		var	comboPending = 0,
-			combosPending = [];
+			combosPending = [],
+			comboPendingTimer = null;
 	}
 
 	var legacyMode = 0,
@@ -480,8 +481,19 @@
 					if(p=="cacheBust"){
 						cacheBust = config[p] ? (isString(config[p]) ? config[p] : (new Date()).getTime() + "") : "";
 					}
-					if(p=="baseUrl" || p=="combo"){
+					if(p=="baseUrl"){
 						req[p] = config[p];
+						if(p=="combo" && combo.plugins){
+							for(var pluing in combo.plugins){
+							}
+						}
+					}
+					if(has("dojo-combo-api") && p=="combo"){
+						var combo = req[p] = config[p],
+							pluginName;
+						for(pluginName in combo.plugins){
+							mix(mix(getModule(pluginName), combo.plugins[pluginName]), {isCombo:1, executed:"executed", load:1});
+						}
 					}
 					if(has("dojo-sync-loader") && p=="async"){
 						// falsy or "sync" => legacy sync loader
@@ -610,8 +622,10 @@
 			// checkComplete!=0 holds the idle signal; we're not idle if we're injecting dependencies
 			checkCompleteGuard++;
 			forEach(module.deps, injectModule);
-			if(has("dojo-combo-api") && comboPending){
+			if(has("dojo-combo-api") && comboPending && !comboPendingTimer){
+				comboPendingTimer = setTimeout(function() {
 					comboPending = 0;
+					comboPendingTimer = null;
 					req.combo.done(function(mids, url) {
 						var onLoadCallback= function(){
 							// defQ is a vector of module definitions 1-to-1, onto mids
@@ -623,6 +637,7 @@
 						req.injectUrl(url, onLoadCallback, mids);
 						injectingModule = 0;
 					}, req);
+				}, 0);
 			}
 			checkIdle();
 		},
@@ -631,11 +646,8 @@
 			var module, syntheticMid;
 			if(isString(a1)){
 				// signature is (moduleId)
-				module = getModule(a1, referenceModule);
-				if(module.plugin){
-					injectPlugin(module, true);
-				}
-				if(module.executed){
+				module = getModule(a1, referenceModule, true);
+				if(module && module.executed){
 					return module.result;
 				}
 				throw makeError("undefinedModule", a1);
@@ -692,6 +704,9 @@
 		},
 
 		createRequire = function(module){
+			if(!module){
+				return req;
+			}
 			var result = module.require;
 			if(!result){
 				result = function(a1, a2, a3){
@@ -866,24 +881,49 @@
 			return getModuleInfo_(mid, referenceModule, packs, modules, req.baseUrl, packageMapProg, pathsMapProg);
 		},
 
-		getModule = function(mid, referenceModule){
+		resolvePluginResourceId = function(plugin, prid, referenceModule){
+			return plugin.normalize ? plugin.normalize(prid, function(mid){return toAbsMid(mid, referenceModule);}) : toAbsMid(prid, referenceModule);
+		},
+
+		dynamicPluginUidGenerator = 0,
+
+		getModule = function(mid, referenceModule, immediate){
 			// compute and optionally construct (if necessary) the module implied by the mid with respect to referenceModule
 			var match, plugin, prid, result;
 			match = mid.match(/^(.+?)\!(.*)$/);
 			if(match){
-				// name was <plugin-module>!<plugin-resource>
-				plugin = getModule(match[1], referenceModule);
-				plugin.isPlugin = 1;
+				// name was <plugin-module>!<plugin-resource-id>
+				plugin = getModule(match[1], referenceModule, immediate);
+
+				if(has("dojo-sync-loader") && legacyMode == sync && !plugin.executed){
+					injectModule(plugin);
+					checkCompleteGuard++;
+					execModule(plugin);
+					checkIdle();
+					promoteModuleToPlugin(plugin);
+				}
+
+				if(plugin.executed === executed && !plugin.load){
+					// executed the module not knowing it was a plugin
+					promoteModuleToPlugin(plugin);
+				}
+
+				// if the plugin has not been loaded, then can't resolve the prid and  must assume this plugin is dynamic until we find out otherwise
+				if(plugin.load){
+					prid = resolvePluginResourceId(plugin, match[2], referenceModule);
+					mid = (plugin.mid + "!" + (plugin.dynamic ? ++dynamicPluginUidGenerator + "!" : "") + prid);
+				}else{
 					prid = match[2];
-				mid = plugin.mid + "!" + (referenceModule ? referenceModule.mid + "!" : "") + prid;
-				return modules[mid] || (modules[mid] = {plugin:plugin, mid:mid, req:(referenceModule ? createRequire(referenceModule) : req), prid:prid});
+					mid = plugin.mid + "!" + (++dynamicPluginUidGenerator) + "!waitingForPlugin";
+				}
+				result = {plugin:plugin, mid:mid, req:createRequire(referenceModule), prid:prid};
 			}else{
 				result = getModuleInfo(mid, referenceModule);
-				return modules[result.mid] || (modules[result.mid] = result);
 			}
+			return modules[result.mid] || (!immediate && (modules[result.mid] = result));
 		},
 
-		toAbsMid =	req.toAbsMid = function(mid, referenceModule){
+		toAbsMid = req.toAbsMid = function(mid, referenceModule){
 			return getModuleInfo(mid, referenceModule).mid;
 		},
 
@@ -936,27 +976,64 @@
 
 		defOrder = 0,
 
+		promoteModuleToPlugin = function(pluginModule){
+			var plugin = pluginModule.result;
+			pluginModule.dynamic = plugin.dynamic;
+			pluginModule.normalize = plugin.normalize;
+			pluginModule.load = plugin.load;
+			return pluginModule;
+		},
+
+		resolvePluginLoadQ = function(plugin){
+			// plugins is a newly executed module that has a loadQ waiting to run
+
+			// step 1: traverse the loadQ and fixup the mid and prid; remember the map from original mid to new mid
+			// recall the original mid was created before the plugin was on board and therefore it was impossible to
+			// compute the final mid; accordingly, prid may or may not change, but the mid will definitely change
+			var map = {};
+			forEach(plugin.loadQ, function(pseudoPluginResource){
+				// manufacture and insert the real module in modules
+				var pseudoMid = pseudoPluginResource.mid,
+					prid = resolvePluginResourceId(plugin, pseudoPluginResource.prid, pseudoPluginResource.req.module),
+					mid = plugin.dynamic ? pseudoPluginResource.mid.replace(/waitingForPlugin$/, prid) : (plugin.mid + "!" + prid),
+					pluginResource = mix(mix({}, pseudoPluginResource), {mid:mid, prid:prid, injected:0});
+				if(!modules[mid]){
+					// create a new (the real) plugin resource and inject it normally now that the plugin is on board
+					injectPlugin(modules[mid] = pluginResource);
+				} // else this was a duplicate request for the same (plugin, rid) for a nondynamic plugin
+
+				// pluginResource is really just a placeholder with the wrong mid (because we couldn't calculate it until the plugin was on board)
+				// mark is as arrived and delete it from modules; the real module was requested above
+				map[pseudoPluginResource.mid] = modules[mid];
+				setArrived(pseudoPluginResource);
+				delete modules[pseudoPluginResource.mid];
+			});
+			plugin.loadQ = 0;
+
+			// step2: replace all references to any placeholder modules with real modules
+			var substituteModules = function(module){
+				for(var replacement, deps = module.deps || [], i = 0; i<deps.length; i++){
+					replacement = map[deps[i].mid];
+					if(replacement){
+						deps[i] = replacement;
+					}
+				}
+			};
+			for(var p in modules){
+				substituteModules(modules[p]);
+			}
+			forEach(execQ, substituteModules);
+		},
+
 		finishExec = function(module){
 			req.trace("loader-finish-exec", [module.mid]);
 			module.executed = executed;
 			module.defOrder = defOrder++;
 			has("dojo-sync-loader") && forEach(module.provides, function(cb){ cb(); });
 			if(module.loadQ){
-				// this was a plugin module
-				var	q = module.loadQ,
-					load = module.load = module.result.load;
-				while(q.length){
-					if(has("config-dojo-loader-catches")){
-						try{
-							load.apply(null, q.shift());
-						}catch(e){
-							signal(error, makeError("pluginThrew", [module, e]));
-						}
-					}else{
-						load.apply(null, q.shift());
-					}
-				}
-				module.loadQ = 0;
+				// the module was a plugin
+				promoteModuleToPlugin(module);
+				resolvePluginLoadQ(module);
 			}
 			// remove all occurences of this module from the execQ
 			for(i = 0; i < execQ.length;){
@@ -1077,54 +1154,44 @@
 			},
 
 			injectPlugin = function(
-				module,
-				immediate // this is consequent to a require call like require("text!some/text")
+				module
 			){
 				// injects the plugin module given by module; may have to inject the plugin itself
 				var plugin = module.plugin;
 
-				if(has("dojo-sync-loader") && legacyMode==sync && !plugin.executed){
-					injectModule(plugin);
-					execQ.unshift(plugin);
-					checkCompleteGuard++;
-					execModule(plugin);
-					checkIdle();
-				}
-
 				if(plugin.executed === executed && !plugin.load){
 					// executed the module not knowing it was a plugin
-					plugin.load = plugin.result.load;
-				}
-
-				if(module.executed){
-					// let the plugin decide if it wants to use the existing value or provide a new value
-					module.executed = 0;
+					promoteModuleToPlugin(plugin);
 				}
 
-				var onload = function(def){
+				var onLoad = function(def){
 						module.result = def;
 						setArrived(module);
 						finishExec(module);
 						checkComplete();
 					};
-				if(!immediate){
-					// don't go loading the plugin if were just looking for an immediate
-					// make the client properly demand the module
-					if(!plugin.load){
-						plugin.loadQ = [];
-						plugin.load = function(id, require, callback){
-							plugin.loadQ.push([id, require, callback]);
-						};
+
+				setRequested(module);
+				if(plugin.load){
+					plugin.load(module.prid, module.req, onLoad);
+				}else if(plugin.loadQ){
+					plugin.loadQ.push(module);
+				}else{
 					// the unshift instead of push is important: we don't want plugins to execute as
 					// dependencies of some other module because this may cause circles when the plugin
 					// loadQ is run; also, generally, we want plugins to run early since they may load
 					// several other modules and therefore can potentially unblock many modules
 					execQ.unshift(plugin);
 					injectModule(plugin);
+
+					// maybe the module was cached and is now defined...
+					if(plugin.load){
+						plugin.load(module.prid, module.req, onLoad);
+					}else{
+						// nope; queue up the plugin resource to be loaded after the plugin module is loaded
+						plugin.loadQ = [module];
 					}
-					setRequested(module);
 				}
-				plugin.load && plugin.load(module.prid, module.req, onload);
 			},
 
 			// for IE, injecting a module may result in a recursive execution if the module is in the cache
@@ -1164,23 +1231,36 @@
 				//
 				// If in synchronous mode, then get the module synchronously if it's not xdomainLoading.
 
-				if(module.plugin){
-					injectPlugin(module);
-					return;
-				} // else a normal module (not a plugin)
-
 				var mid = module.mid,
 					url = module.url;
 				if(module.executed || module.injected || waiting[mid] || (module.url && waiting[module.url])){
 					return;
 				}
 
-				setRequested(module);
-
-				if(has("dojo-combo-api") && req.combo.add(0, module.mid, module.url, req)){
+				if(has("dojo-combo-api")){
+					var viaCombo = 1;
+					if(module.plugin && module.plugin.isCombo){
+						// a combo plugin; therefore, must be handled by combo service
+						// the prid should have already been converted to a URL (if required by the plugin) during
+						// the normalze process; in any event, there is no way for the loader to know how to
+						// to the conversion; therefore the third argument is zero
+						req.combo.add(module.plugin.mid, module.prid, 0, req);
+					}else if(!module.plugin){
+						viaCombo = req.combo.add(0, module.mid, module.url, req);
+					}
+					if(viaCombo){
+						setRequested(module);
 						comboPending= 1;
 						return;
 					}
+				}
+
+				if(module.plugin){
+					injectPlugin(module);
+					return;
+				} // else a normal module (not a plugin)
+
+				setRequested(module);
 
 				var onLoadCallback = function(){
 					runDefQ(module);
@@ -1293,6 +1373,16 @@
 			defineModule = function(module, deps, def){
 				req.trace("loader-define-module", [module.mid, deps]);
 
+				if(has("dojo-combo-api") && module.plugin && module.plugin.isCombo){
+					// the module is a plugin resource loaded by the combo service
+					// note: check for module.plugin should be enough since normal plugin resources should
+					// not follow this path; module.plugin.isCombo is future-proofing belt and suspenders
+					module.result = def;
+					setArrived(module);
+					finishExec(module);
+					return module;
+				};
+
 				var mid = module.mid;
 				if(module.injected === arrived){
 					signal(error, makeError("multipleDefine", module));
@@ -1530,7 +1620,7 @@
 			defQ.push(args);
 		}else{
 			// IE path: possibly anonymous module and therefore injected; therefore, cannot depend on 1-to-1,
-			// in-order exec of onLoad with script eval (since its IE) and must manually detect here
+			// in-order exec of onLoad with script eval (since it's IE) and must manually detect here
 			targetModule = targetModule || injectingModule;
 			if(!targetModule){
 				for(mid in waiting){
diff --git a/has.js b/has.js
index 62c052df60..64a03a770e 100644
--- a/has.js
+++ b/has.js
@@ -120,28 +120,19 @@ define(["require"], function(require) {
 		return element;
 	};
 
-	has.load = /*===== dojo.has.load= ======*/ function(id, parentRequire, loaded){
+	has.normalize = /*===== dojo.has.normalize= ======*/ function(id, toAbsMid){
 		// summary:
-		//	 Conditional loading of AMD modules based on a has feature test value.
-		//
-		// id: String
-		//	 Gives the has feature name, a module to load when the feature exists, and optionally a module
-		//	 to load when the feature is false. The string had the format `"feature-name!path/to/module!path/to/other/module"`
+		//	 Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
 		//
-		// parentRequire: Function
-		//	 The loader require function with respect to the module that contained the plugin resource in it's
-		//	 dependency list.
-		//
-		// loaded: Function
-		//	 Callback to loader that consumes result of plugin demand.
-
+		// toAbsMid: Function
+		//	 Resolves a relative module id into an absolute module id
 		var
 			tokens = id.match(/[\?:]|[^:\?]*/g), i = 0,
 			get = function(skip){
 				var term = tokens[i++];
 				if(term == ":"){
-					// empty string module name, resolves to undefined
-					return undefined;
+					// empty string module name, resolves to 0
+					return 0;
 				}else{
 					// postfixed with a ? means it is a feature to branch on, the term is the name of the feature
 					if(tokens[i++] == "?"){
@@ -155,10 +146,27 @@ define(["require"], function(require) {
 						}
 					}
 					// a module
-					return term;
+					return term || 0;
 				}
 			};
 		id = get();
+		return id && toAbsMid(id);
+	};
+
+	has.load = /*===== dojo.has.load= ======*/ function(id, parentRequire, loaded){
+		// summary:
+		//	 Conditional loading of AMD modules based on a has feature test value.
+		//
+		// id: String
+		//	 Gives the resolved module id to load.
+		//
+		// parentRequire: Function
+		//	 The loader require function with respect to the module that contained the plugin resource in it's
+		//	 dependency list.
+		//
+		// loaded: Function
+		//	 Callback to loader that consumes result of plugin demand.
+
 		if(id){
 			parentRequire([id], loaded);
 		}else{
diff --git a/i18n.js b/i18n.js
index 15344fffeb..98970d660f 100644
--- a/i18n.js
+++ b/i18n.js
@@ -7,11 +7,6 @@ define(["./_base/kernel", "require", "./has", "./_base/array", "./_base/lang", "
 	//		We choose to include our own plugin to leverage functionality already contained in dojo
 	//		and thereby reduce the size of the plugin compared to various loader implementations. Also, this
 	//		allows foreign AMD loaders to be used without their plugins.
-	//
-	//		CAUTION: this module may return improper results if the AMD loader does not support toAbsMid and client
-	//		code passes relative plugin resource module ids. In that case, you should consider using the i18n! plugin
-	//		that comes with your loader.
-
 	var
 		thisModule= dojo.i18n=
 			// the dojo.i18n module
@@ -84,11 +79,18 @@ define(["./_base/kernel", "require", "./has", "./_base/array", "./_base/lang", "
 			});
 		},
 
-		load= function(id, require, load){
+		normalize = function(id, toAbsMid){
 			// note: id may be relative
+			var match= nlsRe.exec(id),
+				bundlePath= match[1];
+			return /^\./.test(bundlePath) ? toAbsMid(bundlePath) + "/" +  id.substring(bundlePath.length) : id;
+		};
+
+		load = function(id, require, load){
+			// note: id is always absolute
 			var
 				match= nlsRe.exec(id),
-				bundlePath= ((require.toAbsMid && require.toAbsMid(match[1])) || match[1]) + "/",
+				bundlePath= match[1] + "/",
 				bundleName= match[5] || match[4],
 				bundlePathAndName= bundlePath + bundleName,
 				localeSpecified = (match[5] && match[4]),
@@ -166,16 +168,10 @@ define(["./_base/kernel", "require", "./has", "./_base/array", "./_base/lang", "
 				callback.apply(null, results);
 			};
 
-		syncRequire.toAbsMid= function(mid){
-			return require.toAbsMid(mid);
-		};
-
 		thisModule.getLocalization= function(moduleName, bundleName, locale){
-			var
-				result,
-				l10nName= getL10nName(moduleName, bundleName, locale).substring(10),
-				isXd = require.isXdUrl(require.toUrl(l10nName + ".js"));
-			load(l10nName, isXd ? require : syncRequire, function(result_){ result= result_; });
+			var result,
+				l10nName= getL10nName(moduleName, bundleName, locale).substring(10);
+			load(l10nName, (has("dojo-sync-loader") && !require.isXdUrl(require.toUrl(l10nName + ".js")) ? syncRequire : require), function(result_){ result= result_; });
 			return result;
 		};
 
@@ -188,11 +184,12 @@ define(["./_base/kernel", "require", "./has", "./_base/array", "./_base/lang", "
 		};
 	}
 
-	thisModule.load= load;
-
-	thisModule.cache= function(mid, value){
-		cache[mid]= value;
-	};
-
-	return thisModule;
+	return lang.mixin(thisModule, {
+		dynamic:true,
+		normalize:normalize,
+		load:load,
+		cache:function(mid, value){
+			cache[mid] = value;
+		}
+	});
 });
diff --git a/loadInit.js b/loadInit.js
index cef9b92ccf..c25bd56e47 100644
--- a/loadInit.js
+++ b/loadInit.js
@@ -1,3 +1,7 @@
 define(["./_base/loader"], function(loader){
-	return {load:loader.loadInit};
+	return {
+		dynamic:1,
+		normalize:function(id){return id;},
+		load:loader.loadInit
+	};
 });
diff --git a/require.js b/require.js
index f44a3c9933..4b5fca8b89 100644
--- a/require.js
+++ b/require.js
@@ -1,3 +1,7 @@
 define(["./_base/loader"], function(loader){
-	return loader.require;
+	return {
+		dynamic:1,
+		normalize:function(id){return id;},
+		load:loader.require
+	};
 });
diff --git a/text.js b/text.js
index d8abf6ec09..f5deb51964 100644
--- a/text.js
+++ b/text.js
@@ -28,15 +28,6 @@ define(["./_base/kernel", "require", "./has", "./has!host-browser?./_base/xhr"],
 	var
 		theCache= {},
 
-		toAbsMid= has("dojo-loader") ?
-			function(id, require){
-				var result = require.toAbsMid(id + "/x");
-				return result.substring(0, result.length-2);
-			} :
-			function(id, require){
-				return require.toUrl(id);
-			},
-
 		strip= function(text){
 			//Strips <?xml ...?> declarations so that external SVG and XML
 			//documents can be added to a document without worry. Also, if the string
@@ -58,15 +49,29 @@ define(["./_base/kernel", "require", "./has", "./has!host-browser?./_base/xhr"],
 		pending = {},
 
 		result= {
-			load:function(id, require, load){
+			dynamic:
+				// the dojo/text caches it's own resources because of dojo.cache
+				true,
+
+			normalize:function(id, toAbsMid){
 				// id is something like (path may be relative):
 				//
 				//	 "path/to/text.html"
 				//	 "path/to/text.html!strip"
+				var parts= id.split("!"),
+					url= parts[0];
+				return (/^\./.test(url) ? toAbsMid(url) : url) + (parts[1] ? "!" + parts[1] : "");
+			},
+
+			load:function(id, require, load){
+				// id is something like (path is always absolute):
+				//
+				//	 "path/to/text.html"
+				//	 "path/to/text.html!strip"
 				var
 					parts= id.split("!"),
 					stripFlag= parts.length>1,
-					absMid= toAbsMid(parts[0], require),
+					absMid= parts[0],
 					url = require.toUrl(parts[0]),
 					text = notFound,
 					finish = function(text){
@@ -98,52 +103,52 @@ define(["./_base/kernel", "require", "./has", "./has!host-browser?./_base/xhr"],
 			}
 		};
 
-		dojo.cache= function(/*String||Object*/module, /*String*/url, /*String||Object?*/value){
-			//	 * (string string [value]) => (module, url, value)
-			//	 * (object [value])        => (module, value), url defaults to ""
-			//
-			//	 * if module is an object, then it must be convertable to a string
-			//	 * (module, url) module + (url ? ("/" + url) : "") must be a legal argument to require.toUrl
-			//	 * value may be a string or an object; if an object then may have the properties "value" and/or "sanitize"
-			var key;
-			if(typeof module=="string"){
-				if(/\//.test(module)){
-					// module is a version 1.7+ resolved path
-					key = module;
-					value = url;
-				}else{
-					// module is a version 1.6- argument to dojo.moduleUrl
-					key = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : ""));
-				}
-			}else{
-				key = module + "";
+	dojo.cache= function(/*String||Object*/module, /*String*/url, /*String||Object?*/value){
+		//	 * (string string [value]) => (module, url, value)
+		//	 * (object [value])        => (module, value), url defaults to ""
+		//
+		//	 * if module is an object, then it must be convertable to a string
+		//	 * (module, url) module + (url ? ("/" + url) : "") must be a legal argument to require.toUrl
+		//	 * value may be a string or an object; if an object then may have the properties "value" and/or "sanitize"
+		var key;
+		if(typeof module=="string"){
+			if(/\//.test(module)){
+				// module is a version 1.7+ resolved path
+				key = module;
 				value = url;
+			}else{
+				// module is a version 1.6- argument to dojo.moduleUrl
+				key = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : ""));
 			}
-			var
-				val = (value != undefined && typeof value != "string") ? value.value : value,
-				sanitize = value && value.sanitize;
+		}else{
+			key = module + "";
+			value = url;
+		}
+		var
+			val = (value != undefined && typeof value != "string") ? value.value : value,
+			sanitize = value && value.sanitize;
 
-			if(typeof val == "string"){
-				//We have a string, set cache value
-				theCache[key] = val;
-				return sanitize ? strip(val) : val;
-			}else if(val === null){
-				//Remove cached value
-				delete theCache[key];
-				return null;
-			}else{
-				//Allow cache values to be empty strings. If key property does
-				//not exist, fetch it.
-				if(!(key in theCache)){
-					getText(key, true, function(text){
-						theCache[key]= text;
-					});
-				}
-				return sanitize ? strip(theCache[key]) : theCache[key];
+		if(typeof val == "string"){
+			//We have a string, set cache value
+			theCache[key] = val;
+			return sanitize ? strip(val) : val;
+		}else if(val === null){
+			//Remove cached value
+			delete theCache[key];
+			return null;
+		}else{
+			//Allow cache values to be empty strings. If key property does
+			//not exist, fetch it.
+			if(!(key in theCache)){
+				getText(key, true, function(text){
+					theCache[key]= text;
+				});
 			}
-		};
+			return sanitize ? strip(theCache[key]) : theCache[key];
+		}
+	};
 
-		return result;
+	return result;
 
 /*=====
 dojo.cache = function(module, url, value){