webpack-sources - npm Package Compare versions

Comparing version 0.2.3 to 1.0.0

lib/CachedSource.js

@@ -5,33 +5,56 @@ /*
 */
-function CachedSource(source) {
-	this._source = source;
-	this._cachedSource = undefined;
-	this._cachedSize = undefined;
-	this._cachedMaps = {};
+"use strict";
 
-	if(source.node) this.node = function(options) {
-		return this._source.node(options);
-	};
+const Source = require("./Source");
 
-	if(source.listMap) this.listMap = function(options) {
-		return this._source.listMap(options);
-	};
-}
-module.exports = CachedSource;
+class CachedSource extends Source {
+	constructor(source) {
+		super();
+		this._source = source;
+		this._cachedSource = undefined;
+		this._cachedSize = undefined;
+		this._cachedMaps = {};
 
-CachedSource.prototype.source = function() {
-	if(typeof this._cachedSource !== "undefined") return this._cachedSource;
-	return this._cachedSource = this._source.source();
-};
+		if(source.node) this.node = function(options) {
+			return this._source.node(options);
+		};
 
-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();
-};
+		if(source.listMap) this.listMap = function(options) {
+			return this._source.listMap(options);
+		};
+	}
 
-CachedSource.prototype.sourceAndMap = function(options) {
-	var key = JSON.stringify(options);
-	if(typeof this._cachedSource !== "undefined" && key in this._cachedMaps)
+	source() {
+		if(typeof this._cachedSource !== "undefined") return this._cachedSource;
+		return this._cachedSource = this._source.source();
+	}
+
+	size() {
+		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();
+	}
+
+	sourceAndMap(options) {
+		const 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]
+			};
+		}
+		const result = this._source.sourceAndMap(options);
+		this._cachedSource = result.source;
+		this._cachedMaps[key] = result.map;
 		return {
@@ -41,32 +64,17 @@ source: this._cachedSource,
 		};
-	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();
-};
+	map(options) {
+		if(!options) options = {};
+		const 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);
-};
+	updateHash(hash) {
+		this._source.updateHash(hash);
+	}
+}
+
+module.exports = CachedSource;

lib/ConcatSource.js

@@ -5,60 +5,62 @@ /*
 */
-var SourceNode = require("source-map").SourceNode;
-var SourceListMap = require("source-list-map").SourceListMap;
-var Source = require("./Source");
+"use strict";
 
-function ConcatSource() {
-	Source.call(this);
-	this.children = Array.prototype.slice.call(arguments);
-}
-module.exports = ConcatSource;
+const SourceNode = require("source-map").SourceNode;
+const SourceListMap = require("source-list-map").SourceListMap;
+const Source = require("./Source");
 
-ConcatSource.prototype = Object.create(Source.prototype);
-ConcatSource.prototype.constructor = ConcatSource;
+class ConcatSource extends Source {
+	constructor() {
+		super();
+		this.children = Array.prototype.slice.call(arguments);
+	}
 
-ConcatSource.prototype.add = function(item) {
-	this.children.push(item);
-};
+	add(item) {
+		this.children.push(item);
+	}
 
-ConcatSource.prototype.source = function() {
-	return this.children.map(function(item) {
-		return typeof item === "string" ? item : item.source();
-	}).join("");
-};
+	source() {
+		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);
-};
+	size() {
+		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);
+	node(options) {
+		const node = new SourceNode(null, null, null, this.children.map(function(item) {
+			return typeof item === "string" ? item : item.node(options);
+		}));
+		return node;
+	}
 
-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;
-};
+	listMap(options) {
+		const 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.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;
-};
+	updateHash(hash) {
+		this.children.forEach(function(item) {
+			if(typeof item === "string")
+				hash.update(item);
+			else
+				item.updateHash(hash);
+		});
+	}
+}
 
-ConcatSource.prototype.updateHash = function(hash) {
-	this.children.forEach(function(item) {
-		if(typeof item === "string")
-			hash.update(item);
-		else
-			item.updateHash(hash);
-	});
-};
+require("./SourceAndMapMixin")(ConcatSource.prototype);
+
+module.exports = ConcatSource;

lib/LineToLineMappedSource.js

@@ -5,2 +5,4 @@ /*
 */
