first commit

build/node_modules/webpack-core/lib/CachedSource.js

@@ -0,0 +1,58 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+function CachedSource(source) {
+	this._source = source;
+	this._cachedSource = undefined;
+	this._cachedSize = undefined;
+	this._cachedMaps = {};
+}
+module.exports = CachedSource;
+
+CachedSource.prototype.source = function() {
+	if(typeof this._cachedSource !== "undefined") return this._cachedSource;
+	return this._cachedSource = this._source.source();
+};
+
+CachedSource.prototype.size = function() {
+	if(typeof this._cachedSize !== "undefined") return this._cachedSize;
+	if(typeof this._cachedSource !== "undefined")
+		return this._cachedSize = this._cachedSource.length;
+	return this._cachedSize = this._source.size();
+};
+
+CachedSource.prototype.sourceAndMap = function(options) {
+	var key = JSON.stringify(options);
+	if(typeof this._cachedSource !== "undefined" && key in this._cachedMaps)
+		return { source: this._cachedSource, map: this._cachedMaps[key] };
+	else if(typeof this._cachedSource !== "undefined") {
+		return { source: this._cachedSource, map: this._cachedMaps[key] = this._source.map(options) };
+	} else if(key in this._cachedMaps) {
+		return { source: this._cachedSource = this._source.source(), map: this._cachedMaps[key] };
+	}
+	var result = this._source.sourceAndMap(options);
+	this._cachedSource = result.source;
+	this._cachedMaps[key] = result.map;
+	return { source: this._cachedSource, map: this._cachedMaps[key] };
+};
+
+CachedSource.prototype.node = function(options) {
+	return this._source.node(options);
+};
+
+CachedSource.prototype.listMap = function(options) {
+	return this._source.listMap(options);
+}
+
+CachedSource.prototype.map = function(options) {
+	if(!options) options = {};
+	var key = JSON.stringify(options);
+	if(key in this._cachedMaps)
+		return this._cachedMaps[key];
+	return this._cachedMaps[key] = this._source.map();
+};
+
+CachedSource.prototype.updateHash = function(hash) {
+	this._source.updateHash(hash);
+};

build/node_modules/webpack-core/lib/ConcatSource.js

@@ -0,0 +1,62 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var SourceNode = require("source-map").SourceNode;
+var SourceListMap = require("source-list-map").SourceListMap;
+var Source = require("./Source");
+
+function ConcatSource() {
+	Source.call(this);
+	this.children = Array.prototype.slice.call(arguments);
+}
+module.exports = ConcatSource;
+
+ConcatSource.prototype = Object.create(Source.prototype);
+ConcatSource.prototype.constructor = ConcatSource;
+
+ConcatSource.prototype.add = function(item) {
+	this.children.push(item);
+};
+
+ConcatSource.prototype.source = function() {
+	return this.children.map(function(item) {
+		return typeof item === "string" ? item : item.source();
+	}).join("");
+};
+
+ConcatSource.prototype.size = function() {
+	return this.children.map(function(item) {
+		return typeof item === "string" ? item.length : item.size();
+	}).reduce(function(sum, s) { return sum + s; }, 0);
+};
+
+require("./SourceAndMapMixin")(ConcatSource.prototype);
+
+ConcatSource.prototype.node = function(options) {
+	var node = new SourceNode(null, null, null, this.children.map(function(item) {
+		return typeof item === "string" ? item : item.node(options);
+	}));
+	return node;
+};
+
+ConcatSource.prototype.listMap = function(options) {
+	var map = new SourceListMap();
+	this.children.forEach(function(item) {
+		if(typeof item === "string")
+			map.add(item);
+		else
+			map.add(item.listMap(options));
+	});
+	return map;
+};
+
+ConcatSource.prototype.updateHash = function(hash) {
+	this.children.forEach(function(item) {
+		if (typeof item === "string") {
+			hash.update(item)
+		} else {
+			item.updateHash(hash);
+		}
+	});
+};

build/node_modules/webpack-core/lib/LineToLineMappedSource.js

@@ -0,0 +1,49 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var SourceNode = require("source-map").SourceNode;
+var SourceListMap = require("source-list-map").SourceListMap;
+var Source = require("./Source");
+
+function LineToLineMappedSource(value, name, originalSource) {
+	Source.call(this);
+	this._value = value;
+	this._name = name;
+	this._originalSource = originalSource;
+}
+
+module.exports = LineToLineMappedSource;
+
+LineToLineMappedSource.prototype = Object.create(Source.prototype);
+LineToLineMappedSource.prototype.constructor = LineToLineMappedSource;
+
+LineToLineMappedSource.prototype.source = function() {
+	return this._value;
+};
+
+require("./SourceAndMapMixin")(LineToLineMappedSource.prototype);
+
+LineToLineMappedSource.prototype.node = function(options) {
+	var value = this._value;
+	var name = this._name;
+	var lines = value.split("\n");
+	var node = new SourceNode(null, null, null,
+		lines.map(function(line, idx) {
+			return new SourceNode(idx+1, 0, name,
+				(line + (idx != lines.length-1 ? "\n" : ""))
+			);
+		})
+	);
+	node.setSourceContent(name, this._originalSource);
+	return node;
+};
+
+LineToLineMappedSource.prototype.listMap = function(options) {
+	return new SourceListMap(this._value, this._name, this._originalSource)
+};
+
+LineToLineMappedSource.prototype.updateHash = function(hash) {
+	hash.update(this._value);
+	hash.update(this._originalSource);
+};

