smock 0.1.207 → 0.1.208

data/node_modules/webpack/node_modules/tapable/lib/Tapable.js

@@ -0,0 +1,168 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+function Tapable() {
+	this._plugins = {};
+}
+module.exports = Tapable;
+
+function copyProperties(from, to) {
+	for(var key in from)
+		to[key] = from[key];
+	return to;
+}
+
+Tapable.mixin = function mixinTapable(pt) {
+	copyProperties(Tapable.prototype, pt);
+}
+
+Tapable.prototype.applyPlugins = function applyPlugins(name) {
+	if(!this._plugins[name]) return;
+	var args = Array.prototype.slice.call(arguments, 1);
+	var plugins = this._plugins[name];
+	var old = this._currentPluginApply;
+	for(this._currentPluginApply = 0; this._currentPluginApply < plugins.length; this._currentPluginApply++)
+		plugins[this._currentPluginApply].apply(this, args);
+	this._currentPluginApply = old;
+};
+
+Tapable.prototype.applyPluginsWaterfall = function applyPlugins(name, init) {
+	if(!this._plugins[name]) return init;
+	var args = Array.prototype.slice.call(arguments, 2);
+	var plugins = this._plugins[name];
+	var current = init;
+	var old = this._currentPluginApply;
+	for(this._currentPluginApply = 0; this._currentPluginApply < plugins.length; this._currentPluginApply++)
+		current = plugins[this._currentPluginApply].apply(this, [current].concat(args));
+	this._currentPluginApply = old;
+	return current;
+};
+
+Tapable.prototype.applyPluginsBailResult = function applyPluginsBailResult(name) {
+	if(!this._plugins[name]) return;
+	var args = Array.prototype.slice.call(arguments, 1);
+	var plugins = this._plugins[name];
+	var old = this._currentPluginApply
+	for(this._currentPluginApply = 0; this._currentPluginApply < plugins.length; this._currentPluginApply++) {
+		var result = plugins[this._currentPluginApply].apply(this, args);
+		if(typeof result !== "undefined") {
+			this._currentPluginApply = old;
+			return result;
+		}
+	}
+	this._currentPluginApply = old;
+};
+
+Tapable.prototype.applyPluginsAsyncSeries = Tapable.prototype.applyPluginsAsync = function applyPluginsAsync(name) {
+	var args = Array.prototype.slice.call(arguments, 1);
+	var callback = args.pop();
+	if(!this._plugins[name] || this._plugins[name].length == 0) return callback();
+	var plugins = this._plugins[name];
+	var old = this._currentPluginApply;
+	this._currentPluginApply = 0;
+	args.push(copyProperties(callback, function next(err) {
+		if(err) return callback(err);
+		this._currentPluginApply++;
+		if(this._currentPluginApply >= plugins.length) {
+			this._currentPluginApply = old;
+			return callback();
+		}
+		plugins[this._currentPluginApply].apply(this, args);
+	}.bind(this)));
+	plugins[0].apply(this, args);
+};
+
+Tapable.prototype.applyPluginsAsyncWaterfall = function applyPluginsAsyncWaterfall(name, init, callback) {
+	if(!this._plugins[name] || this._plugins[name].length == 0) return callback(null, init);
+	var plugins = this._plugins[name];
+	var old = this._currentPluginApply;
+	this._currentPluginApply = 0;
+	var next = copyProperties(callback, function(err, value) {
+		if(err) return callback(err);
+		this._currentPluginApply++;
+		if(this._currentPluginApply >= plugins.length) {
+			this._currentPluginApply = old;
+			return callback(null, value);
+		}
+		plugins[this._currentPluginApply].call(this, value, next);
+	}.bind(this));
+	plugins[0].call(this, init, next);
+};
+
+Tapable.prototype.applyPluginsParallel = function applyPluginsParallel(name) {
+	var args = Array.prototype.slice.call(arguments, 1);
+	var callback = args.pop();
+	if(!this._plugins[name] || this._plugins[name].length == 0) return callback();
+	var plugins = this._plugins[name];
+	var remaining = plugins.length;
+	args.push(copyProperties(callback, function(err) {
+		if(remaining < 0) return; // ignore
+		if(err) {
+			remaining = -1;
+			return callback(err);
+		}
+		remaining--;
+		if(remaining == 0) {
+			return callback();
+		}
+	}));
+	for(var i = 0; i < plugins.length; i++) {
+		plugins[i].apply(this, args);
+		if(remaining < 0) return;
+	}
+};
+
+Tapable.prototype.applyPluginsParallelBailResult = function applyPluginsParallelBailResult(name) {
+	var args = Array.prototype.slice.call(arguments, 1);
+	var callback = args[args.length-1];
+	if(!this._plugins[name] || this._plugins[name].length == 0) return callback();
+	var plugins = this._plugins[name];
+	var currentPos = plugins.length;
+	var currentError, currentResult;
+	var done = [];
+	for(var i = 0; i < plugins.length; i++) {
+		args[args.length-1] = (function(i) {
+			return copyProperties(callback, function(err, result) {
+				if(i >= currentPos) return; // ignore
+				done.push(i);
+				if(err || result) {
+					currentPos = i + 1;
+					done = done.filter(function(item) {
+						return item <= i;
+					});
+					currentError = err;
+					currentResult = result;
+				}
+				if(done.length == currentPos) {
+					callback(currentError, currentResult);
+					currentPos = 0;
+				}
+			});
+		}(i));
+		plugins[i].apply(this, args);
+	}
+};
+
+
+Tapable.prototype.restartApplyPlugins = function restartApplyPlugins() {
+	this._currentPluginApply = -1;
+};
+
+
+Tapable.prototype.plugin = function plugin(name, fn) {
+	if(Array.isArray(name)) {
+		name.forEach(function(name) {
+			this.plugin(name, fn);
+		}, this);
+		return;
+	}
+	if(!this._plugins[name]) this._plugins[name] = [fn];
+	else this._plugins[name].push(fn);
+};
+
+Tapable.prototype.apply = function apply() {
+	for(var i = 0; i < arguments.length; i++) {
+		arguments[i].apply(this);
+	}
+};