+"use strict";
+
 var SourceNode = require("source-map").SourceNode;
@@ -11,40 +13,39 @@ var SourceMapConsumer = require("source-map").SourceMapConsumer;
 
-function LineToLineMappedSource(value, name, originalSource) {
-	Source.call(this);
-	this._value = value;
-	this._name = name;
-	this._originalSource = originalSource;
-}
+class LineToLineMappedSource extends Source {
+	constructor(value, name, originalSource) {
+		Source.call(this);
+		this._value = value;
+		this._name = name;
+		this._originalSource = originalSource;
+	}
 
-module.exports = LineToLineMappedSource;
+	source() {
+		return this._value;
+	}
 
-LineToLineMappedSource.prototype = Object.create(Source.prototype);
-LineToLineMappedSource.prototype.constructor = LineToLineMappedSource;
+	node(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.source = function() {
-	return this._value;
-};
+	listMap(options) {
+		return new SourceListMap(this._value, this._name, this._originalSource)
+	}
 
+	updateHash(hash) {
+		hash.update(this._value);
+		hash.update(this._originalSource);
+	}
+}
+
 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);
-};
+module.exports = LineToLineMappedSource;

lib/OriginalSource.js

@@ -5,2 +5,4 @@ /*
 */
+"use strict";
+
 var SourceNode = require("source-map").SourceNode;
@@ -39,52 +41,51 @@ var SourceMapConsumer = require("source-map").SourceMapConsumer;
 
-function OriginalSource(value, name) {
-	Source.call(this);
-	this._value = value;
-	this._name = name;
-}
+class OriginalSource extends Source {
+	constructor(value, name) {
+		super();
+		this._value = value;
+		this._name = name;
+	}
 
-module.exports = OriginalSource;
+	source() {
+		return this._value;
+	}
 
-OriginalSource.prototype = Object.create(Source.prototype);
-OriginalSource.prototype.constructor = OriginalSource;
+	node(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.source = function() {
-	return this._value;
-};
+	listMap(options) {
+		return new SourceListMap(this._value, this._name, this._value)
+	}
 
+	updateHash(hash) {
+		hash.update(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);
-};
+module.exports = OriginalSource;

lib/PrefixSource.js

@@ -5,52 +5,9 @@ /*
 */
+"use strict";
+
 var Source = require("./Source");
 var SourceNode = require("source-map").SourceNode;
 
-var REPLACE_REGEX = /\n(?=.|\s)/g
+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) {
@@ -76,1 +33,46 @@ if(typeof node === "string") {
 };
+
+class PrefixSource extends Source {
+	constructor(prefix, source) {
+		super();
+		this._source = source;
+		this._prefix = prefix;
+	}
+
+	source() {
+		var node = typeof this._source === "string" ? this._source : this._source.source();
+		var prefix = this._prefix;
+		return prefix + node.replace(REPLACE_REGEX, "\n" + prefix);
+	}
+
+	node(options) {
+		var node = this._source.node(options);
+		var append = [this._prefix];
+		return new SourceNode(null, null, null, [
+			cloneAndPrefix(node, this._prefix, append)
+		]);
+	}
+
+	listMap(options) {
+		var prefix = this._prefix;
+		var map = this._source.listMap(options);
+		return map.mapGeneratedCode(function(code) {
+			return prefix + code.replace(REPLACE_REGEX, "\n" + prefix);
+		});
+	}
+
+	updateHash(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);
+	}
+}
+
+require("./SourceAndMapMixin")(PrefixSource.prototype);
+
+module.exports = PrefixSource;

lib/RawSource.js

@@ -5,2 +5,4 @@ /*
 */
+"use strict";
+
 var Source = require("./Source");
@@ -10,29 +12,29 @@ var SourceNode = require("source-map").SourceNode;
 
-function RawSource(value) {
-	Source.call(this);
-	this._value = value;
-}
-module.exports = RawSource;
+class RawSource extends Source {
+	constructor(value) {
+		super();
+		this._value = value;
+	}
 
-RawSource.prototype = Object.create(Source.prototype);
-RawSource.prototype.constructor = RawSource;
+	source() {
+		return this._value;
+	}
 
-RawSource.prototype.source = function() {
-	return this._value;
-};
+	map(options) {
+		return null;
+	}
 
-RawSource.prototype.map = function(options) {
-	return null;
-};
+	node(options) {
+		return new SourceNode(null, null, null, this._value);
+	}
 
-RawSource.prototype.node = function(options) {
-	return new SourceNode(null, null, null, this._value);
-};
+	listMap(options) {
+		return new SourceListMap(this._value);
+	}
 
-RawSource.prototype.listMap = function(options) {
-	return new SourceListMap(this._value);
-};
+	updateHash(hash) {
+		hash.update(this._value);
+	}
+}
 
-RawSource.prototype.updateHash = function(hash) {
-	hash.update(this._value);
-};
+module.exports = RawSource;

lib/ReplaceSource.js

@@ -5,2 +5,4 @@ /*
 */
+"use strict";
+
 var Source = require("./Source");
@@ -12,183 +14,187 @@ var SourceNode = require("source-map").SourceNode;
 
-function ReplaceSource(source, name) {
-	Source.call(this);
-	this._source = source;
-	this._name = name;
-	this.replacements = [];
-}
-module.exports = ReplaceSource;
+class ReplaceSource extends Source {
+	constructor(source, name) {
+		super();
+		this._source = source;
+		this._name = name;
+		this.replacements = [];
+	}
 
-ReplaceSource.prototype = Object.create(Source.prototype);
-ReplaceSource.prototype.constructor = ReplaceSource;
+	replace(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.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]);
-};
+	insert(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.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]);
-};
+	source(options) {
+		return this._replaceString(this._source.source());
+	}
 