build/node_modules/webpack-core/lib/LoadersList.js

@@ -0,0 +1,96 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+function LoadersList(list) {
+	this.list = list || [];
+	this.list.forEach(function(element) {
+		if(element === null || typeof element !== "object")
+			throw new Error("Each element of the loaders list must be an object or array");
+	});
+}
+module.exports = LoadersList;
+
+function regExpAsMatcher(regExp) {
+	return function(str) {
+		return regExp.test(str);
+	}
+}
+
+function asMatcher(test) {
+	if(typeof test === "string") {
+		return regExpAsMatcher(new RegExp("^"+test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&")));
+	} else if(typeof test === "function") {
+		return test;
+	} else if(test instanceof RegExp) {
+		return regExpAsMatcher(test);
+	} else if(Array.isArray(test)) {
+		var matchers = test.map(function(item) {
+			if(Array.isArray(item)) {
+				var matchers = item.map(asMatcher);
+				return function(str) {
+					return matchers.every(function(matcher) {
+						return matcher(str);
+					});
+				};
+			} else {
+				return asMatcher(item);
+			}
+		});
+		return function(str) {
+			for(var i = 0; i < test.length; i++) {
+				if(matchers[i](str))
+					return true;
+			}
+			return false;
+		};
+	} else {
+		throw new Error(test + " is not a valid test");
+	}
+}
+
+function getLoadersFromObject(element) {
+	if(element.query) {
+		if(!element.loader || element.loader.indexOf("!") >= 0) throw new Error("Cannot define 'query' and multiple loaders in loaders list");
+		if(typeof element.query === "string") return [element.loader + "?" + element.query];
+		return [element.loader + "?" + JSON.stringify(element.query)];
+	}
+	if(element.loader) return element.loader.split("!");
+	if(element.loaders) return element.loaders;
+	throw new Error("Element from loaders list should have one of the fields 'loader' or 'loaders'");
+}
+
+LoadersList.prototype.matchPart = function matchPart(str, test) {
+	if(!test) return true;
+	var matcher = asMatcher(test);
+	return matcher(str);
+};
+
+LoadersList.prototype.match = function match(str) {
+	return this.list.map(function(element) {
+		if(Array.isArray(element)) {
+			for(var i = 0; i < element.length; i++) {
+				if(this.matchObject(str, element[i]))
+					return getLoadersFromObject(element[i]);
+			}
+		} else {
+			if(this.matchObject(str, element))
+				return getLoadersFromObject(element);
+		}
+	}, this).filter(Boolean).reduce(function(array, r) {
+		r.forEach(function(r) {
+			array.push(r);
+		});
+		return array;
+	}, []) || [];
+};
+
+LoadersList.prototype.matchObject = function matchObject(str, obj) {
+	if(obj.test)
+		if(!this.matchPart(str, obj.test)) return false;
+	if(obj.include)
+		if(!this.matchPart(str, obj.include)) return false;
+	if(obj.exclude)
+		if(this.matchPart(str, obj.exclude)) return false;
+	return true;
+};

build/node_modules/webpack-core/lib/ModuleBuildError.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var loaderFlag = "WEBPACK_CORE_LOADER_EXECUTION";
+function ModuleBuildError(module, err) {
+	Error.call(this);
+	Error.captureStackTrace(this, ModuleBuildError);
+	this.name = "ModuleBuildError";
+	this.message = "Module build failed: ";
+	if(err !== null && typeof err === "object") {
+		if(typeof err.stack === "string" && err.stack) {
+			var stack = err.stack.split("\n");
+			for(var i = 0; i < stack.length; i++)
+				if(stack[i].indexOf(loaderFlag) >= 0)
+					stack.length = i;
+			stack = stack.join("\n");
+			if(!err.hideStack) {
+				this.message += stack;
+			} else {
+				this.details = stack;
+				if(typeof err.message === "string" && err.message) {
+					this.message += err.message;
+				} else {
+					this.message += err;
+				}
+			}
+		} else if(typeof err.message === "string" && err.message) {
+			this.message += err.message;
+		} else {
+			this.message += err;
+		}
+	}
+	this.module = module;
+	this.error = err;
+}
+module.exports = ModuleBuildError;
+
+ModuleBuildError.prototype = Object.create(Error.prototype);

build/node_modules/webpack-core/lib/ModuleError.js

@@ -0,0 +1,15 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+function ModuleError(module, err) {
+	Error.call(this);
+	Error.captureStackTrace(this, ModuleError);
+	this.name = "ModuleError";
+	this.module = module;
+	this.message = err;
+	this.error = err;
+}
+module.exports = ModuleError;
+
+ModuleError.prototype = Object.create(Error.prototype);

build/node_modules/webpack-core/lib/ModuleWarning.js

@@ -0,0 +1,15 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+function ModuleWarning(module, warning) {
+	Error.call(this);
+	Error.captureStackTrace(this, ModuleWarning);
+	this.name = "ModuleWarning";
+	this.module = module;
+	this.message = warning;
+	this.warning = warning;
+}
+module.exports = ModuleWarning;
+
+ModuleWarning.prototype = Object.create(Error.prototype);

build/node_modules/webpack-core/lib/NormalModuleMixin.js

@@ -0,0 +1,319 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var RawSource = require("./RawSource");
+var OriginalSource = require("./OriginalSource");
+var SourceMapSource = require("./SourceMapSource");
+var LineToLineMappedSource = require("./LineToLineMappedSource");
+var path = require("path"); // TODO refactor
+
+var ModuleBuildError = require("./ModuleBuildError");
+var ModuleError = require("./ModuleError");
+var ModuleWarning = require("./ModuleWarning");
+
+function utf8BufferToString(buf) {
+	var str = buf.toString("utf-8");
+	if(str.charCodeAt(0) === 0xFEFF) {
+		return str.substr(1);
+	} else {
+		return str;
+	}
+}
+
+function NormalModuleMixin(loaders, resource) {
+	this.resource = resource;
+	this.loaders = loaders;
+	var resourcePath = this.splitQuery(this.resource)[0];
+	this.context = resourcePath ? path.dirname(resourcePath) : null;
+	this.fileDependencies = [];
+	this.contextDependencies = [];
+	this.warnings = [];
+	this.errors = [];
+	this.error = null;
+	this._source = null;
+}
+module.exports = NormalModuleMixin;
+
+NormalModuleMixin.mixin = function(pt) {
+	for(var name in NormalModuleMixin.prototype)
+		pt[name] = NormalModuleMixin.prototype[name];
+};
+
+NormalModuleMixin.prototype.splitQuery = function splitQuery(req) {
+	var i = req.indexOf("?");
+	if(i < 0) return [req, ""];
+	return [req.substr(0, i), req.substr(i)];
+};
+
+NormalModuleMixin.prototype.doBuild = function doBuild(options, moduleContext, resolver, fs, callback) {
+	var splitQuery = this.splitQuery.bind(this);
+	var module = this;
+	this.cacheable = true;
+
+	// Prepare context
+	var loaders = [];
+	function addLoaderToList(loader) {
+		var l = splitQuery(loader);
+		loaders.push({
+			request: loader,
+			path: l[0],
+			query: l[1],
+			module: null
+		});
+	}
+	this.loaders.forEach(addLoaderToList);
+	var loaderContextCacheable;
+	var loaderContext = {
+		version: 1,
+		context: this.context,
+		loaders: loaders,
+		loaderIndex: 0,
+		resource: this.resource,
+		resourcePath: splitQuery(this.resource)[0],
+		resourceQuery: this.resource ? splitQuery(this.resource)[1] || null : undefined,
+		emitWarning: function(warning) {
+			this.warnings.push(new ModuleWarning(this, warning));
+		}.bind(this),
+		emitError: function(error) {
+			this.errors.push(new ModuleError(this, error));
+		}.bind(this),
+		exec: function(code, filename) {
+			if(typeof __webpack_modules__ === "undefined") {
+				// TODO: check if in enhanced-require
+				var Module = require("module");
+				var m = new Module(filename, module);
+				m.paths = Module._nodeModulePaths(loaderContext.context);
+				m.filename = filename;
+				m._compile(code, filename);
+				return m.exports;
+			} else {
+				throw new Error("loaderContext.exec is not supported");
+			}
+		},
+		resolve: function(context, request, callback) {
+			resolver.resolve(context, request, callback);
+		},
+		resolveSync: function(context, request) {
+			return resolver.resolveSync(context, request);
+		},
+		cacheable: function(flag) {
+			loaderContextCacheable = flag !== false;
+		},
+		dependency: function(file) {
+			this.fileDependencies.push(file);
+		}.bind(this),
+		addDependency: function(file) {
+			this.fileDependencies.push(file);
+		}.bind(this),
+		addContextDependency: function(context) {
+			this.contextDependencies.push(context);
+		}.bind(this),
+		clearDependencies: function() {
+			this.fileDependencies.length = 0;
+			this.contextDependencies.length = 0;
+			module.cacheable = true;
+		}.bind(this),
+		inputValue: undefined,
+		value: null,
+		options: options,
+		debug: options.debug
+	};
+	this.fillLoaderContext(loaderContext, options, moduleContext);
+	if(options.loader) for(var key in options.loader)
+		loaderContext[key] = options.loader[key];
+
+
+	function runSyncOrAsync(fn, context, args, callback) {
+		var isSync = true;
+		var isDone = false;
+		var isError = false; // internal error
+		var reportedError = false;
+		if(!context.async) context.async = function async() {
+			if(isDone) {
+				if(reportedError) return; // ignore
+				throw new Error("async(): The callback was already called.");
+			}
+			isSync = false;
+			return context.callback;
+		};
+		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 WEBPACK_CORE_LOADER_EXECUTION() { return fn.apply(context, args) }());
+			if(isSync) {
+				isDone = true;
+				if(result === undefined)
+					return 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);
+		}
+
+	}
+
+	// Load and pitch loaders
+	(function loadPitch() {
+		var l = loaderContext.loaders[loaderContext.loaderIndex];
+		if(!l) {
+			return onLoadPitchDone.call(this);
+		}
+		if(l.module) {
+			loaderContext.loaderIndex++;
+			return loadPitch.call(this);
+		}
+		if(typeof __webpack_modules__ === "undefined") {
+			if(require.supportQuery) {
+				l.module = require(l.request);
+			} else {
+				try {
+					l.module = require(l.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') {
+						if (typeof setImmediate === 'function') {
+							// node >= 0.9.0
+							return setImmediate(loadPitch.bind(this));
+						} else  {
+							// node < 0.9.0
+							return process.nextTick(loadPitch.bind(this));
+						}
+					}
+					return callback(e)
+				}
+			}
+		} else if(typeof __webpack_require_loader__ === "function") {
+			l.module = __webpack_require_loader__(l.request);
+		} else {
+			return callback(new Error("Cannot load loader, __webpack_require_loader__ not provided."));
+		}
+		if(typeof l.module !== "function")
+			return callback(new Error("Loader " + l.request + " didn't return a function"));
+		var pitchedLoaders = [];
+		var remaining = [];
+		for(var i = 0; i < loaderContext.loaderIndex; i++)
+			pitchedLoaders.push(loaderContext.loaders[i].request);
+		for(i = loaderContext.loaderIndex + 1; i < loaderContext.loaders.length; i++)
+			remaining.push(loaderContext.loaders[i].request);
+		remaining.push(loaderContext.resource);
+		if(typeof l.module.pitch !== "function") return loadPitch.call(this);
+		loaderContextCacheable = false;
+		var privateLoaderContext = Object.create(loaderContext);
+		privateLoaderContext.query = l.query;
+		runSyncOrAsync(l.module.pitch, privateLoaderContext, [remaining.join("!"), pitchedLoaders.join("!"), l.data = {}], function(err) {
+			if(err) return onModuleBuildFailed.call(this, err);
+			if(!loaderContextCacheable) this.cacheable = false;
+			var args = Array.prototype.slice.call(arguments, 1);
+			loaderContext.resourcePath = privateLoaderContext.resourcePath;
+			loaderContext.resourceQuery = privateLoaderContext.resourceQuery;
+			loaderContext.resource = privateLoaderContext.resource;
+			loaderContext.loaderIndex = privateLoaderContext.loaderIndex;
+			if(args.length > 0) {
+				nextLoader.apply(this, [null].concat(args));
+			} else {
+				loadPitch.call(this);
+			}
+		}.bind(this));
+	}.call(this));
+
+	var resourceBuffer;
+	function onLoadPitchDone() {
+		loaderContext.loaderIndex = loaderContext.loaders.length;
+		var request = [];
+		for(var i = 0; i < loaderContext.loaders.length; i++)
+			request.push(loaderContext.loaders[i].request);
+		request.push(loaderContext.resource);
+		loaderContext.request = request.join("!");
+		var resourcePath = loaderContext.resourcePath;
+		loaderContextCacheable = true;
+		if(resourcePath) {
+			loaderContext.addDependency(resourcePath);
+			fs.readFile(resourcePath, function(err, buffer) {
+				if(err) return nextLoader(err);
+				if(module.lineToLine)
+					resourceBuffer = buffer;
+				nextLoader(null, buffer);
+			});
+		} else
+			nextLoader(null, null);
+	}
+
+	function nextLoader(err/*, paramBuffer1, param2, ...*/) {
+		if(!loaderContextCacheable) module.cacheable = false;
+		var args = Array.prototype.slice.call(arguments, 1);
+		if(err) {
+			// a loader emitted an error
+			return onModuleBuildFailed.call(module, err);
+		}
+		if(loaderContext.loaderIndex === 0) {
+			if(Buffer.isBuffer(args[0]))
+				args[0] = utf8BufferToString(args[0]);
+			return onModuleBuild.apply(module, args);
+		}
+		loaderContext.loaderIndex--;
+		var l = loaderContext.loaders[loaderContext.loaderIndex];
+		if(!l.module) return nextLoader.apply(null, [null].concat(args));
+		var privateLoaderContext = Object.create(loaderContext);
+		privateLoaderContext.data = l.data;
+		privateLoaderContext.inputValue = loaderContext.inputValue;
+		privateLoaderContext.query = l.query;
+		if(!l.module.raw && Buffer.isBuffer(args[0])) {
+			args[0] = utf8BufferToString(args[0]);
+		} else if(l.module.raw && typeof args[0] === "string") {
+			args[0] = new Buffer(args[0], "utf-8");
+		}
+		loaderContextCacheable = false;
+		runSyncOrAsync(l.module, privateLoaderContext, args, function() {
+			loaderContext.inputValue = privateLoaderContext.value;
+			nextLoader.apply(null, arguments);
+		});
+	}
+
+
+	function onModuleBuild(source, sourceMap) {
+		if(!Buffer.isBuffer(source) && typeof source !== "string")
+			return onModuleBuildFailed.call(this, new Error("Final loader didn't return a Buffer or String"));
+		if(this.identifier && this.lineToLine && resourceBuffer) {
+			this._source = new LineToLineMappedSource(source, this.identifier(),
+				resourceBuffer.toString("utf-8"));
+		} else if(this.identifier && this.useSourceMap && sourceMap) {
+			this._source = new SourceMapSource(source, this.identifier(), sourceMap);
+		} else if(this.identifier) {
+			this._source = new OriginalSource(source, this.identifier());
+		} else {
+			this._source = new RawSource(source);
+		}
+		return callback();
+	}
+
+	function onModuleBuildFailed(err) {
+		this.error = err;
+		return callback(new ModuleBuildError(this, err));
+	}
+};
+
+NormalModuleMixin.prototype.fillLoaderContext = function fillLoaderContext() {};