data/node_modules/webpack/node_modules/tapable/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "tapable",
+  "version": "0.1.8",
+  "author": {
+    "name": "Tobias Koppers @sokra"
+  },
+  "description": "Just a little module for plugins.",
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://www.opensource.org/licenses/mit-license.php"
+    }
+  ],
+  "devDependencies": {
+    "mocha": "1.3.x",
+    "should": "1.1.x"
+  },
+  "engines": {
+    "node": ">=0.6"
+  },
+  "homepage": "https://github.com/webpack/tapable",
+  "main": "lib/Tapable.js",
+  "scripts": {
+    "test": "mocha --reporter spec"
+  },
+  "gitHead": "18ce8ffafc024daa804e57afcac2e3b65202d0dd",
+  "_id": "tapable@0.1.8",
+  "_shasum": "a943314bc86ac87602c93fbc8ac609dcb19c199e",
+  "_from": "tapable@~0.1.8",
+  "_npmVersion": "1.4.16",
+  "_npmUser": {
+    "name": "sokra",
+    "email": "tobias.koppers@googlemail.com"
+  },
+  "maintainers": [
+    {
+      "name": "sokra",
+      "email": "tobias.koppers@googlemail.com"
+    }
+  ],
+  "dist": {
+    "shasum": "a943314bc86ac87602c93fbc8ac609dcb19c199e",
+    "tarball": "http://registry.npmjs.org/tapable/-/tapable-0.1.8.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/tapable/-/tapable-0.1.8.tgz",
+  "readme": "ERROR: No README data found!"
+}

data/node_modules/webpack/node_modules/tapable/test/applyPluginsParallelBailResultTest.js