-ReplaceSource.prototype.source = function(options) {
-	return this._replaceString(this._source.source());
-};
+	original() {
+		return this._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];
-	});
-};
+	_sortReplacements() {
+		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("");
-};
+	_replaceString(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]);
+	node(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 {
-				result.push(splitted1[1], this._replacementToSourceNode(splitted1[1], repl[2]), splitted1[0]);
+				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);
+				}
 			}
-		} else {
-			splitted2 = this._splitSourceNode(remSource, Math.floor(repl[0]));
-			if(Array.isArray(splitted2)) {
-				result.push(this._replacementToSourceNode(splitted2[1], repl[2]), splitted2[0]);
+		}, this);
+		result = result.reverse();
+		return new SourceNode(null, null, null, result);
+	}
+
+	listMap(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 {
-				result.push(repl[2], remSource);
+				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--;
 		}
-	}, this);
-	result = result.reverse();
-	return new SourceNode(null, null, null, result);
-};
+		if(extraCode) {
+			map.add(extraCode);
+		}
+		return map;
+	}
 
-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 = "";
+	_replacementToSourceNode(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 {
-			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;
+			return newString;
+		}
+	}
+
+	_splitSourceNode(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];
 				}
-				idxReplacement--;
 			}
-			str = finalStr + str;
+			return position;
 		}
-		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;
+	_splitString(str, position) {
+		return position <= 0 ? ["", str] : [str.substr(0, position), str.substr(position)];
 	}
-};
+}
 
-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;
-	}
-};
+require("./SourceAndMapMixin")(ReplaceSource.prototype);
 
-ReplaceSource.prototype._splitString = function(str, position) {
-	return position <= 0 ? ["", str] : [str.substr(0, position), str.substr(position)];
-};
+module.exports = ReplaceSource;

lib/Source.js

@@ -5,33 +5,42 @@ /*
 */
+"use strict";
+
 var SourceNode = require("source-map").SourceNode;
 var SourceMapConsumer = require("source-map").SourceMapConsumer;
 
-function Source() {}
+class Source {
 
-module.exports = Source;
+	source() {
+		throw new Error("Abstract");
+	}
 
-Source.prototype.source = null;
+	size() {
+		return this.source().length;
+	}
 
-Source.prototype.size = function() {
-	return this.source().length;
-};
+	map(options) {
+		return null;
+	}
 
-Source.prototype.map = function(options) {
-	return null;
-};
+	sourceAndMap(options) {
+		return {
+			source: this.source(),
+			map: this.map()
+		};
+	}
 
-Source.prototype.sourceAndMap = function(options) {
-	return {
-		source: this.source(),
-		map: this.map()
-	};
-};
+	node() {
+		throw new Error("Abstract");
+	}
 
-Source.prototype.node = null;
+	listNode() {
+		throw new Error("Abstract");
+	}
 
-Source.prototype.listNode = null;
+	updateHash(hash) {
+		var source = this.source();
+		hash.update(source || "");
+	}
+}
 