build/node_modules/webpack-core/lib/OptionsDefaulter.js

@@ -0,0 +1,70 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+function OptionsDefaulter() {
+	this.defaults = {};
+	this.config = {};
+}
+module.exports = OptionsDefaulter;
+
+function getProperty(obj, name) {
+	name = name.split(".");
+	for(var i = 0; i < name.length - 1; i++) {
+		obj = obj[name[i]];
+		if(typeof obj != "object" || !obj) return;
+	}
+	return obj[name.pop()];
+}
+
+function setProperty(obj, name, value) {
+	name = name.split(".");
+	for(var i = 0; i < name.length - 1; i++) {
+		if(typeof (obj[name[i]]) !== "object" || !obj[name[i]]) obj[name[i]] = {};
+		obj = obj[name[i]];
+	}
+	obj[name.pop()] = value;
+}
+
+function hasProperty(obj, name, value) {
+	name = name.split(".");
+	for(var i = 0; i < name.length - 1; i++) {
+		obj = obj[name[i]];
+		if(typeof obj != "object" || !obj) return false;
+	}
+	return Object.prototype.hasOwnProperty.call(obj, name.pop());
+}
+
+OptionsDefaulter.prototype.process = function(options) {
+	for(var name in this.defaults) {
+		switch(this.config[name]) {
+		case undefined:
+			if(getProperty(options, name) === undefined)
+				setProperty(options, name, this.defaults[name]);
+			break;
+		case "call":
+			setProperty(options, name, this.defaults[name].call(this, getProperty(options, name)), options);
+			break;
+		case "append":
+			var oldValue = getProperty(options, name);
+			if(!Array.isArray(oldValue)) oldValue = [];
+			this.defaults[name].forEach(function(item) {
+				oldValue.push(item);
+			});
+			setProperty(options, name, oldValue);
+			break;
+		default:
+			throw new Error("OptionsDefaulter cannot process " + this.config[name]);
+		}
+	}
+};
+
+OptionsDefaulter.prototype.set = function(name, config, def) {
+	if(arguments.length === 3) {
+		this.defaults[name] = def;
+		this.config[name] = config;
+	} else {
+		this.defaults[name] = config;
+		delete this.config[name];
+	}
+}

