node_modules

11 files changed, 713 insertions, 0 deletions

diff --git a/node_modules/webpack-sources/lib/CachedSource.js b/node_modules/webpack-sources/lib/CachedSource.js
new file mode 100644
index 000000000..50732aebd
--- /dev/null
+++ b/node_modules/webpack-sources/lib/CachedSource.js
@@ -0,0 +1,70 @@
+/*

+	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 = {};

+

+	if(source.node) this.node = function(options) {

+		return this._source.node(options);

+	};

+

+	if(source.listMap) this.listMap = function(options) {

+		return this._source.listMap(options);

+	};

+}

+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.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);

+};

diff --git a/node_modules/webpack-sources/lib/ConcatSource.js b/node_modules/webpack-sources/lib/ConcatSource.js
new file mode 100644
index 000000000..434aa3e5c
--- /dev/null
+++ b/node_modules/webpack-sources/lib/ConcatSource.js
@@ -0,0 +1,63 @@
+/*

+	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);

+	});

+};

diff --git a/node_modules/webpack-sources/lib/LineToLineMappedSource.js b/node_modules/webpack-sources/lib/LineToLineMappedSource.js
new file mode 100644
index 000000000..bca32cd73
--- /dev/null
+++ b/node_modules/webpack-sources/lib/LineToLineMappedSource.js
@@ -0,0 +1,48 @@
+/*

+	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 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);

+};

diff --git a/node_modules/webpack-sources/lib/OriginalSource.js b/node_modules/webpack-sources/lib/OriginalSource.js
new file mode 100644
index 000000000..ac80db8a2
--- /dev/null
+++ b/node_modules/webpack-sources/lib/OriginalSource.js
@@ -0,0 +1,88 @@
+/*

+	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;

+	var 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) {

+				var content = line + (idx != lines.length - 1 ? "\n" : "");

+				return new SourceNode(idx + 1, 0, name, content);

+			}

+			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);

+};

diff --git a/node_modules/webpack-sources/lib/PrefixSource.js b/node_modules/webpack-sources/lib/PrefixSource.js
new file mode 100644
index 000000000..4ea819c45
--- /dev/null
+++ b/node_modules/webpack-sources/lib/PrefixSource.js
@@ -0,0 +1,74 @@
+/*

+	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 REPLACE_REGEX = /\n(?=.|\s)/g

+

+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(REPLACE_REGEX, "\n" + prefix);

+};

+

+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);

+	return map.mapGeneratedCode(function(code) {

+		return prefix + code.replace(REPLACE_REGEX, "\n" + prefix);

+	});

+};

+

+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(REPLACE_REGEX, "\n" + prefix);

+		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;

+	}

+};

diff --git a/node_modules/webpack-sources/lib/RawSource.js b/node_modules/webpack-sources/lib/RawSource.js
new file mode 100644
index 000000000..0b9763938
--- /dev/null
+++ b/node_modules/webpack-sources/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);

+};

diff --git a/node_modules/webpack-sources/lib/ReplaceSource.js b/node_modules/webpack-sources/lib/ReplaceSource.js
new file mode 100644
index 000000000..63087d6de
--- /dev/null
+++ b/node_modules/webpack-sources/lib/ReplaceSource.js
@@ -0,0 +1,192 @@
+/*

+	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) {

+	if(typeof newValue !== "string")

+		throw new Error("insertion must be a string, but is a " + typeof newValue);

+	this.replacements.push([start, end, newValue, this.replacements.length]);

+};

+

+ReplaceSource.prototype.insert = function(pos, newValue) {

+	if(typeof newValue !== "string")

+		throw new Error("insertion must be a string, but is a " + typeof newValue + ": " + newValue);

+	this.replacements.push([pos, pos - 1, newValue, this.replacements.length]);

+};

+

+ReplaceSource.prototype.source = function(options) {

+	return this._replaceString(this._source.source());

+};

+

+ReplaceSource.prototype._sortReplacements = function() {

+	this.replacements.sort(function(a, b) {

+		var diff = b[1] - a[1];

+		if(diff !== 0)

+			return diff;

+		diff = b[0] - a[0];

+		if(diff !== 0)

+			return diff;

+		return b[3] - a[3];

+	});

+};

+

+ReplaceSource.prototype._replaceString = function(str) {

+	if(typeof str !== "string")

+		throw new Error("str must be a string, but is a " + typeof str + ": " + 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));

+		var splitted2;

+		if(Array.isArray(splitted1)) {

+			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 {

+			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) {

+	this._sortReplacements();

+	var map = this._source.listMap(options);

+	var currentIndex = 0;

+	var replacements = this.replacements;

+	var idxReplacement = replacements.length - 1;

+	var removeChars = 0;

+	map = map.mapGeneratedCode(function(str) {

+		var newCurrentIndex = currentIndex + str.length;

+		if(removeChars > str.length) {

+			removeChars -= str.length;

+			str = "";

+		} else {

+			if(removeChars > 0) {

+				str = str.substr(removeChars);

+				currentIndex += removeChars;

+				removeChars = 0;

+			}

+			var finalStr = "";

+			while(idxReplacement >= 0 && replacements[idxReplacement][0] < newCurrentIndex) {

+				var repl = replacements[idxReplacement];

+				var start = Math.floor(repl[0]);

+				var end = Math.floor(repl[1] + 1);

+				var before = str.substr(0, Math.max(0, start - currentIndex));

+				if(end <= newCurrentIndex) {

+					var after = str.substr(Math.max(0, end - currentIndex));

+					finalStr += before + repl[2];

+					str = after;

+					currentIndex = Math.max(currentIndex, end);

+				} else {

+					finalStr += before + repl[2];

+					str = "";

+					removeChars = end - newCurrentIndex;

+				}

+				idxReplacement--;

+			}

+			str = finalStr + str;

+		}

+		currentIndex = newCurrentIndex;

+		return str;

+	});

+	var extraCode = "";

+	while(idxReplacement >= 0) {

+		extraCode += replacements[idxReplacement][2];

+		idxReplacement--;

+	}

+	if(extraCode) {

+		map.add(extraCode);

+	}

+	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 position <= 0 ? ["", node] : [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 position <= 0 ? ["", str] : [str.substr(0, position), str.substr(position)];

+};

diff --git a/node_modules/webpack-sources/lib/Source.js b/node_modules/webpack-sources/lib/Source.js
new file mode 100644
index 000000000..1c729fcf1
--- /dev/null
+++ b/node_modules/webpack-sources/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 || "");

+};

diff --git a/node_modules/webpack-sources/lib/SourceAndMapMixin.js b/node_modules/webpack-sources/lib/SourceAndMapMixin.js
new file mode 100644
index 000000000..e677c6235
--- /dev/null
+++ b/node_modules/webpack-sources/lib/SourceAndMapMixin.js
@@ -0,0 +1,36 @@
+/*

+	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({

+				file: "x"

+			}).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({

+				file: "x"

+			});

+		}

+

+		var res = this.node(options).toStringWithSourceMap({

+			file: "x"

+		});

+		return {

+			source: res.code,

+			map: res.map.toJSON()

+		};

+	};

+}

diff --git a/node_modules/webpack-sources/lib/SourceMapSource.js b/node_modules/webpack-sources/lib/SourceMapSource.js
new file mode 100644
index 000000000..3a7e75a47
--- /dev/null
+++ b/node_modules/webpack-sources/lib/SourceMapSource.js
@@ -0,0 +1,55 @@
+/*

+	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) {

+		sourceMap = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(sourceMap));

+		if(this._originalSource)

+			sourceMap.setSourceContent(this._name, this._originalSource);

+		innerSourceMap = new SourceMapConsumer(innerSourceMap);

+		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);

+};

diff --git a/node_modules/webpack-sources/lib/index.js b/node_modules/webpack-sources/lib/index.js
new file mode 100644
index 000000000..0141d3589
--- /dev/null
+++ b/node_modules/webpack-sources/lib/index.js
@@ -0,0 +1,15 @@
+/*

+	MIT License http://www.opensource.org/licenses/mit-license.php

+	Author Tobias Koppers @sokra

+*/

+exports.Source = require("./Source");

+

+exports.RawSource = require("./RawSource");

+exports.OriginalSource = require("./OriginalSource");

+exports.SourceMapSource = require("./SourceMapSource");

+exports.LineToLineMappedSource = require("./LineToLineMappedSource");

+

+exports.CachedSource = require("./CachedSource");

+exports.ConcatSource = require("./ConcatSource");

+exports.ReplaceSource = require("./ReplaceSource");

+exports.PrefixSource = require("./PrefixSource");