smock 0.1.207 → 0.1.208

data/node_modules/webpack/lib/SetVarMainTemplatePlugin.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var ConcatSource = require("webpack-core/lib/ConcatSource");
+
+function SetVarMainTemplatePlugin(varExpression, copyObject) {
+	this.varExpression = varExpression;
+	this.copyObject = copyObject;
+}
+module.exports = SetVarMainTemplatePlugin;
+SetVarMainTemplatePlugin.prototype.apply = function(compilation) {
+	var mainTemplate = compilation.mainTemplate;
+	compilation.templatesPlugin("render-with-entry", function(source, chunk, hash) {
+		var varExpression = mainTemplate.applyPluginsWaterfall("asset-path", this.varExpression, {
+			hash: hash,
+			chunk: chunk
+		});
+		if(this.copyObject) {
+			return new ConcatSource("(function(e, a) { for(var i in a) e[i] = a[i]; }(" +
+				varExpression + ", ", source, "))");
+		} else {
+			var prefix = varExpression + " =\n";
+			return new ConcatSource(prefix, source);
+		}
+	}.bind(this));
+	mainTemplate.plugin("global-hash-paths", function (paths) {
+		if (this.varExpression) paths.push(this.varExpression);
+		return paths;
+	});
+	mainTemplate.plugin("hash", function(hash) {
+		hash.update("set var");
+		hash.update(this.varExpression + "");
+		hash.update(this.copyObject + "");
+	}.bind(this));
+};

data/node_modules/webpack/lib/SingleEntryPlugin.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var SingleEntryDependency = require("./dependencies/SingleEntryDependency");
+
+function SingleEntryPlugin(context, entry, name) {
+	this.context = context;
+	this.entry = entry;
+	this.name = name;
+}
+module.exports = SingleEntryPlugin;
+SingleEntryPlugin.prototype.apply = function(compiler) {
+	compiler.plugin("compilation", function(compilation, params) {
+		var normalModuleFactory = params.normalModuleFactory;
+
+		compilation.dependencyFactories.set(SingleEntryDependency, normalModuleFactory);
+	});
+	compiler.plugin("make", function(compilation, callback) {
+		compilation.addEntry(this.context, new SingleEntryDependency(this.entry), this.name, callback);
+	}.bind(this));
+};

data/node_modules/webpack/lib/Source.js

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

data/node_modules/webpack/lib/SourceMapDevToolPlugin.js