build/node_modules/webpack-core/lib/OriginalSource.js

@@ -0,0 +1,87 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var SourceNode = require("source-map").SourceNode;
+var SourceMapConsumer = require("source-map").SourceMapConsumer;
+var SourceListMap = require("source-list-map").SourceListMap;
+var Source = require("./Source");
+
+function isSplitter(c) {
+	switch(c) {
+	case 10: // \n
+	case 13: // \r
+	case 59: // ;
+	case 123: // {
+	case 125: // }
+	return true;
+	}
+	return false;
+}
+function _splitCode(code) {
+	var result = [];
+	var i = 0, j = 0;
+	for(; i < code.length; i++) {
+		if(isSplitter(code.charCodeAt(i))) {
+			while(isSplitter(code.charCodeAt(++i)));
+			result.push(code.substring(j, i));
+			j = i;
+		}
+	}
+	if(j < code.length)
+		result.push(code.substr(j));
+	return result;
+}
+
+function OriginalSource(value, name) {
+	Source.call(this);
+	this._value = value;
+	this._name = name;
+}
+
+module.exports = OriginalSource;
+
+OriginalSource.prototype = Object.create(Source.prototype);
+OriginalSource.prototype.constructor = OriginalSource;
+
+OriginalSource.prototype.source = function() {
+	return this._value;
+};
+
+require("./SourceAndMapMixin")(OriginalSource.prototype);
+
+OriginalSource.prototype.node = function(options) {
+	options = options || {};
+	var sourceMap = this._sourceMap;
+	var value = this._value;
+	var name = this._name;
+	var lines = value.split("\n");
+	var node = new SourceNode(null, null, null,
+		lines.map(function(line, idx) {
+			var pos = 0;
+			if(options.columns === false) {
+				return new SourceNode(idx+1, 0, name,
+					(line + (idx != lines.length-1 ? "\n" : ""))
+				);
+			}
+			return new SourceNode(null, null, null,
+				_splitCode(line + (idx != lines.length-1 ? "\n" : "")).map(function(item) {
+					if(/^\s*$/.test(item)) return item;
+					var res = new SourceNode(idx+1, pos, name, item);
+					pos += item.length;
+					return res;
+				})
+			);
+		})
+	);
+	node.setSourceContent(name, value);
+	return node;
+};
+
+OriginalSource.prototype.listMap = function(options) {
+	return new SourceListMap(this._value, this._name, this._value)
+};
+
+OriginalSource.prototype.updateHash = function(hash) {
+	hash.update(this._value);
+};

