text: /******/ (function(modules) { // webpackBootstrap
  /******/ 	function hotDownloadUpdateChunk(chunkId) {
  /******/ 				var filename = require("path").join(__dirname, "" + chunkId + "." + hotCurrentHash + ".hot-update.js");
  /******/ 				require("fs").readFile(filename, "utf-8", function(err, content) {
  /******/ 					if(err) {
  /******/ 						if(__webpack_require__.onError)
  /******/ 							return __webpack_require__.onError(err);
  /******/ 						else
  /******/ 							throw err;
  /******/ 					}
  /******/ 					var chunk = {};
  /******/ 					require("vm").runInThisContext("(function(exports) {" + content + "\n})", filename)(chunk);
  /******/ 					hotAddUpdateChunk(chunk.id, chunk.modules);
  /******/ 				});
  /******/ 			}
  /******/ 	
  /******/ 			function hotDownloadManifest(callback) {
  /******/ 				var filename = require("path").join(__dirname, "" + hotCurrentHash + ".hot-update.json");
  /******/ 				require("fs").readFile(filename, "utf-8", function(err, content) {
  /******/ 					if(err) return callback();
  /******/ 					try {
  /******/ 						var update = JSON.parse(content);
  /******/ 					} catch(e) {
  /******/ 						return callback(e);
  /******/ 					}
  /******/ 					callback(null, update);
  /******/ 				});
  /******/ 			}
  /******/ 		
  /******/
  /******/ 	
  /******/ 	
  /******/ 	var hotApplyOnUpdate = true;
  /******/ 	var hotCurrentHash = "38b6c40dfc628807ab68";
  /******/ 	var hotCurrentModuleData = {};
  /******/ 	var hotCurrentParents = [];
  /******/ 	
  /******/ 	function hotCreateRequire(moduleId) {
  /******/ 		var me = installedModules[moduleId];
  /******/ 		if(!me) return __webpack_require__;
  /******/ 		var fn = function(request) {
  /******/ 			if(me.hot.active) {
  /******/ 				if(installedModules[request]) {
  /******/ 					if(installedModules[request].parents.indexOf(moduleId) < 0)
  /******/ 						installedModules[request].parents.push(moduleId);
  /******/ 					if(me.children.indexOf(request) < 0)
  /******/ 						me.children.push(request);
  /******/ 				} else hotCurrentParents = [moduleId];
  /******/ 			} else {
  /******/ 				console.warn("[HMR] unexpected require(" + request + ") from disposed module " + moduleId);
  /******/ 				hotCurrentParents = [];
  /******/ 			}
  /******/ 			return __webpack_require__(request);
  /******/ 		};
  /******/ 		for(var name in __webpack_require__) {
  /******/ 			if(Object.prototype.hasOwnProperty.call(__webpack_require__, name)) {
  /******/ 				fn[name] = __webpack_require__[name];
  /******/ 			}
  /******/ 		}
  /******/ 		fn.e = function(chunkId, callback) {
  /******/ 			if(hotStatus === "ready")
  /******/ 				hotSetStatus("prepare");
  /******/ 			hotChunksLoading++;
  /******/ 			__webpack_require__.e(chunkId, function() {
  /******/ 				try {
  /******/ 					callback.call(null, fn);
  /******/ 				} finally {
  /******/ 					finishChunkLoading();
  /******/ 				}
  /******/ 				function finishChunkLoading() {
  /******/ 					hotChunksLoading--;
  /******/ 					if(hotStatus === "prepare") {
  /******/ 						if(!hotWaitingFilesMap[chunkId]) {
  /******/ 							hotEnsureUpdateChunk(chunkId);
  /******/ 						}
  /******/ 						if(hotChunksLoading === 0 && hotWaitingFiles === 0) {
  /******/ 							hotUpdateDownloaded();
  /******/ 						}
  /******/ 					}
  /******/ 				}
  /******/ 			});
  /******/ 		}
  /******/ 		return fn;
  /******/ 	}
  /******/ 	
  /******/ 	function hotCreateModule(moduleId) {
  /******/ 		var hot = {
  /******/ 			// private stuff
  /******/ 			_acceptedDependencies: {},
  /******/ 			_declinedDependencies: {},
  /******/ 			_selfAccepted: false,
  /******/ 			_selfDeclined: false,
  /******/ 			_disposeHandlers: [],
  /******/ 	
  /******/ 			// Module API
  /******/ 			active: true,
  /******/ 			accept: function(dep, callback) {
  /******/ 				if(typeof dep === "undefined")
  /******/ 					hot._selfAccepted = true;
  /******/ 				else if(typeof dep === "function")
  /******/ 					hot._selfAccepted = dep;
  /******/ 				else if(typeof dep === "number")
  /******/ 					hot._acceptedDependencies[dep] = callback;
  /******/ 				else for(var i = 0; i < dep.length; i++)
  /******/ 					hot._acceptedDependencies[dep[i]] = callback;
  /******/ 			},
  /******/ 			decline: function(dep) {
  /******/ 				if(typeof dep === "undefined")
  /******/ 					hot._selfDeclined = true;
  /******/ 				else if(typeof dep === "number")
  /******/ 					hot._declinedDependencies[dep] = true;
  /******/ 				else for(var i = 0; i < dep.length; i++)
  /******/ 					hot._declinedDependencies[dep[i]] = true;
  /******/ 			},
  /******/ 			dispose: function(callback) {
  /******/ 				hot._disposeHandlers.push(callback);
  /******/ 			},
  /******/ 			addDisposeHandler: function(callback) {
  /******/ 				hot._disposeHandlers.push(callback);
  /******/ 			},
  /******/ 			removeDisposeHandler: function(callback) {
  /******/ 				var idx = hot._disposeHandlers.indexOf(callback);
  /******/ 				if(idx >= 0) hot._disposeHandlers.splice(idx, 1);
  /******/ 			},
  /******/ 	
  /******/ 			// Management API
  /******/ 			check: hotCheck,
  /******/ 			apply: hotApply,
  /******/ 			status: function(l) {
  /******/ 				if(!l) return hotStatus;
  /******/ 				hotStatusHandlers.push(l);
  /******/ 			},
  /******/ 			addStatusHandler: function(l) {
  /******/ 				hotStatusHandlers.push(l);
  /******/ 			},
  /******/ 			removeStatusHandler: function(l) {
  /******/ 				var idx = hotStatusHandlers.indexOf(l);
  /******/ 				if(idx >= 0) hotStatusHandlers.splice(idx, 1);
  /******/ 			},
  /******/ 	
  /******/ 			//inherit from previous dispose call
  /******/ 			data: hotCurrentModuleData[moduleId]
  /******/ 		};
  /******/ 		return hot;
  /******/ 	}
  /******/ 	
  /******/ 	var hotStatusHandlers = [];
  /******/ 	var hotStatus = "idle";
  /******/ 	
  /******/ 	function hotSetStatus(newStatus) {
  /******/ 		var oldStatus = hotStatus;
  /******/ 		hotStatus = newStatus;
  /******/ 		for(var i = 0; i < hotStatusHandlers.length; i++)
  /******/ 			hotStatusHandlers[i].call(null, newStatus);
  /******/ 	}
  /******/ 	
  /******/ 	// while downloading
  /******/ 	var hotWaitingFiles = 0;
  /******/ 	var hotChunksLoading = 0;
  /******/ 	var hotWaitingFilesMap = {};
  /******/ 	var hotRequestedFilesMap = {};
  /******/ 	var hotAvailibleFilesMap = {};
  /******/ 	var hotCallback;
  /******/ 	
  /******/ 	// The update info
  /******/ 	var hotUpdate, hotUpdateNewHash;
  /******/ 	
  /******/ 	function hotCheck(apply, callback) {
  /******/ 		if(hotStatus !== "idle") throw new Error("check() is only allowed in idle status");
  /******/ 		if(typeof apply === "function") {
  /******/ 			hotApplyOnUpdate = false;
  /******/ 			callback = apply;
  /******/ 		} else {
  /******/ 			hotApplyOnUpdate = apply;
  /******/ 			callback = callback || function(err) { if(err) throw err };
  /******/ 		}
  /******/ 		hotSetStatus("check");
  /******/ 		hotDownloadManifest(function(err, update) {
  /******/ 			if(err) return callback(err);
  /******/ 			if(!update) {
  /******/ 				hotSetStatus("idle");
  /******/ 				callback(null, null);
  /******/ 				return;
  /******/ 			}
  /******/ 	
  /******/ 			hotRequestedFilesMap = {};
  /******/ 			hotAvailibleFilesMap = {};
  /******/ 			hotWaitingFilesMap = {};
  /******/ 			for(var i = 0; i < update.c.length; i++)
  /******/ 				hotAvailibleFilesMap[update.c[i]] = true;
  /******/ 			hotUpdateNewHash = update.h;
  /******/ 	
  /******/ 			hotSetStatus("prepare");
  /******/ 			hotCallback = callback;
  /******/ 			hotUpdate = {};
  /******/ 			var chunkId = 0; {
  /******/ 				hotEnsureUpdateChunk(chunkId);
  /******/ 			}
  /******/ 			if(hotChunksLoading === 0 && hotWaitingFiles === 0) {
  /******/ 				hotUpdateDownloaded();
  /******/ 			}
  /******/ 		});
  /******/ 	}
  /******/ 	
  /******/ 	function hotAddUpdateChunk(chunkId, moreModules) {
  /******/ 		if(!hotAvailibleFilesMap[chunkId] || !hotRequestedFilesMap[chunkId])
  /******/ 			return;
  /******/ 		hotRequestedFilesMap[chunkId] = false;
  /******/ 		for(var moduleId in moreModules) {
  /******/ 			if(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {
  /******/ 				hotUpdate[moduleId] = moreModules[moduleId];
  /******/ 			}
  /******/ 		}
  /******/ 		if(--hotWaitingFiles === 0 && hotChunksLoading === 0) {
  /******/ 			hotUpdateDownloaded();
  /******/ 		}
  /******/ 	}
  /******/ 	
  /******/ 	function hotEnsureUpdateChunk(chunkId) {
  /******/ 		if(!hotAvailibleFilesMap[chunkId]) {
  /******/ 			hotWaitingFilesMap[chunkId] = true;
  /******/ 		} else {
  /******/ 			hotRequestedFilesMap[chunkId] = true;
  /******/ 			hotWaitingFiles++;
  /******/ 			hotDownloadUpdateChunk(chunkId);
  /******/ 		}
  /******/ 	}
  /******/ 	
  /******/ 	function hotUpdateDownloaded() {
  /******/ 		hotSetStatus("ready");
  /******/ 		var callback = hotCallback;
  /******/ 		hotCallback = null;
  /******/ 		if(!callback) return;
  /******/ 		if(hotApplyOnUpdate) {
  /******/ 			hotApply(hotApplyOnUpdate, callback);
  /******/ 		} else {
  /******/ 			var outdatedModules = [];
  /******/ 			for(var id in hotUpdate) {
  /******/ 				if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
  /******/ 					outdatedModules.push(+id);
  /******/ 				}
  /******/ 			}
  /******/ 			callback(null, outdatedModules);
  /******/ 		}
  /******/ 	}
  /******/ 	
  /******/ 	function hotApply(options, callback) {
  /******/ 		if(hotStatus !== "ready") throw new Error("apply() is only allowed in ready status");
  /******/ 		if(typeof options === "function") {
  /******/ 			callback = options;
  /******/ 			options = {};
  /******/ 		} else if(options && typeof options === "object") {
  /******/ 			callback = callback || function(err) { if(err) throw err };
  /******/ 		} else {
  /******/ 			options = {};
  /******/ 			callback = callback || function(err) { if(err) throw err };
  /******/ 		}
  /******/ 		
  /******/ 		function getAffectedStuff(module) {
  /******/ 			var outdatedModules = [module];
  /******/ 			var outdatedDependencies = [];
  /******/ 			
  /******/ 			var queue = outdatedModules.slice();
  /******/ 			while(queue.length > 0) {
  /******/ 				var moduleId = queue.pop();
  /******/ 				var module = installedModules[moduleId];
  /******/ 				if(!module || module.hot._selfAccepted)
  /******/ 					continue;
  /******/ 				if(module.hot._selfDeclined) {
  /******/ 					return new Error("Aborted because of self decline: " + moduleId);
  /******/ 				}
  /******/ 				if(moduleId === 0) {
  /******/ 					return;
  /******/ 				}
  /******/ 				for(var i = 0; i < module.parents.length; i++) {
  /******/ 					var parentId = module.parents[i];
  /******/ 					var parent = installedModules[parentId];
  /******/ 					if(parent.hot._declinedDependencies[moduleId]) {
  /******/ 						return new Error("Aborted because of declined dependency: " + moduleId + " in " + parentId);
  /******/ 					}
  /******/ 					if(outdatedModules.indexOf(parentId) >= 0) continue;
  /******/ 					if(parent.hot._acceptedDependencies[moduleId]) {
  /******/ 						if(!outdatedDependencies[parentId])
  /******/ 							outdatedDependencies[parentId] = [];
  /******/ 						addAllToSet(outdatedDependencies[parentId], [moduleId]);
  /******/ 						continue;
  /******/ 					}
  /******/ 					delete outdatedDependencies[parentId];
  /******/ 					outdatedModules.push(parentId);
  /******/ 					queue.push(parentId);
  /******/ 				}
  /******/ 			}
  /******/ 			
  /******/ 			return [outdatedModules, outdatedDependencies];
  /******/ 		}
  /******/ 		function addAllToSet(a, b) {
  /******/ 			for(var i = 0; i < b.length; i++) {
  /******/ 				var item = b[i];
  /******/ 				if(a.indexOf(item) < 0)
  /******/ 					a.push(item);
  /******/ 			}
  /******/ 		}
  /******/ 	
  /******/ 		// at begin all updates modules are outdated
  /******/ 		// the "outdated" status can propagate to parents if they don't accept the children
  /******/ 		var outdatedDependencies = {};
  /******/ 		var outdatedModules = [];
  /******/ 		var appliedUpdate = {};
  /******/ 		for(var id in hotUpdate) {
  /******/ 			if(Object.prototype.hasOwnProperty.call(hotUpdate, id)) {
  /******/ 				var moduleId = +id;
  /******/ 				var result = getAffectedStuff(moduleId);
  /******/ 				if(!result) {
  /******/ 					if(options.ignoreUnaccepted)
  /******/ 						continue;
  /******/ 					hotSetStatus("abort");
  /******/ 					return callback(new Error("Aborted because " + moduleId + " is not accepted"));
  /******/ 				}
  /******/ 				if(result instanceof Error) {
  /******/ 					hotSetStatus("abort");
  /******/ 					return callback(result);
  /******/ 				}
  /******/ 				appliedUpdate[moduleId] = hotUpdate[moduleId];
  /******/ 				addAllToSet(outdatedModules, result[0]);
  /******/ 				for(var moduleId in result[1]) {
  /******/ 					if(Object.prototype.hasOwnProperty.call(result[1], moduleId)) {
  /******/ 						if(!outdatedDependencies[moduleId])
  /******/ 							outdatedDependencies[moduleId] = [];
  /******/ 						addAllToSet(outdatedDependencies[moduleId], result[1][moduleId]);
  /******/ 					}
  /******/ 				}
  /******/ 			}
  /******/ 		}
  /******/ 	
  /******/ 		// Store self accepted outdated modules to require them later by the module system
  /******/ 		var outdatedSelfAcceptedModules = [];
  /******/ 		for(var i = 0; i < outdatedModules.length; i++) {
  /******/ 			var moduleId = outdatedModules[i];
  /******/ 			if(installedModules[moduleId] && installedModules[moduleId].hot._selfAccepted)
  /******/ 				outdatedSelfAcceptedModules.push({
  /******/ 					module: moduleId,
  /******/ 					errorHandler: installedModules[moduleId].hot._selfAccepted
  /******/ 				});
  /******/ 		}
  /******/ 	
  /******/ 		// Now in "dispose" phase
  /******/ 		hotSetStatus("dispose");
  /******/ 		var queue = outdatedModules.slice();
  /******/ 		while(queue.length > 0) {
  /******/ 			var moduleId = queue.pop();
  /******/ 			var module = installedModules[moduleId];
  /******/ 			if(!module) continue;
  /******/ 	
  /******/ 			var data = {};
  /******/ 	
  /******/ 			// Call dispose handlers
  /******/ 			var disposeHandlers = module.hot._disposeHandlers;
  /******/ 			for(var j = 0; j < disposeHandlers.length; j++) {
  /******/ 				var cb = disposeHandlers[j]
  /******/ 				cb(data);
  /******/ 			}
  /******/ 			hotCurrentModuleData[moduleId] = data;
  /******/ 	
  /******/ 			// disable module (this disables requires from this module)
  /******/ 			module.hot.active = false;
  /******/ 	
  /******/ 			// remove module from cache
  /******/ 			delete installedModules[moduleId];
  /******/ 	
  /******/ 			// remove "parents" references from all children
  /******/ 			for(var j = 0; j < module.children.length; j++) {
  /******/ 				var child = installedModules[module.children[j]];
  /******/ 				if(!child) continue;
  /******/ 				var idx = child.parents.indexOf(moduleId);
  /******/ 				if(idx >= 0) {
  /******/ 					child.parents.splice(idx, 1);
  /******/ 					if(child.parents.length === 0 && child.hot && child.hot._disposeHandlers && child.hot._disposeHandlers.length > 0) {
  /******/ 						// Child has dispose handlers and no more references, dispose it too
  /******/ 						queue.push(child.id);
  /******/ 					}
  /******/ 				}
  /******/ 			}
  /******/ 		}
  /******/ 	
  /******/ 		// remove outdated dependency from module children
  /******/ 		for(var moduleId in outdatedDependencies) {
  /******/ 			if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
  /******/ 				var module = installedModules[moduleId];
  /******/ 				var moduleOutdatedDependencies = outdatedDependencies[moduleId];
  /******/ 				for(var j = 0; j < moduleOutdatedDependencies.length; j++) {
  /******/ 					var dependency = moduleOutdatedDependencies[j];
  /******/ 					var idx = module.children.indexOf(dependency);
  /******/ 					if(idx >= 0) module.children.splice(idx, 1);
  /******/ 				}
  /******/ 			}
  /******/ 		}
  /******/ 	
  /******/ 		// Not in "apply" phase
  /******/ 		hotSetStatus("apply");
  /******/ 	
  /******/ 		hotCurrentHash = hotUpdateNewHash;
  /******/ 	
  /******/ 		// insert new code
  /******/ 		for(var moduleId in appliedUpdate) {
  /******/ 			if(Object.prototype.hasOwnProperty.call(appliedUpdate, moduleId)) {
  /******/ 				modules[moduleId] = appliedUpdate[moduleId];
  /******/ 			}
  /******/ 		}
  /******/ 	
  /******/ 		// call accept handlers
  /******/ 		var error = null;
  /******/ 		for(var moduleId in outdatedDependencies) {
  /******/ 			if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
  /******/ 				var module = installedModules[moduleId];
  /******/ 				var moduleOutdatedDependencies = outdatedDependencies[moduleId];
  /******/ 				var callbacks = [];
  /******/ 				for(var i = 0; i < moduleOutdatedDependencies.length; i++) {
  /******/ 					var dependency = moduleOutdatedDependencies[i];
  /******/ 					var cb = module.hot._acceptedDependencies[dependency];
  /******/ 					if(callbacks.indexOf(cb) >= 0) continue;
  /******/ 					callbacks.push(cb);
  /******/ 				}
  /******/ 				for(var i = 0; i < callbacks.length; i++) {
  /******/ 					var cb = callbacks[i];
  /******/ 					try {
  /******/ 						cb(outdatedDependencies);
  /******/ 					} catch(err) {
  /******/ 						if(!error)
  /******/ 							error = err;
  /******/ 					}
  /******/ 				}
  /******/ 			}
  /******/ 		}
  /******/ 	
  /******/ 		// Load self accepted modules
  /******/ 		for(var i = 0; i < outdatedSelfAcceptedModules.length; i++) {
  /******/ 			var item = outdatedSelfAcceptedModules[i];
  /******/ 			var moduleId = item.module;
  /******/ 			hotCurrentParents = [moduleId];
  /******/ 			try {
  /******/ 				__webpack_require__(moduleId);
  /******/ 			} catch(err) {
  /******/ 				if(typeof item.errorHandler === "function") {
  /******/ 					try {
  /******/ 						item.errorHandler(err);
  /******/ 					} catch(err) {
  /******/ 						if(!error)
  /******/ 							error = err;
  /******/ 					}
  /******/ 				} else if(!error)
  /******/ 					error = err;
  /******/ 			}
  /******/ 		}
  /******/ 	
  /******/ 		// handle errors in accept handlers and self accepted module load
  /******/ 		if(error) {
  /******/ 			hotSetStatus("fail");
  /******/ 			return callback(error);
  /******/ 		}
  /******/ 	
  /******/ 		hotSetStatus("idle");
  /******/ 		callback(null, outdatedModules);
  /******/ 	}
  /******/
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  /******/
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false,
  /******/ 			hot: hotCreateModule(moduleId),
  /******/ 			parents: hotCurrentParents,
  /******/ 			children: []
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, hotCreateRequire(moduleId));
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// __webpack_hash__
  /******/ 	__webpack_require__.h = function() { return hotCurrentHash; };
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return hotCreateRequire(0)(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /*!**************************************!*\
    !*** ./loaders/less-loader/index.js ***!
    \**************************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	it("should handle the less loader (piped with raw loader) correctly", function() {
  		__webpack_require__(/*! raw!less!./less/stylesheet.less */ 1).indexOf(".less-rule-direct").should.not.be.eql(-1);
  		__webpack_require__(/*! raw!less!./less/stylesheet.less */ 1).indexOf(".less-rule-import1").should.not.be.eql(-1);
  		__webpack_require__(/*! raw!less!./less/stylesheet.less */ 1).indexOf(".less-rule-import2").should.not.be.eql(-1);
  	});
  
  
  /***/ },
  /* 1 */
  /*!*************************************************************************************************!*\
    !*** (webpack)/~/raw-loader!(webpack)/~/less-loader!./loaders/less-loader/less/stylesheet.less ***!
    \*************************************************************************************************/
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = ".less-rule-import2 {\n  background: lightgreen;\n}\n.less-rule-import1 {\n  background: lightgreen;\n  background-image: url(\"folder/url.js\");\n}\n.less-rule-direct {\n  background: lightgreen;\n}\n"
  
  /***/ }
  /******/ ])