@@ -0,0 +1,140 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var path = require("path");
+var RequestShortener = require("./RequestShortener");
+var Template = require("./Template");
+var ConcatSource = require("webpack-core/lib/ConcatSource");
+var RawSource = require("webpack-core/lib/RawSource");
+var ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
+
+function SourceMapDevToolPlugin(sourceMapFilename, sourceMappingURLComment, moduleFilenameTemplate, fallbackModuleFilenameTemplate) {
+	this.sourceMapFilename = sourceMapFilename;
+	this.sourceMappingURLComment = sourceMappingURLComment === false ? false : sourceMappingURLComment || "\n//# sourceMappingURL=[url]";
+	this.moduleFilenameTemplate = moduleFilenameTemplate || "webpack:///[resourcePath]";
+	this.fallbackModuleFilenameTemplate = fallbackModuleFilenameTemplate || "webpack:///[resourcePath]?[hash]";
+}
+module.exports = SourceMapDevToolPlugin;
+SourceMapDevToolPlugin.prototype.apply = function(compiler) {
+	var sourceMapFilename = this.sourceMapFilename;
+	var sourceMappingURLComment = this.sourceMappingURLComment;
+	var moduleFilenameTemplate = this.moduleFilenameTemplate;
+	var fallbackModuleFilenameTemplate = this.fallbackModuleFilenameTemplate;
+	var requestShortener = new RequestShortener(compiler.context);
+	compiler.plugin("compilation", function(compilation) {
+		compilation.plugin("build-module", function(module) {
+			module.useSourceMap = true;
+		});
+		compilation.plugin("after-optimize-chunk-assets", function(chunks) {
+			var allModules = [];
+			var allModuleFilenames = [];
+			var tasks = [];
+			chunks.forEach(function(chunk) {
+				chunk.files.slice().map(function(file) {
+					var asset = this.assets[file];
+					if(asset.__SourceMapDevTool_Data) {
+						var data = asset.__SourceMapDevTool_Data;
+						for(var cachedFile in data) {
+							this.assets[cachedFile] = data[cachedFile];
+							if(cachedFile !== file)
+								chunk.files.push(cachedFile);
+						}
+						return;
+					}
+					var sourceMap = asset.map();
+					if(sourceMap) {
+						return {
+							chunk: chunk,
+							file: file,
+							asset: asset,
+							sourceMap: sourceMap
+						}
+					}
+				}, this).filter(Boolean).map(function(task) {
+					var modules = task.sourceMap.sources.map(function(source) {
+						var module = compilation.findModule(source);
+						return module || source;
+					});
+					var moduleFilenames = modules.map(function(module) {
+						return ModuleFilenameHelpers.createFilename(module, moduleFilenameTemplate, requestShortener);
+					});
+					task.modules = modules;
+					task.moduleFilenames = moduleFilenames;
+					return task;
+				}, this).forEach(function(task) {
+					allModules = allModules.concat(task.modules);
+					allModuleFilenames = allModuleFilenames.concat(task.moduleFilenames);
+					tasks.push(task);
+				}, this);
+			}, this);
+			allModuleFilenames = ModuleFilenameHelpers.replaceDuplicates(allModuleFilenames, function(filename, i) {
+				return ModuleFilenameHelpers.createFilename(allModules[i], fallbackModuleFilenameTemplate, requestShortener);
+			}, function(ai, bi) {
+				var a = allModules[ai];
+				var b = allModules[bi];
+				a = typeof a === "string" ? a : a.identifier();
+				b = typeof b === "string" ? b : b.identifier();
+				return a.length - b.length;
+			});
+			allModuleFilenames = ModuleFilenameHelpers.replaceDuplicates(allModuleFilenames, function(filename, i, n) {
+				for(var j = 0; j < n; j++)
+					filename += "*";
+				return filename;
+			});
+			tasks.forEach(function(task) {
+				task.moduleFilenames = allModuleFilenames.slice(0, task.moduleFilenames.length);
+				allModuleFilenames = allModuleFilenames.slice(task.moduleFilenames.length);
+			}, this);
+			tasks.forEach(function(task) {
+				var chunk = task.chunk;
+				var file = task.file;
+				var asset = task.asset;
+				var sourceMap = task.sourceMap;
+				var moduleFilenames = task.moduleFilenames;
+				var modules = task.modules;
+				sourceMap.sources = moduleFilenames;
+				if(sourceMap.sourcesContent) {
+					sourceMap.sourcesContent = sourceMap.sourcesContent.map(function(content, i) {
+						return content + "\n\n\n" + ModuleFilenameHelpers.createFooter(modules[i], requestShortener);
+					});
+				}
+				sourceMap.sourceRoot = "";
+				sourceMap.file = file;
+				asset.__SourceMapDevTool_Data = {};
+				var currentSourceMappingURLComment = sourceMappingURLComment;
+				if(currentSourceMappingURLComment !== false && /\.css($|\?)/i.test(file)) {
+					currentSourceMappingURLComment = currentSourceMappingURLComment.replace(/^\n\/\/(.*)$/, "\n/*$1*/");
+				}
+				if(sourceMapFilename) {
+					var filename = file, query = "";
+					var idx = filename.indexOf("?");
+					if(idx >= 0) {
+						query = filename.substr(idx);
+						filename = filename.substr(0, idx);
+					}
+					var sourceMapFile = this.getPath(sourceMapFilename, {
+						chunk: chunk,
+						filename: filename,
+						query: query,
+						basename: basename(filename)
+					});
+					var sourceMapUrl = path.relative(path.dirname(file), sourceMapFile).replace(/\\/g, "/");
+					if(currentSourceMappingURLComment !== false) {
+						asset.__SourceMapDevTool_Data[file] = this.assets[file] = new ConcatSource(asset, currentSourceMappingURLComment.replace(/\[url\]/g, sourceMapUrl));
+					}
+					asset.__SourceMapDevTool_Data[sourceMapFile] = this.assets[sourceMapFile] = new RawSource(JSON.stringify(sourceMap));
+					chunk.files.push(sourceMapFile);
+				} else {
+					asset.__SourceMapDevTool_Data[file] = this.assets[file] = new ConcatSource(asset, currentSourceMappingURLComment.replace(/\[url\]/g, "data:application/json;base64," + new Buffer(JSON.stringify(sourceMap)).toString("base64")));
+				}
+			}, this);
+		});
+	});
+};
+
+function basename(name) {
+	if(name.indexOf("/") < 0) return name;
+	return name.substr(name.lastIndexOf("/")+1);
+}
+

