smock 0.1.207 → 0.1.208

data/node_modules/webpack/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];
+	}
+}

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

@@ -0,0 +1,70 @@
+/*
+	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 SourceMapNodeSource = require("./SourceMapNodeSource");
+
+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, sourceMap) {
+	if(sourceMap) {
+		if(typeof sourceMap === "string")
+			sourceMap = JSON.parse(sourceMap);
+		node = SourceNode.fromStringWithSourceMap(value, new SourceMapConsumer(sourceMap));
+	} else {
+		var lines = value.split("\n");
+		var node = new SourceNode(null, null, null,
+			lines.map(function(line, idx) {
+				var pos = 0;
+				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);
+	}
+	SourceMapNodeSource.call(this, node, name);
+	this._value = value;
+}
+
+module.exports = OriginalSource;
+
+OriginalSource.prototype = Object.create(SourceMapNodeSource.prototype);
+OriginalSource.prototype.source = function() {
+	return this._value;
+};
+OriginalSource.prototype.updateHash = function(hash) {
+	hash.update(this._value);
+	hash.update(this._name);
+};

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

@@ -0,0 +1,38 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var SourceMapNodeSource = require("./SourceMapNodeSource");
+var SourceNode = require("source-map").SourceNode;
+
+function PrefixSource(prefix, source) {
+	var node = source.node();
+	var append = [prefix];
+	node = new SourceNode(null, null, null, [
+		this._cloneAndPrefix(node, prefix, append)
+	]);
+	SourceMapNodeSource.call(this, node);
+}
+module.exports = PrefixSource;
+
+PrefixSource.prototype = Object.create(SourceMapNodeSource.prototype);
+PrefixSource.prototype._cloneAndPrefix = 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;
+	}
+};

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

@@ -0,0 +1,18 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var Source = require("./Source");
+
+function RawSource(value) {
+	Source.call(this);
+	this._value = value;
+}
+module.exports = RawSource;
+
+RawSource.prototype = Object.create(Source.prototype);
+RawSource.prototype._bake = function() {
+	return {
+		source: this._value
+	};
+};

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

@@ -0,0 +1,92 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var SourceMapNodeSource = require("./SourceMapNodeSource");
+var SourceNode = require("source-map").SourceNode;
+var SourceMapConsumer = require("source-map").SourceMapConsumer;
+
+function ReplaceSource(source, name) {
+	SourceMapNodeSource.call(this, null, name);
+	this._source = source;
+	this.replacements = [];
+}
+module.exports = ReplaceSource;
+
+ReplaceSource.prototype = Object.create(SourceMapNodeSource.prototype);
+
+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._bake = function() {
+	this.replacements.sort(function(a, b) {
+		return b[1] - a[1];
+	});
+	var result = [this._source.node()];
+	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._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;
+	}
+};

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

@@ -0,0 +1,43 @@
+/*
+	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() {
+	this._result = null;
+}
+module.exports = Source;
+
+Source.prototype.source = function() {
+	if(!this._result)
+		this._result = this._bake();
+	return this._result.source;
+};
+Source.prototype.size = function() {
+	if(!this._result)
+		this._result = this._bake();
+	return this._result.source.length;
+};
+Source.prototype.map = function() {
+	if(!this._result)
+		this._result = this._bake();
+	return this._result.map;
+};
+Source.prototype.node = function() {
+	if(!this._result)
+		this._result = this._bake();
+	if(this._result.node)
+		return this._result.node;
+	if(this._result.map)
+		return SourceNode.fromStringWithSourceMap(this._result.source, new SourceMapConsumer(this._result.map));
+	return new SourceNode(null, null, null, this._result.source);
+};
+Source.prototype.updateHash = function(hash) {
+	if(!this._result)
+		this._result = this._bake();
+	hash.update(this._result.source || "");
+	if(this._result.map)
+		hash.update(JSON.stringify(this._result.map));
+};

data/node_modules/webpack/node_modules/webpack-core/lib/SourceMapNodeSource.js

@@ -0,0 +1,70 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var Source = require("./Source");
+
+function SourceMapNodeSource(node, name) {
+	Source.call(this);
+	this._node = node;
+	this._name = name;
+}
+module.exports = SourceMapNodeSource;
+
+SourceMapNodeSource.prototype = Object.create(Source.prototype);
+SourceMapNodeSource.prototype._bake = function() {
+	throw new Error("Overwrite or pass valid SourceNode to constructor");
+};
+SourceMapNodeSource.prototype.source = function() {
+	if(!this._node) this._node = this._bake();
+	if(!this._sourceResult) {
+		this._sourceResult = this._node.toString();
+	}
+	return this._sourceResult;
+};
+SourceMapNodeSource.prototype.map = function() {
+	if(!this._node) this._node = this._bake();
+	if(!this._mapResult) {
+		this._mapResult = this._node.toStringWithSourceMap({
+			file: this._name
+		}).map.toJSON();
+	}
+	return this._mapResult;
+};
+SourceMapNodeSource.prototype.size = function() {
+	if(!this._node) this._node = this._bake();
+	if(!this._sizeResult) {
+		this._sizeResult = sizeOfNode(this._node);
+	}
+	return this._sizeResult;
+};
+SourceMapNodeSource.prototype.node = function() {
+	if(!this._node) this._node = this._bake();
+	return this._node;
+};
+SourceMapNodeSource.prototype.updateHash = function(hash) {
+	if(!this._node) this._node = this._bake();
+	updateHashForNode(this._node, hash);
+};
+function updateHashForNode(node, hash) {
+	hash.update(node.source + "");
+	hash.update(node.line + "");
+	hash.update(node.column + "");
+	hash.update(node.name + "");
+	var c = node.children;
+	for(var i = 0; i < c.length; i++) {
+		var x = c[i];
+		if(typeof x === "string") hash.update(x);
+		else updateHashForNode(x, hash);
+	}
+}
+function sizeOfNode(node) {
+	var c = node.children;
+	var s = 0;
+	for(var i = 0; i < c.length; i++) {
+		var x = c[i];
+		if(typeof x === "string") s += x.length;
+		else s += sizeOfNode(x);
+	}
+	return s;
+}

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

@@ -0,0 +1,32 @@
+/*
+	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 SourceMapNodeSource = require("./SourceMapNodeSource");
+
+function SourceMapSource(value, name, sourceMap, originalSource, innerSourceMap) {
+	if(innerSourceMap) {
+		innerSourceMap = new SourceMapConsumer(innerSourceMap);
+		sourceMap = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(sourceMap));
+		sourceMap.setSourceContent(name, originalSource);
+		sourceMap.applySourceMap(innerSourceMap, name);
+		sourceMap = sourceMap.toJSON();
+	}
+	var node = SourceNode.fromStringWithSourceMap(value, new SourceMapConsumer(sourceMap));
+	SourceMapNodeSource.call(this, node);
+	this._value = value;
+	this._name = name;
+}
+module.exports = SourceMapSource;
+
+SourceMapSource.prototype = Object.create(SourceMapNodeSource.prototype);
+SourceMapSource.prototype.source = function() {
+	return this._value;
+};
+SourceMapSource.prototype.updateHash = function(hash) {
+	hash.update(this._value);
+	hash.update(this._name);
+};

data/node_modules/webpack/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");