@@ -0,0 +1,140 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var Tapable = require("../lib/Tapable");
+var should = require("should");
+
+function makeTestPlugin(arr, index) {
+	var last;
+	var f = function() {
+		f.shouldNotBeCalled();
+		var args = Array.prototype.slice.call(arguments);
+		args.unshift(index);
+		last = args;
+		arr.push(args);
+	};
+	f.issue = function() {
+		f.shouldBeCalled();
+		last.pop().apply(null, arguments);
+		last = null;
+	};
+	f.shouldNotBeCalled = function() {
+		if(last) throw new Error("Plugin " + index + " was called, but shouldn't be.");
+	};
+	f.shouldBeCalled = function() {
+		if(!last) throw new Error("Plugin " + index + " was not called, but should be.");
+	};
+	f.shouldBeCalledAsyncWith = function() {
+		f.shouldBeCalled();
+		var args = Array.prototype.slice.call(arguments);
+		for(var i = 0; i < args.length && i < last.length - 2; i++) {
+			if(args[i] === null || args[i] === undefined) {
+				should.not.exist(last[i+1]);
+			} else {
+				should.exist(last[i+1]);
+				last[i+1].should.be.eql(args[i]);
+			}
+		}
+		args.length.should.be.eql(last.length - 2);
+	};
+	return f;
+}
+
+describe("applyPluginsParallelBailResult", function() {
+	it("should call all handlers", function() {
+		var tapable = new Tapable();
+		var log = [];
+		var p1 = makeTestPlugin(log, 1);
+		var p2 = makeTestPlugin(log, 2);
+		var p3 = makeTestPlugin(log, 3);
+		var p4 = makeTestPlugin(log, 4);
+		var result = makeTestPlugin(log, 0);
+		tapable.plugin("test", p1);
+		tapable.plugin("test", p2);
+		tapable.plugin("xxxx", p3);
+		tapable.plugin("test", p4);
+		tapable.applyPluginsParallelBailResult("test", 1, 2, result);
+		p1.shouldBeCalledAsyncWith(1, 2);
+		p2.shouldBeCalledAsyncWith(1, 2);
+		p3.shouldNotBeCalled();
+		p4.shouldBeCalledAsyncWith(1, 2);
+		p1.issue();
+		p2.issue(null, "ok");
+		p4.issue(null, "fail");
+		log.should.be.eql([
+			[1, 1, 2],
+			[2, 1, 2],
+			[4, 1, 2],
+			[0, null, "ok"]
+		]);
+	});
+	it("should save valid results", function() {
+		var tapable = new Tapable();
+		var log = [];
+		var p1 = makeTestPlugin(log, 1);
+		var p2 = makeTestPlugin(log, 2);
+		var p3 = makeTestPlugin(log, 3);
+		tapable.plugin("test", p1);
+		tapable.plugin("test", p2);
+		tapable.plugin("test", p3);
+		var result = makeTestPlugin(log, 0);
+		tapable.applyPluginsParallelBailResult("test", "a", result);
+		p3.issue(null, "fail");
+		p2.issue(null, "ok");
+		p1.issue();
+		log.should.be.eql([
+			[1, "a"],
+			[2, "a"],
+			[3, "a"],
+			[0, null, "ok"],
+		]);
+	});
+	it("should take the first result", function() {
+		var tapable = new Tapable();
+		var log = [];
+		var p1 = makeTestPlugin(log, 1);
+		var p2 = makeTestPlugin(log, 2);
+		var p3 = makeTestPlugin(log, 3);
+		tapable.plugin("test", p1);
+		tapable.plugin("test", p2);
+		tapable.plugin("test", p3);
+		var result = makeTestPlugin(log, 0);
+		tapable.applyPluginsParallelBailResult("test", "a", result);
+		log.length.should.be.eql(3);
+		p1.issue(null, "ok");
+		log.length.should.be.eql(4);
+		p2.issue(new Error("fail"));
+		p3.issue();
+		log.should.be.eql([
+			[1, "a"],
+			[2, "a"],
+			[3, "a"],
+			[0, null, "ok"],
+		]);
+	});
+	it("should return errors", function() {
+		var tapable = new Tapable();
+		var log = [];
+		var p1 = makeTestPlugin(log, 1);
+		var p2 = makeTestPlugin(log, 2);
+		var p3 = makeTestPlugin(log, 3);
+		tapable.plugin("test", p1);
+		tapable.plugin("test", p2);
+		tapable.plugin("test", p3);
+		var result = makeTestPlugin(log, 0);
+		tapable.applyPluginsParallelBailResult("test", "a", result);
+		log.length.should.be.eql(3);
+		p1.issue("ok");
+		log.length.should.be.eql(4);
+		p2.issue();
+		p3.issue(null, "fail");
+		log.should.be.eql([
+			[1, "a"],
+			[2, "a"],
+			[3, "a"],
+			[0, "ok", undefined],
+		]);
+	});
+
+});

data/node_modules/webpack/node_modules/uglify-js/.npmignore

@@ -0,0 +1,2 @@
+tmp/
+node_modules/

data/node_modules/webpack/node_modules/uglify-js/.travis.yml

@@ -0,0 +1,6 @@
+language: node_js
+before_install: "npm install -g npm"
+node_js:
+    - "0.8"
+    - "0.10"
+    - "0.11"

data/node_modules/webpack/node_modules/uglify-js/LICENSE

@@ -0,0 +1,29 @@
+UglifyJS is released under the BSD license:
+
+Copyright 2012-2013 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    * Redistributions of source code must retain the above
+      copyright notice, this list of conditions and the following
+      disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials
+      provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/node_modules/webpack/node_modules/uglify-js/README.md