data/node_modules/webpack/lib/SourceMapSource.js

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

data/node_modules/webpack/lib/Stats.js

@@ -0,0 +1,609 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var RequestShortener = require("./RequestShortener");
+
+function Stats(compilation) {
+	this.compilation = compilation;
+	this.hash = compilation.hash;
+}
+module.exports = Stats;
+
+Stats.prototype.hasWarnings = function() {
+	return this.compilation.warnings.length > 0;
+};
+
+Stats.prototype.hasErrors = function() {
+	return this.compilation.errors.length > 0;
+};
+
+Stats.prototype.toJson = function toJson(options, forToString) {
+	if(!options) options = {};
+	function d(v, d) { return v === undefined ? d : v }
+	var compilation = this.compilation;
+	var requestShortener = new RequestShortener(d(options.context, process.cwd()));
+	var showHash = d(options.hash, true);
+	var showVersion = d(options.version, true);
+	var showTimings = d(options.timings, true);
+	var showAssets = d(options.assets, true);
+	var showChunks = d(options.chunks, true);
+	var showChunkModules = d(options.chunkModules, !!forToString);
+	var showChunkOrigins = d(options.chunkOrigins, !forToString);
+	var showModules = d(options.modules, !forToString);
+	var showCachedModules = d(options.cached, true);
+	var showCachedAssets = d(options.cachedAssets, true);
+	var showReasons = d(options.reasons, !forToString);
+	var showChildren = d(options.children, true);
+	var showSource = d(options.source, !forToString);
+	var showErrorDetails = d(options.errorDetails, !forToString);
+	var excludeModules = [].concat(d(options.exclude, [])).map(function(str) {
+		if(typeof str !== "string") return str;
+		return new RegExp("[\\\\/]" + str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&") + "([\\\\/]|$|!|\\?)");
+	});
+	var sortModules = d(options.modulesSort, "id");
+	var sortChunks = d(options.chunksSort, "id");
+	var sortAssets = d(options.assetsSort, "");
+	
+	function moduleFilter(module) {
+		if(!showCachedModules && !module.built) {
+			return false;
+		}
+		if(excludeModules.length === 0)
+			return true;
+		var ident = module.identifier();
+		return !excludeModules.some(function(regExp) {
+			return regExp.test(ident);
+		});
+	}
+
+	function sortByField(field) {
+		if(!field) return function() { return 0; }
+		if(field[0] === "!") {
+			field = field.substr(1);
+			return function(a, b) {
+				if(a[field] === b[field]) return 0;
+				return (a[field] < b[field]) ? 1 : -1;
+			}
+		}
+		return function(a, b) {
+			if(a[field] === b[field]) return 0;
+			return (a[field] < b[field]) ? -1 : 1;
+		}
+	}
+	function formatError(e) {
+		var text = "";
+		if(e.module && e.module.readableIdentifier && typeof e.module.readableIdentifier === "function") {
+			text += e.module.readableIdentifier(requestShortener) + "\n";
+		} else if(e.file) {
+			text += e.file + "\n";
+		}
+		text += e.message;
+		if(showErrorDetails && e.details) text += "\n" + e.details;
+		if(e.dependencies && e.origin) {
+			text += "\n @ " + e.origin.readableIdentifier(requestShortener);
+			e.dependencies.forEach(function(dep) {
+				if(!dep.loc) return;
+				if(!dep.loc.start) return;
+				if(!dep.loc.end) return;
+				text += " " + dep.loc.start.line + ":" + dep.loc.start.column + "-" +
+					(dep.loc.start.line !== dep.loc.end.line ? dep.loc.end.line + ":" : "") + dep.loc.end.column;
+			});
+		}
+		return text;
+	}
+	var obj = {
+		errors: compilation.errors.map(formatError),
+		warnings: compilation.warnings.map(formatError)
+	};
+
+	if(showVersion) {
+		obj.version = require("../package.json").version;
+	}
+
+	if(showHash) obj.hash = this.hash;
+	if(showTimings && this.startTime && this.endTime) {
+		obj.time = this.endTime - this.startTime;
+	}
+	if(showAssets) {
+		var assetsByFile = {};
+		obj.assetsByChunkName = {};
+		obj.assets = Object.keys(compilation.assets).map(function(asset) {
+			var obj = {
+				name: asset,
+				size: compilation.assets[asset].size(),
+				chunks: [],
+				chunkNames: [],
+				emitted: compilation.assets[asset].emitted
+			};
+			assetsByFile[asset] = obj;
+			return obj;
+		}).filter(function(asset) {
+			return showCachedAssets || asset.emitted;
+		});
+		compilation.chunks.forEach(function(chunk) {
+			chunk.files.forEach(function(asset) {
+				if(assetsByFile[asset]) {
+					chunk.ids.forEach(function(id) {
+						assetsByFile[asset].chunks.push(id);
+					});
+					if(chunk.name) {
+						assetsByFile[asset].chunkNames.push(chunk.name);
+						if(obj.assetsByChunkName[chunk.name])
+							obj.assetsByChunkName[chunk.name] = [].concat(obj.assetsByChunkName[chunk.name]).concat([asset]);
+						else
+							obj.assetsByChunkName[chunk.name] = asset;
+					}
+				}
+			});
+		});
+		obj.assets.sort(sortByField(sortAssets));
+	}
+	function fnModule(module) {
+		var obj = {
+			id: module.id,
+			identifier: module.identifier(),
+			name: module.readableIdentifier(requestShortener),
+			size: module.size(),
+			cacheable: !!module.cacheable,
+			built: !!module.built,
+			optional: !!module.optional,
+			prefetched: !!module.prefetched,
+			chunks: module.chunks.map(function(chunk) {
+				return chunk.id;
+			}),
+			assets: Object.keys(module.assets || {}),
+			issuer: module.issuer,
+			profile: module.profile,
+			failed: !!module.error,
+			errors: module.errors && module.dependenciesErrors && (module.errors.length + module.dependenciesErrors.length),
+			warnings: module.errors && module.dependenciesErrors && (module.warnings.length + module.dependenciesWarnings.length)
+		};
+		if(showReasons) {
+			obj.reasons = module.reasons.filter(function(reason) {
+				return reason.dependency && reason.module;
+			}).map(function(reason) {
+				var obj = {
+					moduleId: reason.module.id,
+					moduleIdentifier: reason.module.identifier(),
+					module: reason.module.readableIdentifier(requestShortener),
+					moduleName: reason.module.readableIdentifier(requestShortener),
+					type: reason.dependency.type,
+					userRequest: reason.dependency.userRequest
+				}
+				var dep = reason.dependency;
+				if(dep.templateModules) obj.templateModules = dep.templateModules.map(function(module) { return module.id; });
+				if(dep.loc) obj.loc = dep.loc.start.line + ":" + dep.loc.start.column + "-" +
+					(dep.loc.start.line !== dep.loc.end.line ? dep.loc.end.line + ":" : "") + dep.loc.end.column
+				return obj;
+			}).sort(function(a, b) {
+				return a.moduleId - b.moduleId;
+			});
+		}
+		if(showSource && module._source) {
+			obj.source = module._source.source();
+		}
+		return obj;
+	}
+	if(showChunks) {
+		obj.chunks = compilation.chunks.map(function(chunk) {
+			var obj = {
+				id: chunk.id,
+				rendered: chunk.rendered,
+				initial: !!chunk.initial,
+				entry: !!chunk.entry,
+				size: chunk.modules.reduce(function(size, module) { return size + module.size(); }, 0),
+				names: chunk.name ? [chunk.name] : [],
+				files: chunk.files.slice(),
+				parents: chunk.parents.map(function(c) {
+					return c.id;
+				})
+			};
+			if(showChunkModules) {
+				obj.modules = chunk.modules.filter(moduleFilter).map(fnModule);
+				obj.filteredModules = chunk.modules.length - obj.modules.length;
+				obj.modules.sort(sortByField(sortModules));
+			}
+			if(showChunkOrigins) {
+				obj.origins = chunk.origins.map(function(origin) {
+					return {
+						moduleId: origin.module ? origin.module.id : undefined,
+						module: origin.module ? origin.module.identifier() : "",
+						moduleIdentifier: origin.module ? origin.module.identifier() : "",
+						moduleName: origin.module ? origin.module.readableIdentifier(requestShortener) : "",
+						loc: origin.loc ? obj.loc = origin.loc.start.line + ":" + origin.loc.start.column + "-" +
+							(origin.loc.start.line !== origin.loc.end.line ? origin.loc.end.line + ":" : "") + origin.loc.end.column : "",
+						name: origin.name,
+						reasons: origin.reasons || []
+					}
+				});
+			}
+			return obj;
+		});
+		obj.chunks.sort(sortByField(sortChunks));
+	}
+	if(showModules) {
+		obj.modules = compilation.modules.filter(moduleFilter).map(fnModule);
+		obj.filteredModules = compilation.modules.length - obj.modules.length;
+		obj.modules.sort(sortByField(sortModules));
+	}
+	if(showChildren) {
+		obj.children = compilation.children.map(function(child) {
+			var obj = new Stats(child).toJson(options, forToString);
+			delete obj.hash;
+			delete obj.version;
+			obj.name = child.name;
+			return obj;
+		});
+	}
+	return obj;
+};
+
+Stats.prototype.toString = function toString(options) {
+	if(!options) options = {};
+	function d(v, d) { return v === undefined ? d : v }
+	var useColors = d(options.colors, false);
+
+	var obj = this.toJson(options, true);
+
+	return Stats.jsonToString(obj, useColors);
+};
+
+Stats.jsonToString = function jsonToString(obj, useColors) {
+	var buf = [];
+	function normal(str) {
+		buf.push(str);
+	}
+	function bold(str) {
+		if(useColors) buf.push("\033[1m");
+		buf.push(str);
+		if(useColors) buf.push("\033[22m");
+	}
+	function yellow(str) {
+		if(useColors) buf.push("\033[1m\033[33m");
+		buf.push(str);
+		if(useColors) buf.push("\033[39m\033[22m");
+	}
+	function red(str) {
+		if(useColors) buf.push("\033[1m\033[31m");
+		buf.push(str);
+		if(useColors) buf.push("\033[39m\033[22m");
+	}
+	function green(str) {
+		if(useColors) buf.push("\033[1m\033[32m");
+		buf.push(str);
+		if(useColors) buf.push("\033[39m\033[22m");
+	}
+	function cyan(str) {
+		if(useColors) buf.push("\033[1m\033[36m");
+		buf.push(str);
+		if(useColors) buf.push("\033[39m\033[22m");
+	}
+	function magenta(str) {
+		if(useColors) buf.push("\033[1m\033[35m");
+		buf.push(str);
+		if(useColors) buf.push("\033[39m\033[22m");
+	}
+	function coloredTime(time) {
+		var times = [800, 400, 200, 100];
+		if(obj.time) {
+			times = [obj.time/2, obj.time/4, obj.time/8, obj.time/16];
+		}
+		if(time < times[3])
+			normal(time + "ms");
+		else if(time < times[2])
+			bold(time + "ms");
+		else if(time < times[1])
+			green(time + "ms");
+		else if(time < times[0])
+			yellow(time + "ms");
+		else
+			red(time + "ms");
+	}
+	function newline() {
+		buf.push("\n");
+	}
+	function table(array, formats, align, splitter) {
+		var rows = array.length;
+		var cols = array[0].length;
+		var colSizes = new Array(cols);
+		for(var col = 0; col < cols; col++)
+			colSizes[col] = 3;
+		for(var row = 0; row < rows; row++) {
+			for(var col = 0; col < cols; col++) {
+				var value = array[row][col] + "";
+				if(value.length > colSizes[col]) {
+					colSizes[col] = value.length;
+				}
+			}
+		}
+		for(var row = 0; row < rows; row++) {
+			for(var col = 0; col < cols; col++) {
+				var format = row === 0 ? bold : formats[col];
+				var value = array[row][col] + "";
+				var l = value.length;
+				if(align[col] === "l")
+					format(value);
+				for(; l < colSizes[col] && col !== cols-1; l++)
+					normal(" ");
+				if(align[col] === "r")
+					format(value);
+				if(col + 1 < cols)
+					normal(splitter || "  ");
+			}
+			newline();
+		}
+	}
+
+	if(obj.hash) {
+		normal("Hash: ");
+		bold(obj.hash);
+		newline();
+	}
+	if(obj.version) {
+		normal("Version: webpack ");
+		bold(obj.version);
+		newline();
+	}
+	if(obj.time) {
+		normal("Time: ");
+		bold(obj.time);
+		normal("ms");
+		newline();
+	}
+	if(obj.assets && obj.assets.length > 0) {
+		var t = [["Asset", "Size", "Chunks", "", "Chunk Names"]]
+		obj.assets.forEach(function(asset) {
+			t.push([
+				asset.name,
+				asset.size,
+				asset.chunks.join(", "),
+				asset.emitted ? "[emitted]" : "",
+				asset.chunkNames.join(", ")
+			])
+		});
+		table(t, [green, normal, bold, green, normal], "rrrll");
+	}
+	var modulesByIdentifier = {};
+	if(obj.modules) {
+		obj.modules.forEach(function(module) {
+			modulesByIdentifier["$"+module.identifier] = module;
+		});
+	} else if(obj.chunks) {
+		obj.chunks.forEach(function(chunk) {
+			if(chunk.modules) {
+				chunk.modules.forEach(function(module) {
+					modulesByIdentifier["$"+module.identifier] = module;
+				});
+			}
+		});
+	}
+	function processProfile(module) {
+		if(module.profile) {
+			normal("      ");
+			var sum = 0, allowSum = true;
+			var path = [];
+			var current = module;
+			while(current.issuer) {
+				if(!modulesByIdentifier["$"+current.issuer]) {
+					normal(" ... ->");
+					allowSum = false;
+					break;
+				}
+				path.unshift(current = modulesByIdentifier["$"+current.issuer]);
+			}
+			path.forEach(function(module) {
+				normal(" [");
+				normal(module.id);
+				normal("] ");
+				if(module.profile) {
+					var time = (module.profile.factory || 0) + (module.profile.building || 0);
+					coloredTime(time);
+					sum += time;
+					normal(" ");
+				}
+				normal("->");
+			});
+			Object.keys(module.profile).forEach(function(key) {
+				normal(" " + key + ":");
+				var time = module.profile[key];
+				coloredTime(time);
+				sum += time;
+			});
+			if(allowSum) {
+				normal(" = ");
+				coloredTime(sum);
+			}
+			newline();
+		}
+	}
+	function processModuleAttributes(module) {
+		normal(" ");
+		normal(module.size);
+		if(module.chunks) {
+			module.chunks.forEach(function(chunk) {
+				normal(" {");
+				yellow(chunk);
+				normal("}");
+			});
+		}
+		if(!module.cacheable) {
+			red(" [not cacheable]");
+		}
+		if(module.optional) {
+			yellow(" [optional]");
+		}
+		if(module.built) {
+			green(" [built]");
+		}
+		if(module.prefetched) {
+			magenta(" [prefetched]");
+		}
+		if(module.failed)
+			red(" [failed]");
+		if(module.warnings)
+			yellow(" [" + module.warnings + " warning"+(module.warnings === 1 ? "": "s")+"]");
+		if(module.errors)
+			red(" [" + module.errors + " error"+(module.errors === 1 ? "": "s")+"]");
+	}
+	if(obj.chunks) {
+		obj.chunks.forEach(function(chunk) {
+			normal("chunk ");
+			if(chunk.id < 1000) normal(" ");
+			if(chunk.id < 100) normal(" ");
+			if(chunk.id < 10) normal(" ");
+			normal("{");
+			yellow(chunk.id);
+			normal("} ");
+			green(chunk.files.join(", "));
+			if(chunk.names && chunk.names.length > 0) {
+				normal(" (");
+				normal(chunk.names.join(", "));
+				normal(")");
+			}
+			normal(" ");
+			normal(chunk.size);
+			chunk.parents.forEach(function(id) {
+				normal(" {");
+				yellow(id);
+				normal("}");
+			});
+			if(chunk.rendered) {
+				green(" [rendered]");
+			}
+			newline();
+			if(chunk.origins) {
+				chunk.origins.forEach(function(origin) {
+					normal("    > ");
+					if(origin.reasons && origin.reasons.length) {
+						yellow(origin.reasons.join(" "));
+						normal(" ");
+					}
+					if(origin.name) {
+						normal(origin.name)
+						normal(" ");
+					}
+					if(origin.module) {
+						normal("[");
+						normal(origin.moduleId);
+						normal("] ");
+						var module = modulesByIdentifier["$"+origin.module];
+						if(module) {
+							bold(module.name);
+							normal(" ");
+						}
+						if(origin.loc) {
+							normal(origin.loc);
+						}
+					}
+					newline();
+				});
+			}
+			if(chunk.modules) {
+				chunk.modules.forEach(function(module) {
+					normal(" ");
+					if(module.id < 1000) normal(" ");
+					if(module.id < 100) normal(" ");
+					if(module.id < 10) normal(" ");
+					normal("[");
+					normal(module.id);
+					normal("] ");
+					bold(module.name);
+					processModuleAttributes(module);
+					newline();
+					if(module.reasons) {
+						module.reasons.forEach(function(reason) {
+							normal("        ");
+							normal(reason.type);
+							normal(" ");
+							cyan(reason.userRequest);
+							if(reason.templateModules) cyan(reason.templateModules.join(" "));
+							normal(" [");
+							normal(reason.moduleId);
+							normal("] ");
+							magenta(reason.module);
+							if(reason.loc) {
+								normal(" ");
+								normal(reason.loc)
+							}
+							newline();
+						});
+					}
+					processProfile(module);
+				});
+				if(chunk.filteredModules > 0) {
+					normal("     + " + chunk.filteredModules + " hidden modules");
+					newline();
+				}
+			}
+		});
+	}
+	if(obj.modules) {
+		obj.modules.forEach(function(module) {
+			if(module.id < 1000) normal(" ");
+			if(module.id < 100) normal(" ");
+			if(module.id < 10) normal(" ");
+			normal("[");
+			normal(module.id);
+			normal("] ");
+			bold(module.name || module.identifier);
+			processModuleAttributes(module);
+			newline();
+			if(module.reasons) {
+				module.reasons.forEach(function(reason) {
+					normal("       ");
+					normal(reason.type);
+					normal(" ");
+					cyan(reason.userRequest);
+					if(reason.templateModules) cyan(reason.templateModules.join(" "));
+					normal(" [");
+					normal(reason.moduleId);
+					normal("] ");
+					magenta(reason.module);
+					if(reason.loc) {
+						normal(" ");
+						normal(reason.loc)
+					}
+					newline();
+				});
+			}
+			processProfile(module);
+		});
+		if(obj.filteredModules > 0) {
+			normal("    + " + obj.filteredModules + " hidden modules");
+			newline();
+		}
+	}
+	if(obj.warnings) {
+		obj.warnings.forEach(function(warning) {
+			newline();
+			yellow("WARNING in " + warning);
+			newline();
+		});
+	}
+	if(obj.errors) {
+		obj.errors.forEach(function(error) {
+			newline();
+			red("ERROR in " + error);
+			newline();
+		});
+	}
+	if(obj.children) {
+		obj.children.forEach(function(child) {
+			if(child.name) {
+				normal("Child ");
+				bold(child.name);
+				normal(":");
+			} else {
+				normal("Child");
+			}
+			newline();
+			buf.push("    ");
+			buf.push(Stats.jsonToString(child, useColors).replace(/\n/g, "\n    "));
+			newline();
+		});
+	}
+
+	while(buf[buf.length-1] === "\n") buf.pop();
+	return buf.join("");
+};