build/node_modules/webpack-core/lib/PrefixSource.js

@@ -0,0 +1,73 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var Source = require("./Source");
+var SourceNode = require("source-map").SourceNode;
+
+function PrefixSource(prefix, source) {
+	Source.call(this);
+	this._source = source;
+	this._prefix = prefix;
+}
+module.exports = PrefixSource;
+
+PrefixSource.prototype = Object.create(Source.prototype);
+PrefixSource.prototype.constructor = PrefixSource;
+
+PrefixSource.prototype.source = function() {
+	var node = typeof this._source === "string" ? this._source : this._source.source();
+	var prefix = this._prefix;
+	return prefix + node.replace(/\n(.)/g, "\n" + prefix + "$1");
+};
+
+require("./SourceAndMapMixin")(PrefixSource.prototype);
+
+PrefixSource.prototype.node = function(options) {
+	var node = this._source.node(options);
+	var append = [this._prefix];
+	return new SourceNode(null, null, null, [
+		cloneAndPrefix(node, this._prefix, append)
+	]);
+};
+
+PrefixSource.prototype.listMap = function(options) {
+	var prefix = this._prefix;
+	var map = this._source.listMap(options);
+	map.mapGeneratedCode(function(code) {
+		return prefix + code.replace(/\n(.)/g, "\n" + prefix + "$1");
+	});
+	return map;
+};
+
+PrefixSource.prototype.updateHash = function(hash) {
+	if(typeof this._source === "string")
+		hash.update(this._source);
+	else
+		this._source.updateHash(hash);
+	if(typeof this._prefix === "string")
+		hash.update(this._prefix);
+	else
+		this._prefix.updateHash(hash);
+};
+
+function cloneAndPrefix(node, prefix, append) {
+	if(typeof node === "string") {
+		var result = node.replace(/\n(.)/g, "\n" + prefix + "$1");
+		if(append.length > 0) result = append.pop() + result;
+		if(/\n$/.test(node)) append.push(prefix);
+		return result;
+	} else {
+		var newNode = new SourceNode(
+			node.line,
+			node.column,
+			node.source,
+			node.children.map(function(node) {
+				return cloneAndPrefix(node, prefix, append);
+			}),
+			node.name
+		);
+		newNode.sourceContents = node.sourceContents;
+		return newNode;
+	}
+};

