text: /******/ (function(modules) { // webpackBootstrap
  /******/ 	// 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] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = 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;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__(1);
  
  
  /***/ }),
  /* 1 */
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__(2)
  
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports, __webpack_require__) {
  
  /*
  	MIT License http://www.opensource.org/licenses/mit-license.php
  	Author Tobias Koppers @sokra
  */
  var fs = __webpack_require__(3);
  var readFile = fs.readFile.bind(fs);
  var loadLoader = __webpack_require__(4);
  
  function utf8BufferToString(buf) {
  	var str = buf.toString("utf-8");
  	if(str.charCodeAt(0) === 0xFEFF) {
  		return str.substr(1);
  	} else {
  		return str;
  	}
  }
  
  function splitQuery(req) {
  	var i = req.indexOf("?");
  	if(i < 0) return [req, ""];
  	return [req.substr(0, i), req.substr(i)];
  }
  
  function dirname(path) {
  	if(path === "/") return "/";
  	var i = path.lastIndexOf("/");
  	var j = path.lastIndexOf("\\");
  	var i2 = path.indexOf("/");
  	var j2 = path.indexOf("\\");
  	var idx = i > j ? i : j;
  	var idx2 = i > j ? i2 : j2;
  	if(idx < 0) return path;
  	if(idx === idx2) return path.substr(0, idx + 1);
  	return path.substr(0, idx);
  }
  
  function createLoaderObject(loader) {
  	var obj = {
  		path: null,
  		query: null,
  		options: null,
  		ident: null,
  		normal: null,
  		pitch: null,
  		raw: null,
  		data: null,
  		pitchExecuted: false,
  		normalExecuted: false
  	};
  	Object.defineProperty(obj, "request", {
  		enumerable: true,
  		get: function() {
  			return obj.path + obj.query;
  		},
  		set: function(value) {
  			if(typeof value === "string") {
  				var splittedRequest = splitQuery(value);
  				obj.path = splittedRequest[0];
  				obj.query = splittedRequest[1];
  				obj.options = undefined;
  				obj.ident = undefined;
  			} else {
  				if(!value.loader)
  					throw new Error("request should be a string or object with loader and object (" + JSON.stringify(value) + ")");
  				obj.path = value.loader;
  				obj.options = value.options;
  				obj.ident = value.ident;
  				if(obj.options === null)
  					obj.query = "";
  				else if(obj.options === undefined)
  					obj.query = "";
  				else if(typeof obj.options === "string")
  					obj.query = "?" + obj.options;
  				else if(obj.ident)
  					obj.query = "??" + obj.ident;
  				else if(typeof obj.options === "object" && obj.options.ident)
  					obj.query = "??" + obj.options.ident;
  				else
  					obj.query = "?" + JSON.stringify(obj.options);
  			}
  		}
  	});
  	obj.request = loader;
  	if(Object.preventExtensions) {
  		Object.preventExtensions(obj);
  	}
  	return obj;
  }
  
  function runSyncOrAsync(fn, context, args, callback) {
  	var isSync = true;
  	var isDone = false;
  	var isError = false; // internal error
  	var reportedError = false;
  	context.async = function async() {
  		if(isDone) {
  			if(reportedError) return; // ignore
  			throw new Error("async(): The callback was already called.");
  		}
  		isSync = false;
  		return innerCallback;
  	};
  	var innerCallback = context.callback = function() {
  		if(isDone) {
  			if(reportedError) return; // ignore
  			throw new Error("callback(): The callback was already called.");
  		}
  		isDone = true;
  		isSync = false;
  		try {
  			callback.apply(null, arguments);
  		} catch(e) {
  			isError = true;
  			throw e;
  		}
  	};
  	try {
  		var result = (function LOADER_EXECUTION() {
  			return fn.apply(context, args);
  		}());
  		if(isSync) {
  			isDone = true;
  			if(result === undefined)
  				return callback();
  			if(result && typeof result === "object" && typeof result.then === "function") {
  				return result.then(function(r) {
  					callback(null, r);
  				}, callback);
  			}
  			return callback(null, result);
  		}
  	} catch(e) {
  		if(isError) throw e;
  		if(isDone) {
  			// loader is already "done", so we cannot use the callback function
  			// for better debugging we print the error on the console
  			if(typeof e === "object" && e.stack) console.error(e.stack);
  			else console.error(e);
  			return;
  		}
  		isDone = true;
  		reportedError = true;
  		callback(e);
  	}
  
  }
  
  function convertArgs(args, raw) {
  	if(!raw && Buffer.isBuffer(args[0]))
  		args[0] = utf8BufferToString(args[0]);
  	else if(raw && typeof args[0] === "string")
  		args[0] = Buffer.from(args[0], "utf-8");
  }
  
  function iteratePitchingLoaders(options, loaderContext, callback) {
  	// abort after last loader
  	if(loaderContext.loaderIndex >= loaderContext.loaders.length)
  		return processResource(options, loaderContext, callback);
  
  	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
  
  	// iterate
  	if(currentLoaderObject.pitchExecuted) {
  		loaderContext.loaderIndex++;
  		return iteratePitchingLoaders(options, loaderContext, callback);
  	}
  
  	// load loader module
  	loadLoader(currentLoaderObject, function(err) {
  		if(err) {
  			loaderContext.cacheable(false);
  			return callback(err);
  		}
  		var fn = currentLoaderObject.pitch;
  		currentLoaderObject.pitchExecuted = true;
  		if(!fn) return iteratePitchingLoaders(options, loaderContext, callback);
  
  		runSyncOrAsync(
  			fn,
  			loaderContext, [loaderContext.remainingRequest, loaderContext.previousRequest, currentLoaderObject.data = {}],
  			function(err) {
  				if(err) return callback(err);
  				var args = Array.prototype.slice.call(arguments, 1);
  				// Determine whether to continue the pitching process based on
  				// argument values (as opposed to argument presence) in order
  				// to support synchronous and asynchronous usages.
  				var hasArg = args.some(function(value) {
  					return value !== undefined;
  				});
  				if(hasArg) {
  					loaderContext.loaderIndex--;
  					iterateNormalLoaders(options, loaderContext, args, callback);
  				} else {
  					iteratePitchingLoaders(options, loaderContext, callback);
  				}
  			}
  		);
  	});
  }
  
  function processResource(options, loaderContext, callback) {
  	// set loader index to last loader
  	loaderContext.loaderIndex = loaderContext.loaders.length - 1;
  
  	var resourcePath = loaderContext.resourcePath;
  	if(resourcePath) {
  		loaderContext.addDependency(resourcePath);
  		options.readResource(resourcePath, function(err, buffer) {
  			if(err) return callback(err);
  			options.resourceBuffer = buffer;
  			iterateNormalLoaders(options, loaderContext, [buffer], callback);
  		});
  	} else {
  		iterateNormalLoaders(options, loaderContext, [null], callback);
  	}
  }
  
  function iterateNormalLoaders(options, loaderContext, args, callback) {
  	if(loaderContext.loaderIndex < 0)
  		return callback(null, args);
  
  	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
  
  	// iterate
  	if(currentLoaderObject.normalExecuted) {
  		loaderContext.loaderIndex--;
  		return iterateNormalLoaders(options, loaderContext, args, callback);
  	}
  
  	var fn = currentLoaderObject.normal;
  	currentLoaderObject.normalExecuted = true;
  	if(!fn) {
  		return iterateNormalLoaders(options, loaderContext, args, callback);
  	}
  
  	convertArgs(args, currentLoaderObject.raw);
  
  	runSyncOrAsync(fn, loaderContext, args, function(err) {
  		if(err) return callback(err);
  
  		var args = Array.prototype.slice.call(arguments, 1);
  		iterateNormalLoaders(options, loaderContext, args, callback);
  	});
  }
  
  exports.getContext = function getContext(resource) {
  	var splitted = splitQuery(resource);
  	return dirname(splitted[0]);
  };
  
  exports.runLoaders = function runLoaders(options, callback) {
  	// read options
  	var resource = options.resource || "";
  	var loaders = options.loaders || [];
  	var loaderContext = options.context || {};
  	var readResource = options.readResource || readFile;
  
  	//
  	var splittedResource = resource && splitQuery(resource);
  	var resourcePath = splittedResource ? splittedResource[0] : undefined;
  	var resourceQuery = splittedResource ? splittedResource[1] : undefined;
  	var contextDirectory = resourcePath ? dirname(resourcePath) : null;
  
  	// execution state
  	var requestCacheable = true;
  	var fileDependencies = [];
  	var contextDependencies = [];
  
  	// prepare loader objects
  	loaders = loaders.map(createLoaderObject);
  
  	loaderContext.context = contextDirectory;
  	loaderContext.loaderIndex = 0;
  	loaderContext.loaders = loaders;
  	loaderContext.resourcePath = resourcePath;
  	loaderContext.resourceQuery = resourceQuery;
  	loaderContext.async = null;
  	loaderContext.callback = null;
  	loaderContext.cacheable = function cacheable(flag) {
  		if(flag === false) {
  			requestCacheable = false;
  		}
  	};
  	loaderContext.dependency = loaderContext.addDependency = function addDependency(file) {
  		fileDependencies.push(file);
  	};
  	loaderContext.addContextDependency = function addContextDependency(context) {
  		contextDependencies.push(context);
  	};
  	loaderContext.getDependencies = function getDependencies() {
  		return fileDependencies.slice();
  	};
  	loaderContext.getContextDependencies = function getContextDependencies() {
  		return contextDependencies.slice();
  	};
  	loaderContext.clearDependencies = function clearDependencies() {
  		fileDependencies.length = 0;
  		contextDependencies.length = 0;
  		requestCacheable = true;
  	};
  	Object.defineProperty(loaderContext, "resource", {
  		enumerable: true,
  		get: function() {
  			if(loaderContext.resourcePath === undefined)
  				return undefined;
  			return loaderContext.resourcePath + loaderContext.resourceQuery;
  		},
  		set: function(value) {
  			var splittedResource = value && splitQuery(value);
  			loaderContext.resourcePath = splittedResource ? splittedResource[0] : undefined;
  			loaderContext.resourceQuery = splittedResource ? splittedResource[1] : undefined;
  		}
  	});
  	Object.defineProperty(loaderContext, "request", {
  		enumerable: true,
  		get: function() {
  			return loaderContext.loaders.map(function(o) {
  				return o.request;
  			}).concat(loaderContext.resource || "").join("!");
  		}
  	});
  	Object.defineProperty(loaderContext, "remainingRequest", {
  		enumerable: true,
  		get: function() {
  			if(loaderContext.loaderIndex >= loaderContext.loaders.length - 1 && !loaderContext.resource)
  				return "";
  			return loaderContext.loaders.slice(loaderContext.loaderIndex + 1).map(function(o) {
  				return o.request;
  			}).concat(loaderContext.resource || "").join("!");
  		}
  	});
  	Object.defineProperty(loaderContext, "currentRequest", {
  		enumerable: true,
  		get: function() {
  			return loaderContext.loaders.slice(loaderContext.loaderIndex).map(function(o) {
  				return o.request;
  			}).concat(loaderContext.resource || "").join("!");
  		}
  	});
  	Object.defineProperty(loaderContext, "previousRequest", {
  		enumerable: true,
  		get: function() {
  			return loaderContext.loaders.slice(0, loaderContext.loaderIndex).map(function(o) {
  				return o.request;
  			}).join("!");
  		}
  	});
  	Object.defineProperty(loaderContext, "query", {
  		enumerable: true,
  		get: function() {
  			var entry = loaderContext.loaders[loaderContext.loaderIndex];
  			return entry.options && typeof entry.options === "object" ? entry.options : entry.query;
  		}
  	});
  	Object.defineProperty(loaderContext, "data", {
  		enumerable: true,
  		get: function() {
  			return loaderContext.loaders[loaderContext.loaderIndex].data;
  		}
  	});
  
  	// finish loader context
  	if(Object.preventExtensions) {
  		Object.preventExtensions(loaderContext);
  	}
  
  	var processOptions = {
  		resourceBuffer: null,
  		readResource: readResource
  	};
  	iteratePitchingLoaders(processOptions, loaderContext, function(err, result) {
  		if(err) {
  			return callback(err, {
  				cacheable: requestCacheable,
  				fileDependencies: fileDependencies,
  				contextDependencies: contextDependencies
  			});
  		}
  		callback(null, {
  			result: result,
  			resourceBuffer: processOptions.resourceBuffer,
  			cacheable: requestCacheable,
  			fileDependencies: fileDependencies,
  			contextDependencies: contextDependencies
  		});
  	});
  };
  
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports) {
  
  module.exports = require("fs");
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var LoaderLoadingError = __webpack_require__(5);
  
  module.exports = function loadLoader(loader, callback) {
  	try {
  		var module = __webpack_require__(6)(loader.path);
  	} catch(e) {
  		// it is possible for node to choke on a require if the FD descriptor
  		// limit has been reached. give it a chance to recover.
  		if(e instanceof Error && e.code === "EMFILE") {
  			var retry = loadLoader.bind(null, loader, callback);
  			if(typeof setImmediate === "function") {
  				// node >= 0.9.0
  				return setImmediate(retry);
  			} else {
  				// node < 0.9.0
  				return process.nextTick(retry);
  			}
  		}
  		return callback(e);
  	}
  	if(typeof module !== "function" && typeof module !== "object") {
  		return callback(new LoaderLoadingError(
  			"Module '" + loader.path + "' is not a loader (export function or es6 module)"
  		));
  	}
  	loader.normal = typeof module === "function" ? module : module.default;
  	loader.pitch = module.pitch;
  	loader.raw = module.raw;
  	if(typeof loader.normal !== "function" && typeof loader.pitch !== "function") {
  		return callback(new LoaderLoadingError(
  			"Module '" + loader.path + "' is not a loader (must have normal or pitch function)"
  		));
  	}
  	callback();
  };
  
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  class LoadingLoaderError extends Error {
  	constructor(message) {
  		super(message);
  		this.name = "LoaderRunnerError";
  		Error.captureStackTrace(this, this.constructor);
  	}
  }
  
  module.exports = LoadingLoaderError;
  
  
  /***/ }),
  /* 6 */
  /***/ (function(module, exports) {
  
  function webpackEmptyContext(req) {
  	var e = new Error("Cannot find module '" + req + "'");
  	e.code = 'MODULE_NOT_FOUND';
  	throw e;
  }
  webpackEmptyContext.keys = function() { return []; };
  webpackEmptyContext.resolve = webpackEmptyContext;
  module.exports = webpackEmptyContext;
  webpackEmptyContext.id = 6;
  
  /***/ })
  /******/ ]);
  