-Source.prototype.updateHash = function(hash) {
-	var source = this.source();
-	hash.update(source || "");
-};
+module.exports = Source;

lib/SourceAndMapMixin.js

@@ -5,2 +5,4 @@ /*
 */
+"use strict";
+
 module.exports = function mixinSourceAndMap(proto) {
@@ -7,0 +9,0 @@ proto.map = function(options) {

lib/SourceMapSource.js

@@ -5,2 +5,4 @@ /*
 */
+"use strict";
+
 var SourceNode = require("source-map").SourceNode;
@@ -13,45 +15,46 @@ var SourceMapConsumer = require("source-map").SourceMapConsumer;
 
-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;
+class SourceMapSource extends Source {
+	constructor(value, name, sourceMap, originalSource, innerSourceMap) {
+		super();
+		this._value = value;
+		this._name = name;
+		this._sourceMap = sourceMap;
+		this._originalSource = originalSource;
+		this._innerSourceMap = innerSourceMap;
+	}
 
-SourceMapSource.prototype = Object.create(Source.prototype);
-SourceMapSource.prototype.constructor = SourceMapSource;
+	source() {
+		return this._value;
+	}
 
-SourceMapSource.prototype.source = function() {
-	return this._value;
-};
+	node(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));
+	}
 
-require("./SourceAndMapMixin")(SourceMapSource.prototype);
+	listMap(options) {
+		options = 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.node = function(options) {
-	var innerSourceMap = this._innerSourceMap;
-	var sourceMap = this._sourceMap;
-	if(innerSourceMap) {
-		sourceMap = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(sourceMap));
+	updateHash(hash) {
+		hash.update(this._value);
 		if(this._originalSource)
-			sourceMap.setSourceContent(this._name, this._originalSource);
-		innerSourceMap = new SourceMapConsumer(innerSourceMap);
-		sourceMap.applySourceMap(innerSourceMap, this._name);
-		sourceMap = sourceMap.toJSON();
+			hash.update(this._originalSource);
 	}
-	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);
-};
+require("./SourceAndMapMixin")(SourceMapSource.prototype);
 
-SourceMapSource.prototype.updateHash = function(hash) {
-	hash.update(this._value);
-	if(this._originalSource)
-		hash.update(this._originalSource);
-};
+module.exports = SourceMapSource;

package.json

 {
   "name": "webpack-sources",
-  "version": "0.2.3",
+  "version": "1.0.0",
   "description": "Source code handling classes for webpack",
@@ -18,4 +18,4 @@ "main": "./lib/index.js",
   "dependencies": {
-    "source-map": "~0.5.3",
-    "source-list-map": "^1.1.1"
+    "source-list-map": "^2.0.0",
+    "source-map": "~0.5.3"
   },
@@ -26,8 +26,8 @@ "devDependencies": {
     "coveralls": "^2.11.6",
-    "eslint": "^1.1.0",
+    "eslint": "^3.19.0",
     "eslint-plugin-nodeca": "^1.0.3",
     "istanbul": "^0.4.1",
     "js-beautify": "^1.5.10",
-    "mocha": "^2.3.4",
-    "should": "^8.0.2"
+    "mocha": "^3.4.2",
+    "should": "^11.2.1"
   },
@@ -34,0 +34,0 @@ "files": [

README.md

@@ -219,2 +219,5 @@ # webpack-sources
 
+#### `original`
 
+Get decorated `Source`.
+

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Lines of code

654

increased by3.97%

Number of low quality alerts

0

decreased by-100%

Number of lines in readme file

223

increased by1.36%

Worsened metrics

Total package byte prevSize

26067

decreased by-5.23%

Dependency changes

• + Addedsource-list-map@2.0.1(transitive)

• - Removedsource-list-map@1.1.2(transitive)

• Updatedsource-list-map@^2.0.0