build/node_modules/webpack-core/lib/RawSource.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var Source = require("./Source");
+var SourceNode = require("source-map").SourceNode;
+var SourceListMap = require("source-list-map").SourceListMap;
+
+function RawSource(value) {
+	Source.call(this);
+	this._value = value;
+}
+module.exports = RawSource;
+
+RawSource.prototype = Object.create(Source.prototype);
+RawSource.prototype.constructor = RawSource;
+
+RawSource.prototype.source = function() {
+	return this._value;
+};
+
+RawSource.prototype.map = function(options) {
+	return null;
+};
+
+RawSource.prototype.node = function(options) {
+	return new SourceNode(null, null, null, this._value);
+};
+
+RawSource.prototype.listMap = function(options) {
+	return new SourceListMap(this._value);
+};
+
+RawSource.prototype.updateHash = function(hash) {
+	hash.update(this._value);
+};

build/node_modules/webpack-core/lib/ReplaceSource.js

@@ -0,0 +1,155 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var Source = require("./Source");
+var SourceNode = require("source-map").SourceNode;
+var SourceListMap = require("source-list-map").SourceListMap;
+var fromStringWithSourceMap = require("source-list-map").fromStringWithSourceMap;
+var SourceMapConsumer = require("source-map").SourceMapConsumer;
+
+function ReplaceSource(source, name) {
+	Source.call(this);
+	this._source = source;
+	this._name = name;
+	this.replacements = [];
+}
+module.exports = ReplaceSource;
+
+ReplaceSource.prototype = Object.create(Source.prototype);
+ReplaceSource.prototype.constructor = ReplaceSource;
+
+ReplaceSource.prototype.replace = function(start, end, newValue) {
+	this.replacements.push([start, end, newValue]);
+};
+
+ReplaceSource.prototype.insert = function(pos, newValue) {
+	this.replacements.push([pos, pos-1, newValue]);
+};
+
+ReplaceSource.prototype.source = function(options) {
+	return this._replaceString(this._source.source());
+};
+
+ReplaceSource.prototype._sortReplacements = function() {
+	this.replacements.forEach(function(item, idx) {
+		item[3] = idx;
+	});
+	this.replacements.sort(function(a, b) {
+		var diff = b[1] - a[1];
+		if(diff !== 0)
+			return diff;
+		return b[3] - a[3];
+	});
+
+};
+
+ReplaceSource.prototype._replaceString = function(str) {
+	this._sortReplacements();
+	var result = [str];
+	this.replacements.forEach(function(repl) {
+		var remSource = result.pop();
+		var splitted1 = this._splitString(remSource, Math.floor(repl[1]+1));
+		var splitted2 = this._splitString(splitted1[0], Math.floor(repl[0]));
+		result.push(splitted1[1], repl[2], splitted2[0]);
+	}, this);
+	result = result.reverse();
+	return result.join("");
+};
+
+require("./SourceAndMapMixin")(ReplaceSource.prototype);
+
+ReplaceSource.prototype.node = function(options) {
+	this._sortReplacements();
+	var result = [this._source.node(options)];
+	this.replacements.forEach(function(repl) {
+		var remSource = result.pop();
+		var splitted1 = this._splitSourceNode(remSource, Math.floor(repl[1]+1));
+		if(Array.isArray(splitted1)) {
+			var splitted2 = this._splitSourceNode(splitted1[0], Math.floor(repl[0]));
+			if(Array.isArray(splitted2)) {
+				result.push(splitted1[1], this._replacementToSourceNode(splitted2[1], repl[2]), splitted2[0]);
+			} else {
+				result.push(splitted1[1], this._replacementToSourceNode(splitted1[1], repl[2]), splitted1[0]);
+			}
+		} else {
+			var splitted2 = this._splitSourceNode(remSource, Math.floor(repl[0]));
+			if(Array.isArray(splitted2)) {
+				result.push(this._replacementToSourceNode(splitted2[1], repl[2]), splitted2[0]);
+			} else {
+				result.push(repl[2], remSource);
+			}
+		}
+	}, this);
+	result = result.reverse();
+	return new SourceNode(null, null, null, result);
+};
+
+ReplaceSource.prototype.listMap = function(options) {
+	var map = this._source.listMap(options);
+	if(map.children.length !== 1) {
+		var code = map.toString();
+		code = this._replaceString(code).split("\n");
+		var currentIndex = 0;
+		map.mapGeneratedCode(function(str) {
+			var idx = -1;
+			var count = -1;
+			do {
+				count++;
+				idx = str.indexOf("\n", idx + 1);
+			} while(idx >= 0);
+			if(!count) return "";
+			var result = code.slice(currentIndex, currentIndex + count).join("\n") + "\n";
+			currentIndex += count;
+			return result;
+		});
+		map.add(code.slice(currentIndex).join("\n"));
+	} else {
+		map.mapGeneratedCode(this._replaceString.bind(this));
+	}
+	return map;
+};
+
+ReplaceSource.prototype._replacementToSourceNode = function(oldNode, newString) {
+	var map = oldNode.toStringWithSourceMap({ file: "?" }).map;
+	var original = new SourceMapConsumer(map.toJSON()).originalPositionFor({ line: 1, column: 0 });
+	if(original) {
+		return new SourceNode(original.line, original.column, original.source, newString);
+	} else {
+		return newString;
+	}
+};
+
+ReplaceSource.prototype._splitSourceNode = function(node, position) {
+	if(typeof node === "string") {
+		if(node.length <= position) return position - node.length;
+		return [node.substr(0, position), node.substr(position)];
+	} else {
+		for(var i = 0; i < node.children.length; i++) {
+			position = this._splitSourceNode(node.children[i], position);
+			if(Array.isArray(position)) {
+				var leftNode = new SourceNode(
+					node.line,
+					node.column,
+					node.source,
+					node.children.slice(0, i).concat([position[0]]),
+					node.name
+				);
+				var rightNode = new SourceNode(
+					node.line,
+					node.column,
+					node.source,
+					[position[1]].concat(node.children.slice(i+1)),
+					node.name
+				);
+				leftNode.sourceContents = node.sourceContents;
+				return [leftNode, rightNode];
+			}
+		}
+		return position;
+	}
+};
+
+ReplaceSource.prototype._splitString = function(str, position) {
+	return [str.substr(0, position), str.substr(position)];
+};