@@ -0,0 +1,676 @@
+UglifyJS 2
+==========
+[![Build Status](https://travis-ci.org/mishoo/UglifyJS2.png)](https://travis-ci.org/mishoo/UglifyJS2)
+
+UglifyJS is a JavaScript parser, minifier, compressor or beautifier toolkit.
+
+This page documents the command line utility.  For
+[API and internals documentation see my website](http://lisperator.net/uglifyjs/).
+There's also an
+[in-browser online demo](http://lisperator.net/uglifyjs/#demo) (for Firefox,
+Chrome and probably Safari).
+
+Install
+-------
+
+First make sure you have installed the latest version of [node.js](http://nodejs.org/)
+(You may need to restart your computer after this step).
+
+From NPM for use as a command line app:
+
+    npm install uglify-js -g
+
+From NPM for programmatic use:
+
+    npm install uglify-js
+
+From Git:
+
+    git clone git://github.com/mishoo/UglifyJS2.git
+    cd UglifyJS2
+    npm link .
+
+Usage
+-----
+
+    uglifyjs [input files] [options]
+
+UglifyJS2 can take multiple input files.  It's recommended that you pass the
+input files first, then pass the options.  UglifyJS will parse input files
+in sequence and apply any compression options.  The files are parsed in the
+same global scope, that is, a reference from a file to some
+variable/function declared in another file will be matched properly.
+
+If you want to read from STDIN instead, pass a single dash instead of input
+files.
+
+The available options are:
+
+```
+  --source-map       Specify an output file where to generate source map.
+                                                                        [string]
+  --source-map-root  The path to the original source to be included in the
+                     source map.                                        [string]
+  --source-map-url   The path to the source map to be added in //#
+                     sourceMappingURL.  Defaults to the value passed with
+                     --source-map.                                      [string]
+  --source-map-include-sources
+                     Pass this flag if you want to include the content of
+                     source files in the source map as sourcesContent
+                     property.                                         [boolean]
+  --in-source-map    Input source map, useful if you're compressing JS that was
+                     generated from some other original code.
+  --screw-ie8        Pass this flag if you don't care about full compliance
+                     with Internet Explorer 6-8 quirks (by default UglifyJS
+                     will try to be IE-proof).                         [boolean]
+  --expr             Parse a single expression, rather than a program (for
+                     parsing JSON)                                     [boolean]
+  -p, --prefix       Skip prefix for original filenames that appear in source
+                     maps. For example -p 3 will drop 3 directories from file
+                     names and ensure they are relative paths. You can also
+                     specify -p relative, which will make UglifyJS figure out
+                     itself the relative paths between original sources, the
+                     source map and the output file.                    [string]
+  -o, --output       Output file (default STDOUT).
+  -b, --beautify     Beautify output/specify output options.            [string]
+  -m, --mangle       Mangle names/pass mangler options.                 [string]
+  -r, --reserved     Reserved names to exclude from mangling.
+  -c, --compress     Enable compressor/pass compressor options. Pass options
+                     like -c hoist_vars=false,if_return=false. Use -c with no
+                     argument to use the default compression options.   [string]
+  -d, --define       Global definitions                                 [string]
+  -e, --enclose      Embed everything in a big function, with a configurable
+                     parameter/argument list.                           [string]
+  --comments         Preserve copyright comments in the output. By default this
+                     works like Google Closure, keeping JSDoc-style comments
+                     that contain "@license" or "@preserve". You can optionally
+                     pass one of the following arguments to this flag:
+                     - "all" to keep all comments
+                     - a valid JS regexp (needs to start with a slash) to keep
+                     only comments that match.
+                     Note that currently not *all* comments can be kept when
+                     compression is on, because of dead code removal or
+                     cascading statements into sequences.               [string]
+  --preamble         Preamble to prepend to the output.  You can use this to
+                     insert a comment, for example for licensing information.
+                     This will not be parsed, but the source map will adjust
+                     for its presence.
+  --stats            Display operations run time on STDERR.            [boolean]
+  --acorn            Use Acorn for parsing.                            [boolean]
+  --spidermonkey     Assume input files are SpiderMonkey AST format (as JSON).
+                                                                       [boolean]
+  --self             Build itself (UglifyJS2) as a library (implies
+                     --wrap=UglifyJS --export-all)                     [boolean]
+  --wrap             Embed everything in a big function, making the “exports”
+                     and “global” variables available. You need to pass an
+                     argument to this option to specify the name that your
+                     module will take when included in, say, a browser.
+                                                                        [string]
+  --export-all       Only used when --wrap, this tells UglifyJS to add code to
+                     automatically export all globals.                 [boolean]
+  --lint             Display some scope warnings                       [boolean]
+  -v, --verbose      Verbose                                           [boolean]
+  -V, --version      Print version number and exit.                    [boolean]
+```
+
+Specify `--output` (`-o`) to declare the output file.  Otherwise the output
+goes to STDOUT.
+
+## Source map options
+
+UglifyJS2 can generate a source map file, which is highly useful for
+debugging your compressed JavaScript.  To get a source map, pass
+`--source-map output.js.map` (full path to the file where you want the
+source map dumped).
+
+Additionally you might need `--source-map-root` to pass the URL where the
+original files can be found.  In case you are passing full paths to input
+files to UglifyJS, you can use `--prefix` (`-p`) to specify the number of
+directories to drop from the path prefix when declaring files in the source
+map.
+
+For example:
+
+    uglifyjs /home/doe/work/foo/src/js/file1.js \
+             /home/doe/work/foo/src/js/file2.js \
+             -o foo.min.js \
+             --source-map foo.min.js.map \
+             --source-map-root http://foo.com/src \
+             -p 5 -c -m
+
+The above will compress and mangle `file1.js` and `file2.js`, will drop the
+output in `foo.min.js` and the source map in `foo.min.js.map`.  The source
+mapping will refer to `http://foo.com/src/js/file1.js` and
+`http://foo.com/src/js/file2.js` (in fact it will list `http://foo.com/src`
+as the source map root, and the original files as `js/file1.js` and
+`js/file2.js`).
+
+### Composed source map
+
+When you're compressing JS code that was output by a compiler such as
+CoffeeScript, mapping to the JS code won't be too helpful.  Instead, you'd
+like to map back to the original code (i.e. CoffeeScript).  UglifyJS has an
+option to take an input source map.  Assuming you have a mapping from
+CoffeeScript → compiled JS, UglifyJS can generate a map from CoffeeScript →
+compressed JS by mapping every token in the compiled JS to its original
+location.
+
+To use this feature you need to pass `--in-source-map
+/path/to/input/source.map`.  Normally the input source map should also point
+to the file containing the generated JS, so if that's correct you can omit
+input files from the command line.
+
+## Mangler options
+
+To enable the mangler you need to pass `--mangle` (`-m`).  The following
+(comma-separated) options are supported:
+
+- `sort` — to assign shorter names to most frequently used variables.  This
+  saves a few hundred bytes on jQuery before gzip, but the output is
+  _bigger_ after gzip (and seems to happen for other libraries I tried it
+  on) therefore it's not enabled by default.
+
+- `toplevel` — mangle names declared in the toplevel scope (disabled by
+  default).
+
+- `eval` — mangle names visible in scopes where `eval` or `with` are used
+  (disabled by default).
+
+When mangling is enabled but you want to prevent certain names from being
+mangled, you can declare those names with `--reserved` (`-r`) — pass a
+comma-separated list of names.  For example:
+
+    uglifyjs ... -m -r '$,require,exports'
+
+to prevent the `require`, `exports` and `$` names from being changed.
+
+## Compressor options
+
+You need to pass `--compress` (`-c`) to enable the compressor.  Optionally
+you can pass a comma-separated list of options.  Options are in the form
+`foo=bar`, or just `foo` (the latter implies a boolean option that you want
+to set `true`; it's effectively a shortcut for `foo=true`).
+
+- `sequences` -- join consecutive simple statements using the comma operator
+
+- `properties` -- rewrite property access using the dot notation, for
+  example `foo["bar"] → foo.bar`
+
+- `dead_code` -- remove unreachable code
+
+- `drop_debugger` -- remove `debugger;` statements
+
+- `unsafe` (default: false) -- apply "unsafe" transformations (discussion below)
+
+- `conditionals` -- apply optimizations for `if`-s and conditional
+  expressions
+
+- `comparisons` -- apply certain optimizations to binary nodes, for example:
+  `!(a <= b) → a > b` (only when `unsafe`), attempts to negate binary nodes,
+  e.g. `a = !b && !c && !d && !e → a=!(b||c||d||e)` etc.
+
+- `evaluate` -- attempt to evaluate constant expressions
+
+- `booleans` -- various optimizations for boolean context, for example `!!a
+  ? b : c → a ? b : c`
+
+- `loops` -- optimizations for `do`, `while` and `for` loops when we can
+  statically determine the condition
+
+- `unused` -- drop unreferenced functions and variables
+
+- `hoist_funs` -- hoist function declarations
+
+- `hoist_vars` (default: false) -- hoist `var` declarations (this is `false`
+  by default because it seems to increase the size of the output in general)
+
+- `if_return` -- optimizations for if/return and if/continue
+
+- `join_vars` -- join consecutive `var` statements
+
+- `cascade` -- small optimization for sequences, transform `x, x` into `x`
+  and `x = something(), x` into `x = something()`
+
+- `warnings` -- display warnings when dropping unreachable code or unused
+  declarations etc.
+
+- `negate_iife` -- negate "Immediately-Called Function Expressions"
+  where the return value is discarded, to avoid the parens that the
+  code generator would insert.
+
+- `pure_getters` -- the default is `false`.  If you pass `true` for
+  this, UglifyJS will assume that object property access
+  (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
+
+- `pure_funcs` -- default `null`.  You can pass an array of names and
+  UglifyJS will assume that those functions do not produce side
+  effects.  DANGER: will not check if the name is redefined in scope.
+  An example case here, for instance `var q = Math.floor(a/b)`.  If
+  variable `q` is not used elsewhere, UglifyJS will drop it, but will
+  still keep the `Math.floor(a/b)`, not knowing what it does.  You can
+  pass `pure_funcs: [ 'Math.floor' ]` to let it know that this
+  function won't produce any side effect, in which case the whole
+  statement would get discarded.  The current implementation adds some
+  overhead (compression will be slower).
+
+- `drop_console` -- default `false`.  Pass `true` to discard calls to
+  `console.*` functions.
+
+- `keep_fargs` -- default `false`.  Pass `true` to prevent the
+  compressor from discarding unused function arguments.  You need this
+  for code which relies on `Function.length`.
+
+### The `unsafe` option
+
+It enables some transformations that *might* break code logic in certain
+contrived cases, but should be fine for most code.  You might want to try it
+on your own code, it should reduce the minified size.  Here's what happens
+when this flag is on:
+
+- `new Array(1, 2, 3)` or `Array(1, 2, 3)` → `[1, 2, 3 ]`
+- `new Object()` → `{}`
+- `String(exp)` or `exp.toString()` → `"" + exp`
+- `new Object/RegExp/Function/Error/Array (...)` → we discard the `new`
+- `typeof foo == "undefined"` → `foo === void 0`
+- `void 0` → `undefined` (if there is a variable named "undefined" in
+  scope; we do it because the variable name will be mangled, typically
+  reduced to a single character).
+
+### Conditional compilation
+
+You can use the `--define` (`-d`) switch in order to declare global
+variables that UglifyJS will assume to be constants (unless defined in
+scope).  For example if you pass `--define DEBUG=false` then, coupled with
+dead code removal UglifyJS will discard the following from the output:
+```javascript
+if (DEBUG) {
+	console.log("debug stuff");
+}
+```
+
+UglifyJS will warn about the condition being always false and about dropping
+unreachable code; for now there is no option to turn off only this specific
+warning, you can pass `warnings=false` to turn off *all* warnings.
+
+Another way of doing that is to declare your globals as constants in a
+separate file and include it into the build.  For example you can have a
+`build/defines.js` file with the following:
+```javascript
+const DEBUG = false;
+const PRODUCTION = true;
+// etc.
+```
+
+and build your code like this:
+
+    uglifyjs build/defines.js js/foo.js js/bar.js... -c
+
+UglifyJS will notice the constants and, since they cannot be altered, it
+will evaluate references to them to the value itself and drop unreachable
+code as usual.  The possible downside of this approach is that the build
+will contain the `const` declarations.
+
+<a name="codegen-options"></a>
+## Beautifier options
+
+The code generator tries to output shortest code possible by default.  In
+case you want beautified output, pass `--beautify` (`-b`).  Optionally you
+can pass additional arguments that control the code output:
+
+- `beautify` (default `true`) -- whether to actually beautify the output.
+  Passing `-b` will set this to true, but you might need to pass `-b` even
+  when you want to generate minified code, in order to specify additional
+  arguments, so you can use `-b beautify=false` to override it.
+- `indent-level` (default 4)
+- `indent-start` (default 0) -- prefix all lines by that many spaces
+- `quote-keys` (default `false`) -- pass `true` to quote all keys in literal
+  objects
+- `space-colon` (default `true`) -- insert a space after the colon signs
+- `ascii-only` (default `false`) -- escape Unicode characters in strings and
+  regexps
+- `inline-script` (default `false`) -- escape the slash in occurrences of
+  `</script` in strings
+- `width` (default 80) -- only takes effect when beautification is on, this
+  specifies an (orientative) line width that the beautifier will try to
+  obey.  It refers to the width of the line text (excluding indentation).
+  It doesn't work very well currently, but it does make the code generated
+  by UglifyJS more readable.
+- `max-line-len` (default 32000) -- maximum line length (for uglified code)
+- `bracketize` (default `false`) -- always insert brackets in `if`, `for`,
+  `do`, `while` or `with` statements, even if their body is a single
+  statement.
+- `semicolons` (default `true`) -- separate statements with semicolons.  If
+  you pass `false` then whenever possible we will use a newline instead of a
+  semicolon, leading to more readable output of uglified code (size before
+  gzip could be smaller; size after gzip insignificantly larger).
+- `preamble` (default `null`) -- when passed it must be a string and
+  it will be prepended to the output literally.  The source map will
+  adjust for this text.  Can be used to insert a comment containing
+  licensing information, for example.
+
+### Keeping copyright notices or other comments
+
+You can pass `--comments` to retain certain comments in the output.  By
+default it will keep JSDoc-style comments that contain "@preserve",
+"@license" or "@cc_on" (conditional compilation for IE).  You can pass
+`--comments all` to keep all the comments, or a valid JavaScript regexp to
+keep only comments that match this regexp.  For example `--comments
+'/foo|bar/'` will keep only comments that contain "foo" or "bar".
+
+Note, however, that there might be situations where comments are lost.  For
+example:
+```javascript
+function f() {
+	/** @preserve Foo Bar */
+	function g() {
+	  // this function is never called
+	}
+	return something();
+}
+```
+
+Even though it has "@preserve", the comment will be lost because the inner
+function `g` (which is the AST node to which the comment is attached to) is
+discarded by the compressor as not referenced.
+
+The safest comments where to place copyright information (or other info that
+needs to be kept in the output) are comments attached to toplevel nodes.
+
+## Support for the SpiderMonkey AST
+
+UglifyJS2 has its own abstract syntax tree format; for
+[practical reasons](http://lisperator.net/blog/uglifyjs-why-not-switching-to-spidermonkey-ast/)
+we can't easily change to using the SpiderMonkey AST internally.  However,
+UglifyJS now has a converter which can import a SpiderMonkey AST.
+
+For example [Acorn][acorn] is a super-fast parser that produces a
+SpiderMonkey AST.  It has a small CLI utility that parses one file and dumps
+the AST in JSON on the standard output.  To use UglifyJS to mangle and
+compress that:
+
+    acorn file.js | uglifyjs --spidermonkey -m -c
+
+The `--spidermonkey` option tells UglifyJS that all input files are not
+JavaScript, but JS code described in SpiderMonkey AST in JSON.  Therefore we
+don't use our own parser in this case, but just transform that AST into our
+internal AST.
+
+### Use Acorn for parsing
+
+More for fun, I added the `--acorn` option which will use Acorn to do all
+the parsing.  If you pass this option, UglifyJS will `require("acorn")`.
+
+Acorn is really fast (e.g. 250ms instead of 380ms on some 650K code), but
+converting the SpiderMonkey tree that Acorn produces takes another 150ms so
+in total it's a bit more than just using UglifyJS's own parser.
+
+### Using UglifyJS to transform SpiderMonkey AST
+
+Now you can use UglifyJS as any other intermediate tool for transforming
+JavaScript ASTs in SpiderMonkey format.
+
+Example:
+
+```javascript
+function uglify(ast, options, mangle) {
+  // Conversion from SpiderMonkey AST to internal format
+  var uAST = UglifyJS.AST_Node.from_mozilla_ast(ast);
+
+  // Compression
+  uAST.figure_out_scope();
+  uAST = uAST.transform(UglifyJS.Compressor(options));
+
+  // Mangling (optional)
+  if (mangle) {
+    uAST.figure_out_scope();
+    uAST.compute_char_frequency();
+    uAST.mangle_names();
+  }
+
+  // Back-conversion to SpiderMonkey AST
+  return uAST.to_mozilla_ast();
+}
+```
+
+Check out
+[original blog post](http://rreverser.com/using-mozilla-ast-with-uglifyjs/)
+for details.
+
+API Reference
+-------------
+
+Assuming installation via NPM, you can load UglifyJS in your application
+like this:
+```javascript
+var UglifyJS = require("uglify-js");
+```
+
+It exports a lot of names, but I'll discuss here the basics that are needed
+for parsing, mangling and compressing a piece of code.  The sequence is (1)
+parse, (2) compress, (3) mangle, (4) generate output code.
+
+### The simple way
+
+There's a single toplevel function which combines all the steps.  If you
+don't need additional customization, you might want to go with `minify`.
+Example:
+```javascript
+var result = UglifyJS.minify("/path/to/file.js");
+console.log(result.code); // minified output
+// if you need to pass code instead of file name
+var result = UglifyJS.minify("var b = function () {};", {fromString: true});
+```
+
+You can also compress multiple files:
+```javascript
+var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ]);
+console.log(result.code);
+```
+
+To generate a source map:
+```javascript
+var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ], {
+	outSourceMap: "out.js.map"
+});
+console.log(result.code); // minified output
+console.log(result.map);
+```
+
+Note that the source map is not saved in a file, it's just returned in
+`result.map`.  The value passed for `outSourceMap` is only used to set the
+`file` attribute in the source map (see [the spec][sm-spec]).
+
+You can also specify sourceRoot property to be included in source map:
+```javascript
+var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ], {
+	outSourceMap: "out.js.map",
+	sourceRoot: "http://example.com/src"
+});
+```
+
+If you're compressing compiled JavaScript and have a source map for it, you
+can use the `inSourceMap` argument:
+```javascript
+var result = UglifyJS.minify("compiled.js", {
+	inSourceMap: "compiled.js.map",
+	outSourceMap: "minified.js.map"
+});
+// same as before, it returns `code` and `map`
+```
+
+The `inSourceMap` is only used if you also request `outSourceMap` (it makes
+no sense otherwise).
+
+Other options:
+
+- `warnings` (default `false`) — pass `true` to display compressor warnings.
+
+- `fromString` (default `false`) — if you pass `true` then you can pass
+  JavaScript source code, rather than file names.
+
+- `mangle` — pass `false` to skip mangling names.
+
+- `output` (default `null`) — pass an object if you wish to specify
+  additional [output options][codegen].  The defaults are optimized
+  for best compression.
+
+- `compress` (default `{}`) — pass `false` to skip compressing entirely.
+  Pass an object to specify custom [compressor options][compressor].
+
+We could add more options to `UglifyJS.minify` — if you need additional
+functionality please suggest!
+
+### The hard way
+
+Following there's more detailed API info, in case the `minify` function is
+too simple for your needs.
+
+#### The parser
+```javascript
+var toplevel_ast = UglifyJS.parse(code, options);
+```
+
+`options` is optional and if present it must be an object.  The following
+properties are available:
+
+- `strict` — disable automatic semicolon insertion and support for trailing
+  comma in arrays and objects
+- `filename` — the name of the file where this code is coming from
+- `toplevel` — a `toplevel` node (as returned by a previous invocation of
+  `parse`)
+
+The last two options are useful when you'd like to minify multiple files and
+get a single file as the output and a proper source map.  Our CLI tool does
+something like this:
+```javascript
+var toplevel = null;
+files.forEach(function(file){
+	var code = fs.readFileSync(file, "utf8");
+	toplevel = UglifyJS.parse(code, {
+		filename: file,
+		toplevel: toplevel
+	});
+});
+```
+
+After this, we have in `toplevel` a big AST containing all our files, with
+each token having proper information about where it came from.
+
+#### Scope information
+
+UglifyJS contains a scope analyzer that you need to call manually before
+compressing or mangling.  Basically it augments various nodes in the AST
+with information about where is a name defined, how many times is a name
+referenced, if it is a global or not, if a function is using `eval` or the
+`with` statement etc.  I will discuss this some place else, for now what's
+important to know is that you need to call the following before doing
+anything with the tree:
+```javascript
+toplevel.figure_out_scope()
+```
+
+#### Compression
+
+Like this:
+```javascript
+var compressor = UglifyJS.Compressor(options);
+var compressed_ast = toplevel.transform(compressor);
+```
+
+The `options` can be missing.  Available options are discussed above in
+“Compressor options”.  Defaults should lead to best compression in most
+scripts.
+
+The compressor is destructive, so don't rely that `toplevel` remains the
+original tree.
+
+#### Mangling
+
+After compression it is a good idea to call again `figure_out_scope` (since
+the compressor might drop unused variables / unreachable code and this might
+change the number of identifiers or their position).  Optionally, you can
+call a trick that helps after Gzip (counting character frequency in
+non-mangleable words).  Example:
+```javascript
+compressed_ast.figure_out_scope();
+compressed_ast.compute_char_frequency();
+compressed_ast.mangle_names();
+```
+
+#### Generating output
+
+AST nodes have a `print` method that takes an output stream.  Essentially,
+to generate code you do this:
+```javascript
+var stream = UglifyJS.OutputStream(options);
+compressed_ast.print(stream);
+var code = stream.toString(); // this is your minified code
+```
+
+or, for a shortcut you can do:
+```javascript
+var code = compressed_ast.print_to_string(options);
+```
+
+As usual, `options` is optional.  The output stream accepts a lot of otions,
+most of them documented above in section “Beautifier options”.  The two
+which we care about here are `source_map` and `comments`.
+
+#### Keeping comments in the output
+
+In order to keep certain comments in the output you need to pass the
+`comments` option.  Pass a RegExp or a function.  If you pass a RegExp, only
+those comments whose body matches the regexp will be kept.  Note that body
+means without the initial `//` or `/*`.  If you pass a function, it will be
+called for every comment in the tree and will receive two arguments: the
+node that the comment is attached to, and the comment token itself.
+
+The comment token has these properties:
+
+- `type`: "comment1" for single-line comments or "comment2" for multi-line
+  comments
+- `value`: the comment body
+- `pos` and `endpos`: the start/end positions (zero-based indexes) in the
+  original code where this comment appears
+- `line` and `col`: the line and column where this comment appears in the
+  original code
+- `file` — the file name of the original file
+- `nlb` — true if there was a newline before this comment in the original
+  code, or if this comment contains a newline.
+
+Your function should return `true` to keep the comment, or a falsy value
+otherwise.
+
+#### Generating a source mapping
+
+You need to pass the `source_map` argument when calling `print`.  It needs
+to be a `SourceMap` object (which is a thin wrapper on top of the
+[source-map][source-map] library).
+
+Example:
+```javascript
+var source_map = UglifyJS.SourceMap(source_map_options);
+var stream = UglifyJS.OutputStream({
+	...
+	source_map: source_map
+});
+compressed_ast.print(stream);
+
+var code = stream.toString();
+var map = source_map.toString(); // json output for your source map
+```
+
+The `source_map_options` (optional) can contain the following properties:
+
+- `file`: the name of the JavaScript output file that this mapping refers to
+- `root`: the `sourceRoot` property (see the [spec][sm-spec])
+- `orig`: the "original source map", handy when you compress generated JS
+  and want to map the minified output back to the original code where it
+  came from.  It can be simply a string in JSON, or a JSON object containing
+  the original source map.
+
+  [acorn]: https://github.com/marijnh/acorn
+  [source-map]: https://github.com/mozilla/source-map
+  [sm-spec]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+  [codegen]: http://lisperator.net/uglifyjs/codegen
+  [compressor]: http://lisperator.net/uglifyjs/compress