build/node_modules/webpack-core/lib/Source.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var SourceNode = require("source-map").SourceNode;
+var SourceMapConsumer = require("source-map").SourceMapConsumer;
+
+function Source() {}
+
+module.exports = Source;
+
+Source.prototype.source = null;
+
+Source.prototype.size = function() {
+	return this.source().length;
+};
+
+Source.prototype.map = function(options) {
+	return null;
+};
+
+Source.prototype.sourceAndMap = function(options) {
+	return {
+		source: this.source(),
+		map: this.map()
+	};
+};
+
+Source.prototype.node = null;
+
+Source.prototype.listNode = null;
+
+Source.prototype.updateHash = function(hash) {
+	var source = this.source();
+	hash.update(source || "");
+};

build/node_modules/webpack-core/lib/SourceAndMapMixin.js

@@ -0,0 +1,28 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+module.exports = function mixinSourceAndMap(proto) {
+	proto.map = function(options) {
+		options = options || {};
+		if(options.columns === false) {
+			return this.listMap(options).toStringWithSourceMap().map;
+		}
+
+		return this.node(options).toStringWithSourceMap({file:"x"}).map.toJSON();
+	};
+
+	proto.sourceAndMap = function(options) {
+		options = options || {};
+		if(options.columns === false) {
+			//console.log(this.listMap(options).debugInfo());
+			return this.listMap(options).toStringWithSourceMap();
+		}
+
+		var res = this.node(options).toStringWithSourceMap({file:"x"});
+		return {
+			source: res.code,
+			map: res.map.toJSON()
+		};
+	};
+}

build/node_modules/webpack-core/lib/SourceMapSource.js

@@ -0,0 +1,54 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var SourceNode = require("source-map").SourceNode;
+var SourceMapConsumer = require("source-map").SourceMapConsumer;
+var SourceMapGenerator = require("source-map").SourceMapGenerator;
+var SourceListMap = require("source-list-map").SourceListMap;
+var fromStringWithSourceMap = require("source-list-map").fromStringWithSourceMap;
+var Source = require("./Source");
+
+function SourceMapSource(value, name, sourceMap, originalSource, innerSourceMap) {
+	Source.call(this);
+	this._value = value;
+	this._name = name;
+	this._sourceMap = sourceMap;
+	this._originalSource = originalSource;
+	this._innerSourceMap = innerSourceMap;
+}
+module.exports = SourceMapSource;
+
+SourceMapSource.prototype = Object.create(Source.prototype);
+SourceMapSource.prototype.constructor = SourceMapSource;
+
+SourceMapSource.prototype.source = function() {
+	return this._value;
+};
+
+require("./SourceAndMapMixin")(SourceMapSource.prototype);
+
+SourceMapSource.prototype.node = function(options) {
+	var innerSourceMap = this._innerSourceMap;
+	var sourceMap = this._sourceMap;
+	if(innerSourceMap) {
+		innerSourceMap = new SourceMapConsumer(innerSourceMap);
+		sourceMap = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(sourceMap));
+		sourceMap.setSourceContent(this._name, this._originalSource);
+		sourceMap.applySourceMap(innerSourceMap, this._name);
+		sourceMap = sourceMap.toJSON();
+	}
+	return SourceNode.fromStringWithSourceMap(this._value, new SourceMapConsumer(sourceMap));
+};
+
+SourceMapSource.prototype.listMap = function(options) {
+	if(options.module === false)
+		return new SourceListMap(this._value, this._name, this._value);
+	return fromStringWithSourceMap(this._value, typeof this._sourceMap === "string" ? JSON.parse(this._sourceMap) : this._sourceMap);
+};
+
+SourceMapSource.prototype.updateHash = function(hash) {
+	hash.update(this._value);
+	if(this._originalSource)
+		hash.update(this._originalSource);
+};

build/node_modules/webpack-core/lib/source-map.js

@@ -0,0 +1,5 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+module.exports = require("source-map");