node_modules

48 files changed, 8738 insertions, 13111 deletions

diff --git a/node_modules/uglify-js/README.md b/node_modules/uglify-js/README.md
index 8c1d67642..8db77e57e 100644
--- a/node_modules/uglify-js/README.md
+++ b/node_modules/uglify-js/README.md
@@ -1,20 +1,14 @@
-UglifyJS 2
+UglifyJS 3
 ==========
-[![Build Status](https://travis-ci.org/mishoo/UglifyJS2.svg)](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).
+UglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.
 
 #### Note:
+- **`uglify-js@3` has a simplified [API](#api-reference) and [CLI](#command-line-usage) that is not backwards compatible with [`uglify-js@2`](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
+- **Documentation for UglifyJS `2.x` releases can be found [here](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
 - `uglify-js` only supports ECMAScript 5 (ES5).
-- Support for `const` is [present but incomplete](#support-for-const), and may not be
-  transformed properly.
-- Those wishing to minify ES2015+ (ES6+) should use the `npm` package [**uglify-es**](https://github.com/mishoo/UglifyJS2/tree/harmony).
+- Those wishing to minify
+ES2015+ (ES6+) should use the `npm` package [**uglify-es**](https://github.com/mishoo/UglifyJS2/tree/harmony).
 
 Install
 -------
@@ -30,70 +24,74 @@ From NPM for programmatic use:
 
     npm install uglify-js
 
-Usage
------
+# Command line usage
 
     uglifyjs [input files] [options]
 
-UglifyJS2 can take multiple input files.  It's recommended that you pass the
+UglifyJS 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.
+If no input file is specified, UglifyJS will read from STDIN.
 
 If you wish to pass your options before the input files, separate the two with
 a double dash to prevent input files being used as option arguments:
 
     uglifyjs --compress --mangle -- input.js
 
-The available options are:
-
-```
-  --source-map                  Specify an output file where to generate source
-                                map.
-  --source-map-root             The path to the original source to be included
-                                in the source map.
-  --source-map-url              The path to the source map to be added in //#
-                                sourceMappingURL.  Defaults to the value passed
-                                with --source-map.
-  --source-map-include-sources  Pass this flag if you want to include the
-                                content of source files in the source map as
-                                sourcesContent property.
-  --source-map-inline           Write base64-encoded source map to the end of js output.
-  --in-source-map               Input source map, useful if you're compressing
-                                JS that was generated from some other original
-                                code. Specify "inline" if the source map is included
-                                inline with the sources.
-  --screw-ie8                   Use this flag if you don't wish to support
-                                Internet Explorer 6/7/8.
-                                By default UglifyJS will not try to be IE-proof.
-  --support-ie8                 Use this flag to support Internet Explorer 6/7/8.
-                                Equivalent to setting `screw_ie8: false` in `minify()`
-                                for `compress`, `mangle` and `output` options.
-  --expr                        Parse a single expression, rather than a
-                                program (for parsing JSON)
-  -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.
-  -o, --output                  Output file (default STDOUT).
-  -b, --beautify                Beautify output/specify output options.
-  -m, --mangle                  Mangle names/pass mangler options.
-  -r, --reserved                Reserved names to exclude from mangling.
-  -c, --compress                Enable compressor/pass compressor options, e.g.
-                                `-c 'if_return=false,pure_funcs=["Math.pow","console.log"]'`
-                                Use `-c` with no argument to enable default compression
-                                options.
-  -d, --define                  Global definitions
-  -e, --enclose                 Embed everything in a big function, with a
-                                configurable parameter/argument list.
-  --comments                    Preserve copyright comments in the output. By
+### Command line options
+
+```
+    -h, --help                  Print usage information.
+                                `--help options` for details on available options.
+    -V, --version               Print version number.
+    -p, --parse <options>       Specify parser options:
+                                `acorn`  Use Acorn for parsing.
+                                `bare_returns`  Allow return outside of functions.
+                                                Useful when minifying CommonJS
+                                                modules and Userscripts that may
+                                                be anonymous function wrapped (IIFE)
+                                                by the .user.js engine `caller`.
+                                `expression`  Parse a single expression, rather than
+                                              a program (for parsing JSON).
+                                `spidermonkey`  Assume input files are SpiderMonkey
+                                                AST format (as JSON).
+    -c, --compress [options]    Enable compressor/specify compressor options:
+                                `pure_funcs`  List of functions that can be safely
+                                              removed when their return values are
+                                              not used.
+    -m, --mangle [options]      Mangle names/specify mangler options:
+                                `reserved`  List of names that should not be mangled.
+    --mangle-props [options]    Mangle properties/specify mangler options:
+                                `builtins`  Mangle property names that overlaps
+                                            with standard JavaScript globals.
+                                `debug`  Add debug prefix and suffix.
+                                `domprops`  Mangle property names that overlaps
+                                            with DOM properties.
+                                `keep_quoted`  Only mangle unquoted properies.
+                                `regex`  Only mangle matched property names.
+                                `reserved`  List of names that should not be mangled.
+    -b, --beautify [options]    Beautify output/specify output options:
+                                `beautify`  Enabled with `--beautify` by default.
+                                `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.
+                                `quote_style`  Quote style:
+                                               0 - auto
+                                               1 - single
+                                               2 - double
+                                               3 - original
+                                `wrap_iife`  Wrap IIFEs in parenthesis. Note: you may
+                                             want to disable `negate_iife` under
+                                             compressor options.
+    -o, --output <file>         Output file path (default STDOUT). Specify `ast` or
+                                `spidermonkey` to write UglifyJS or SpiderMonkey AST
+                                as JSON to STDOUT respectively.
+    --comments [filter]         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
@@ -105,80 +103,66 @@ The available options are:
                                 kept when compression is on, because of dead
                                 code removal or cascading statements into
                                 sequences.
-  --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.
-  --acorn                       Use Acorn for parsing.
-  --spidermonkey                Assume input files are SpiderMonkey AST format
-                                (as JSON).
-  --self                        Build itself (UglifyJS2) as a library (implies
-                                --wrap=UglifyJS --export-all)
-  --wrap                        Embed everything in a big function, making the
+    --config-file <file>        Read `minify()` options from JSON file.
+    -d, --define <expr>[=value] Global definitions.
+    --ie8                       Support non-standard Internet Explorer 8.
+                                Equivalent to setting `ie8: true` in `minify()`
+                                for `compress`, `mangle` and `output` options.
+                                By default UglifyJS will not try to be IE-proof.
+    --keep-fnames               Do not mangle/drop function names.  Useful for
+                                code relying on Function.prototype.name.
+    --name-cache <file>         File to hold mangled name mappings.
+    --self                      Build UglifyJS as a library (implies --wrap UglifyJS)
+    --source-map [options]      Enable source map/specify source map options:
+                                `base`  Path to compute relative paths from input files.
+                                `content`  Input source map, useful if you're compressing
+                                           JS that was generated from some other original
+                                           code. Specify "inline" if the source map is
+                                           included within the sources.
+                                `filename`  Name and/or location of the output source.
+                                `includeSources`  Pass this flag if you want to include
+                                                  the content of source files in the
+                                                  source map as sourcesContent property.
+                                `root`  Path to the original source to be included in
+                                        the source map.
+                                `url`  If specified, path to the source map to append in
+                                       `//# sourceMappingURL`.
+    --timings                   Display operations run time on STDERR.
+    --toplevel                  Compress and/or mangle variables in top level scope.
+    --verbose                   Print diagnostic messages.
+    --warn                      Print warning messages.
+    --wrap <name>               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.
-  --export-all                  Only used when --wrap, this tells UglifyJS to
-                                add code to automatically export all globals.
-  --lint                        Display some scope warnings
-  -v, --verbose                 Verbose
-  -V, --version                 Print version number and exit.
-  --noerr                       Don't throw an error for unknown options in -c,
-                                -b or -m.
-  --bare-returns                Allow return outside of functions.  Useful when
-                                minifying CommonJS modules and Userscripts that
-                                may be anonymous function wrapped (IIFE) by the
-                                .user.js engine `caller`.
-  --keep-fnames                 Do not mangle/drop function names.  Useful for
-                                code relying on Function.prototype.name.
-  --reserved-file               File containing reserved names
-  --reserve-domprops            Make (most?) DOM properties reserved for
-                                --mangle-props
-  --mangle-props                Mangle property names (default `0`). Set to
-                                `true` or `1` to mangle all property names. Set
-                                to `unquoted` or `2` to only mangle unquoted
-                                property names. Mode `2` also enables the
-                                `keep_quoted_props` beautifier option to
-                                preserve the quotes around property names and
-                                disables the `properties` compressor option to
-                                prevent rewriting quoted properties with dot
-                                notation. You can override these by setting
-                                them explicitly on the command line.
-  --mangle-regex                Only mangle property names matching the regex
-  --name-cache                  File to hold mangled names mappings
-  --pure-funcs                  Functions that can be safely removed if their
-                                return value is not used, e.g.
-                                `--pure-funcs Math.floor console.info`
-                                (requires `--compress`)
 ```
 
 Specify `--output` (`-o`) to declare the output file.  Otherwise the output
 goes to STDOUT.
 
-## Source map options
+## CLI source map options
 
-UglifyJS2 can generate a source map file, which is highly useful for
+UglifyJS 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).
+`--source-map --output output.js` (source map will be written out to
+`output.js.map`).
+
+Additional options:
+
+- `--source-map filename=<NAME>` to specify the name of the source map.
 
-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.
+- `--source-map root=<URL>` to pass the URL where the original files can be found.
+  Otherwise UglifyJS assumes HTTP `X-SourceMap` is being used and will omit the
+  `//# sourceMappingURL=` directive.
+
+- `--source-map url=<URL>` to specify the URL where the source map can be found.
 
 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
+    uglifyjs js/file1.js js/file2.js \
+             -o foo.min.js -c -m \
+             --source-map root="http://foo.com/src",url=foo.min.js.map
 
 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
@@ -197,90 +181,114 @@ 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` or `--in-source-map inline` if the source map is
-included inline with the sources. 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.
+To use this feature pass `--source-map content="/path/to/input/source.map"`
+or `--source-map content=inline` if the source map is included inline with
+the sources.
+
+## CLI compress options
 
-## Mangler options
+You need to pass `--compress` (`-c`) to enable the compressor.  Optionally
+you can pass a comma-separated list of [compress options](#compress-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`).
+
+Example:
+
+    uglifyjs file.js -c toplevel,sequences=false
+
+## CLI mangle options
 
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
 
-- `toplevel` — mangle names declared in the toplevel scope (disabled by
+- `toplevel` — mangle names declared in the top level 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
+mangled, you can declare those names with `--mangle reserved` — pass a
 comma-separated list of names.  For example:
 
-    uglifyjs ... -m -r '$,require,exports'
+    uglifyjs ... -m reserved=[$,require,exports]
 
 to prevent the `require`, `exports` and `$` names from being changed.
 
-### Mangling property names (`--mangle-props`)
+### CLI mangling property names (`--mangle-props`)
 
-**Note:** this will probably break your code.  Mangling property names is a
-separate step, different from variable name mangling.  Pass
-`--mangle-props`.  It will mangle all properties that are seen in some
-object literal, or that are assigned to.  For example:
+**Note:** THIS WILL PROBABLY BREAK YOUR CODE.  Mangling property names
+is a separate step, different from variable name mangling.  Pass
+`--mangle-props` to enable it.  It will mangle all properties in the
+input code with the exception of built in DOM properties and properties
+in core javascript classes.  For example:
 
-```js
+```javascript
+// example.js
 var x = {
-  foo: 1
+    baz_: 0,
+    foo_: 1,
+    calc: function() {
+        return this.foo_ + this.baz_;
+    }
 };
-
-x.bar = 2;
-x["baz"] = 3;
-x[condition ? "moo" : "boo"] = 4;
-console.log(x.something());
+x.bar_ = 2;
+x["baz_"] = 3;
+console.log(x.calc());
+```
+Mangle all properties (except for javascript `builtins`):
+```bash
+$ uglifyjs example.js -c -m --mangle-props
+```
+```javascript
+var x={o:0,_:1,l:function(){return this._+this.o}};x.t=2,x.o=3,console.log(x.l());
+```
+Mangle all properties except for `reserved` properties:
+```bash
+$ uglifyjs example.js -c -m --mangle-props reserved=[foo_,bar_]
+```
+```javascript
+var x={o:0,foo_:1,_:function(){return this.foo_+this.o}};x.bar_=2,x.o=3,console.log(x._());
+```
+Mangle all properties matching a `regex`:
+```bash
+$ uglifyjs example.js -c -m --mangle-props regex=/_$/
+```
+```javascript
+var x={o:0,_:1,calc:function(){return this._+this.o}};x.l=2,x.o=3,console.log(x.calc());
 ```
 
-In the above code, `foo`, `bar`, `baz`, `moo` and `boo` will be replaced
-with single characters, while `something()` will be left as is.
-
-In order for this to be of any use, we should avoid mangling standard JS
-names.  For instance, if your code would contain `x.length = 10`, then
-`length` becomes a candidate for mangling and it will be mangled throughout
-the code, regardless if it's being used as part of your own objects or
-accessing an array's length.  To avoid that, you can use `--reserved-file`
-to pass a filename that should contain the names to be excluded from
-mangling.  This file can be used both for excluding variable names and
-property names.  It could look like this, for example:
-
-```js
-{
-  "vars": [ "define", "require", ... ],
-  "props": [ "length", "prototype", ... ]
-}
+Combining mangle properties options:
+```bash
+$ uglifyjs example.js -c -m --mangle-props regex=/_$/,reserved=[bar_]
+```
+```javascript
+var x={o:0,_:1,calc:function(){return this._+this.o}};x.bar_=2,x.o=3,console.log(x.calc());
 ```
 
-`--reserved-file` can be an array of file names (either a single
-comma-separated argument, or you can pass multiple `--reserved-file`
-arguments) — in this case it will exclude names from all those files.
+In order for this to be of any use, we avoid mangling standard JS names by
+default (`--mangle-props builtins` to override).
 
 A default exclusion file is provided in `tools/domprops.json` which should
 cover most standard JS and DOM properties defined in various browsers.  Pass
-`--reserve-domprops` to read that in.
+`--mangle-props domprops` to disable this feature.
 
-You can also use a regular expression to define which property names should be
-mangled.  For example, `--mangle-regex="/^_/"` will only mangle property names
-that start with an underscore.
+A regular expression can be used to define which property names should be
+mangled.  For example, `--mangle-props regex=/^_/` will only mangle property
+names that start with an underscore.
 
 When you compress multiple files using this option, in order for them to
 work together in the end we need to ensure somehow that one property gets
-mangled to the same name in all of them.  For this, pass `--name-cache
-filename.json` and UglifyJS will maintain these mappings in a file which can
-then be reused.  It should be initially empty.  Example:
-
-```
-rm -f /tmp/cache.json  # start fresh
-uglifyjs file1.js file2.js --mangle-props --name-cache /tmp/cache.json -o part1.js
-uglifyjs file3.js file4.js --mangle-props --name-cache /tmp/cache.json -o part2.js
+mangled to the same name in all of them.  For this, pass `--name-cache filename.json`
+and UglifyJS will maintain these mappings in a file which can then be reused.
+It should be initially empty.  Example:
+
+```bash
+$ rm -f /tmp/cache.json  # start fresh
+$ uglifyjs file1.js file2.js --mangle-props --name-cache /tmp/cache.json -o part1.js
+$ uglifyjs file3.js file4.js --mangle-props --name-cache /tmp/cache.json -o part2.js
 ```
 
 Now, `part1.js` and `part2.js` will be consistent with each other in terms
@@ -289,38 +297,303 @@ of mangled property names.
 Using the name cache is not necessary if you compress all your files in a
 single call to UglifyJS.
 
-#### Mangling unquoted names (`--mangle-props=unquoted` or `--mangle-props=2`)
+### Mangling unquoted names (`--mangle-props keep_quoted`)
 
 Using quoted property name (`o["foo"]`) reserves the property name (`foo`)
 so that it is not mangled throughout the entire script even when used in an
 unquoted style (`o.foo`). Example:
 
+```javascript
+// stuff.js
+var o = {
+    "foo": 1,
+    bar: 3
+};
+o.foo += o.bar;
+console.log(o.foo);
 ```
-$ echo 'var o={"foo":1, bar:3}; o.foo += o.bar; console.log(o.foo);' | uglifyjs --mangle-props=2 -mc
-var o={"foo":1,a:3};o.foo+=o.a,console.log(o.foo);
+```bash
+$ uglifyjs stuff.js --mangle-props keep_quoted -c -m
+```
+```javascript
+var o={foo:1,o:3};o.foo+=o.o,console.log(o.foo);
 ```
 
-#### Debugging property name mangling
+### Debugging property name mangling
 
-You can also pass `--mangle-props-debug` in order to mangle property names
+You can also pass `--mangle-props debug` in order to mangle property names
 without completely obscuring them. For example the property `o.foo`
 would mangle to `o._$foo$_` with this option. This allows property mangling
 of a large codebase while still being able to debug the code and identify
 where mangling is breaking things.
 
-You can also pass a custom suffix using `--mangle-props-debug=XYZ`. This would then
+```bash
+$ uglifyjs stuff.js --mangle-props debug -c -m
+```
+```javascript
+var o={_$foo$_:1,_$bar$_:3};o._$foo$_+=o._$bar$_,console.log(o._$foo$_);
+```
+
+You can also pass a custom suffix using `--mangle-props debug=XYZ`. This would then
 mangle `o.foo` to `o._$foo$XYZ_`. You can change this each time you compile a
 script to identify how a property got mangled. One technique is to pass a
 random number on every compile to simulate mangling changing with different
 inputs (e.g. as you update the input script with new properties), and to help
 identify mistakes like writing mangled keys to storage.
 
-## 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`).
+# API Reference
+
+Assuming installation via NPM, you can load UglifyJS in your application
+like this:
+```javascript
+var UglifyJS = require("uglify-js");
+```
+
+There is a single high level function, **`minify(code, options)`**,
+which will perform all minification [phases](#minify-options) in a configurable
+manner. By default `minify()` will enable the options [`compress`](#compress-options)
+and [`mangle`](#mangle-options). Example:
+```javascript
+var code = "function add(first, second) { return first + second; }";
+var result = UglifyJS.minify(code);
+console.log(result.error); // runtime error, or `undefined` if no error
+console.log(result.code);  // minified output: function add(n,d){return n+d}
+```
+
+You can `minify` more than one JavaScript file at a time by using an object
+for the first argument where the keys are file names and the values are source
+code:
+```javascript
+var code = {
+    "file1.js": "function add(first, second) { return first + second; }",
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+};
+var result = UglifyJS.minify(code);
+console.log(result.code);
+// function add(d,n){return d+n}console.log(add(3,7));
+```
+
+The `toplevel` option:
+```javascript
+var code = {
+    "file1.js": "function add(first, second) { return first + second; }",
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+};
+var options = { toplevel: true };
+var result = UglifyJS.minify(code, options);
+console.log(result.code);
+// console.log(3+7);
+```
+
+The `nameCache` option:
+```javascript
+var options = {
+    mangle: {
+        toplevel: true,
+    },
+    nameCache: {}
+};
+var result1 = UglifyJS.minify({
+    "file1.js": "function add(first, second) { return first + second; }"
+}, options);
+var result2 = UglifyJS.minify({
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+}, options);
+console.log(result1.code);
+// function n(n,r){return n+r}
+console.log(result2.code);
+// console.log(n(3,7));
+```
+
+You may persist the name cache to the file system in the following way:
+```javascript
+var cacheFileName = "/tmp/cache.json";
+var options = {
+    mangle: {
+        properties: true,
+    },
+    nameCache: JSON.parse(fs.readFileSync(cacheFileName, "utf8"))
+};
+fs.writeFileSync("part1.js", UglifyJS.minify({
+    "file1.js": fs.readFileSync("file1.js", "utf8"),
+    "file2.js": fs.readFileSync("file2.js", "utf8")
+}, options).code, "utf8");
+fs.writeFileSync("part2.js", UglifyJS.minify({
+    "file3.js": fs.readFileSync("file3.js", "utf8"),
+    "file4.js": fs.readFileSync("file4.js", "utf8")
+}, options).code, "utf8");
+fs.writeFileSync(cacheFileName, JSON.stringify(options.nameCache), "utf8");
+```
+
+An example of a combination of `minify()` options:
+```javascript
+var code = {
+    "file1.js": "function add(first, second) { return first + second; }",
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+};
+var options = {
+    toplevel: true,
+    compress: {
+        global_defs: {
+            "@console.log": "alert"
+        },
+        passes: 2
+    },
+    output: {
+        beautify: false,
+        preamble: "/* uglified */"
+    }
+};
+var result = UglifyJS.minify(code, options);
+console.log(result.code);
+// /* uglified */
+// alert(10);"
+```
+
+To produce warnings:
+```javascript
+var code = "function f(){ var u; return 2 + 3; }";
+var options = { warnings: true };
+var result = UglifyJS.minify(code, options);
+console.log(result.error);    // runtime error, `undefined` in this case
+console.log(result.warnings); // [ 'Dropping unused variable u [0:1,18]' ]
+console.log(result.code);     // function f(){return 5}
+```
+
+An error example:
+```javascript
+var result = UglifyJS.minify({"foo.js" : "if (0) else console.log(1);"});
+console.log(JSON.stringify(result.error));
+// {"message":"Unexpected token: keyword (else)","filename":"foo.js","line":1,"col":7,"pos":7}
+```
+Note: unlike `uglify-js@2.x`, the `3.x` API does not throw errors. To
+achieve a similar effect one could do the following:
+```javascript
+var result = UglifyJS.minify(code, options);
+if (result.error) throw result.error;
+```
+
+## Minify options
+
+- `warnings` (default `false`) — pass `true` to return compressor warnings
+  in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
+
+- `parse` (default `{}`) — pass an object if you wish to specify some
+  additional [parse options](#parse-options).
+
+- `compress` (default `{}`) — pass `false` to skip compressing entirely.
+  Pass an object to specify custom [compress options](#compress-options).
+
+- `mangle` (default `true`) — pass `false` to skip mangling names, or pass
+  an object to specify [mangle options](#mangle-options) (see below).
+
+  - `mangle.properties` (default `false`) — a subcategory of the mangle option.
+    Pass an object to specify custom [mangle property options](#mangle-properties-options).
+
+- `output` (default `null`) — pass an object if you wish to specify
+  additional [output options](#output-options).  The defaults are optimized
+  for best compression.
+
+- `sourceMap` (default `false`) - pass an object if you wish to specify
+  [source map options](#source-map-options).
+
+- `toplevel` (default `false`) - set to `true` if you wish to enable top level
+  variable and function name mangling and to drop unused variables and functions.
+
+- `nameCache` (default `null`) - pass an empty object `{}` or a previously
+  used `nameCache` object if you wish to cache mangled variable and
+  property names across multiple invocations of `minify()`. Note: this is
+  a read/write property. `minify()` will read the name cache state of this
+  object and update it during minification so that it may be
+  reused or externally persisted by the user.
+
+- `ie8` (default `false`) - set to `true` to support IE8.
+
+## Minify options structure
+
+```javascript
+{
+    warnings: false,
+    parse: {
+        // parse options
+    },
+    compress: {
+        // compress options
+    },
+    mangle: {
+        // mangle options
+
+        properties: {
+            // mangle property options
+        }
+    },
+    output: {
+        // output options
+    },
+    sourceMap: {
+        // source map options
+    },
+    nameCache: null, // or specify a name cache object
+    toplevel: false,
+    ie8: false,
+}
+```
+
+### Source map options
+
+To generate a source map:
+```javascript
+var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
+    sourceMap: {
+        filename: "out.js",
+        url: "out.js.map"
+    }
+});
+console.log(result.code); // minified output
+console.log(result.map);  // source map
+```
+
+Note that the source map is not saved in a file, it's just returned in
+`result.map`.  The value passed for `sourceMap.url` is only used to set
+`//# sourceMappingURL=out.js.map` in `result.code`. The value of
+`filename` is only used to set `file` attribute (see [the spec][sm-spec])
+in source map file.
+
+You can set option `sourceMap.url` to be `"inline"` and source map will
+be appended to code.
+
+You can also specify sourceRoot property to be included in source map:
+```javascript
+var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
+    sourceMap: {
+        root: "http://example.com/src",
+        url: "out.js.map"
+    }
+});
+```
+
+If you're compressing compiled JavaScript and have a source map for it, you
+can use `sourceMap.content`:
+```javascript
+var result = UglifyJS.minify({"compiled.js": "compiled code"}, {
+    sourceMap: {
+        content: "content from compiled.js.map",
+        url: "minified.js.map"
+    }
+});
+// same as before, it returns `code` and `map`
+```
+
+If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.url`.
+
+## Parse options
+
+- `bare_returns` (default `false`) -- support top level `return` statements
+- `html5_comments` (default `true`)
+- `shebang` (default `true`) -- support `#!command` as the first line
+
+## Compress options
 
 - `sequences` (default: true) -- join consecutive simple statements using the
   comma operator.  May be set to a positive integer to specify the maximum number
@@ -347,6 +620,9 @@ to set `true`; it's effectively a shortcut for `foo=true`).
   comparison are switching. Compression only works if both `comparisons` and
   `unsafe_comps` are both set to true.
 
+- `unsafe_Func` (default: false) -- compress and mangle `Function(args, code)`
+  when both `args` and `code` are string literals.
+
 - `unsafe_math` (default: false) -- optimize numerical expressions like
   `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
 
@@ -368,6 +644,10 @@ to set `true`; it's effectively a shortcut for `foo=true`).
 - `booleans` -- various optimizations for boolean context, for example `!!a
   ? b : c → a ? b : c`
 
+- `typeofs` -- default `true`.  Transforms `typeof foo == "undefined"` into
+  `foo === void 0`.  Note: recommend to set this value to `false` for IE10 and
+  earlier versions due to known issues.
+
 - `loops` -- optimizations for `do`, `while` and `for` loops when we can
   statically determine the condition
 
@@ -375,7 +655,7 @@ to set `true`; it's effectively a shortcut for `foo=true`).
   assignments do not count as references unless set to `"keep_assign"`)
 
 - `toplevel` -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
-  in the toplevel scope (`false` by default, `true` to drop both unreferenced
+  in the top level scope (`false` by default, `true` to drop both unreferenced
   functions and variables)
 
 - `top_retain` -- prevent specific toplevel functions and variables from `unused`
@@ -388,13 +668,15 @@ to set `true`; it's effectively a shortcut for `foo=true`).
 
 - `if_return` -- optimizations for if/return and if/continue
 
+- `inline` -- embed simple functions
+
 - `join_vars` -- join consecutive `var` statements
 
 - `cascade` -- small optimization for sequences, transform `x, x` into `x`
   and `x = something(), x` into `x = something()`
 
-- `collapse_vars` -- Collapse single-use `var` and `const` definitions
-  when possible.
+- `collapse_vars` -- Collapse single-use non-constant variables - side
+  effects permitting.
 
 - `reduce_vars` -- Improve optimization on variables assigned with and
   used as constant values.
@@ -439,7 +721,7 @@ to set `true`; it's effectively a shortcut for `foo=true`).
   compressor from discarding function names.  Useful for code relying on
   `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
 
-- `passes` -- default `1`. Number of times to run compress with a maximum of 3.
+- `passes` -- default `1`. The maximum number of times to run compress.
   In some cases more than one pass leads to further compressed code.  Keep in
   mind more passes will take more time.
 
@@ -451,122 +733,110 @@ to set `true`; it's effectively a shortcut for `foo=true`).
   annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
   example: `/*@__PURE__*/foo();`
 
+## Mangle options
 
-### The `unsafe` option
+- `reserved` (default `[]`). Pass an array of identifiers that should be
+  excluded from mangling. Example: `["foo", "bar"]`.
 
-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:
+- `toplevel` (default `false`). Pass `true` to mangle names declared in the
+  top level scope.
 
-- `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)
+- `keep_fnames` (default `false`).  Pass `true` to not mangle function names.
+  Useful for code relying on `Function.prototype.name`. See also: the `keep_fnames`
+  [compress option](#compress-options).
 
-### Conditional compilation
+- `eval` (default `false`). Pass `true` to mangle names visible in scopes
+  where `eval` or `with` are used.
+
+Examples:
 
-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");
+// test.js
+var globalVar;
+function funcName(firstLongName, anotherLongName) {
+    var myVariable = firstLongName +  anotherLongName;
 }
 ```
-
-You can specify nested constants in the form of `--define env.DEBUG=false`.
-
-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:
+var code = fs.readFileSync("test.js", "utf8");
 
-    uglifyjs build/defines.js js/foo.js js/bar.js... -c
+UglifyJS.minify(code).code;
+// 'function funcName(a,n){}var globalVar;'
 
-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 build will contain the `const` declarations if you use
-them. If you are targeting < ES6 environments which does not support `const`,
-using `var` with `reduce_vars` (enabled by default) should suffice.
+UglifyJS.minify(code, { mangle: { reserved: ['firstLongName'] } }).code;
+// 'function funcName(firstLongName,a){}var globalVar;'
 
-<a name="codegen-options"></a>
+UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
+// 'function n(n,a){}var a;'
+```
 
-#### Conditional compilation, API
-You can also use conditional compilation via the programmatic API. With the difference that the
-property name is `global_defs` and is a compressor property:
+### Mangle properties options
 
-```js
-uglifyJS.minify([ "input.js"], {
-    compress: {
-        dead_code: true,
-        global_defs: {
-            DEBUG: false
-        }
-    }
-});
-```
+- `reserved` (default: `[]`) -- Do not mangle property names listed in the
+  `reserved` array.
+- `regex` (default: `null`) -— Pass a RegExp literal to only mangle property
+  names matching the regular expression.
+- `keep_quoted` (default: `false`) -— Only mangle unquoted property names.
+- `debug` (default: `false`) -— Mangle names with the original name still present.
+  Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
+- `builtins` (default: `false`) -- Use `true` to allow the mangling of builtin
+  DOM properties. Not recommended to override this setting.
 
-## Beautifier options
+## Output 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:
 
+- `ascii_only` (default `false`) -- escape Unicode characters in strings and
+  regexps (affects directives with non-ascii characters becoming invalid)
 - `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 (affects directives with non-ascii characters becoming invalid)
-- `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).
+- `comments` (default `false`) -- pass `true` or `"all"` to preserve all
+  comments, `"some"` to preserve some comments, a regular expression string
+  (e.g. `/^!/`) or a function.
+- `indent_level` (default 4)
+- `indent_start` (default 0) -- prefix all lines by that many spaces
+- `inline_script` (default `false`) -- escape the slash in occurrences of
+  `</script` in strings
+- `keep_quoted_props` (default `false`) -- when turned on, prevents stripping
+  quotes from property names in object literals.
+- `max_line_len` (default `false`) -- maximum line length (for uglified code)
 - `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.
+- `preserve_line` (default `false`) -- pass `true` to preserve lines, but it
+  only works if `beautify` is set to `false`.
+- `quote_keys` (default `false`) -- pass `true` to quote all keys in literal
+  objects
 - `quote_style` (default `0`) -- preferred quote style for strings (affects
   quoted property names and directives as well):
   - `0` -- prefers double quotes, switches to single quotes when there are
-    more double quotes in the string itself.
+    more double quotes in the string itself. `0` is best for gzip size.
   - `1` -- always use single quotes
   - `2` -- always use double quotes
   - `3` -- always use the original quotes
-- `keep_quoted_props` (default `false`) -- when turned on, prevents stripping
-  quotes from property names in object literals.
+- `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).
+- `shebang` (default `true`) -- preserve shebang `#!` in preamble (bash scripts)
+- `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.
+- `wrap_iife` (default `false`) -- pass `true` to wrap immediately invoked
+  function expressions. See
+  [#640](https://github.com/mishoo/UglifyJS2/issues/640) for more details.
+
+# Miscellaneous
 
 ### Keeping copyright notices or other comments
 
@@ -574,18 +844,18 @@ 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".
+keep only comments that match this regexp.  For example `--comments /^!/`
+will keep comments like `/*! Copyright Notice */`.
 
 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();
+    /** @preserve Foo Bar */
+    function g() {
+        // this function is never called
+    }
+    return something();
 }
 ```
 
@@ -596,400 +866,193 @@ 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.
+### The `unsafe` `compress` option
 
-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
+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:
 
-Now you can use UglifyJS as any other intermediate tool for transforming
-JavaScript ASTs in SpiderMonkey format.
+- `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`
+- `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)
 
-Example:
+### 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
-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 = UglifyJS.Compressor(options).compress(uAST);
-
-  // 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();
+if (DEBUG) {
+    console.log("debug stuff");
 }
 ```
 
-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
+You can specify nested constants in the form of `--define env.DEBUG=false`.
 
-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});
-```
+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.
 
-You can also compress multiple files:
+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
-var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ]);
-console.log(result.code);
+var DEBUG = false;
+var PRODUCTION = true;
+// etc.
 ```
 
-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);
-```
+and build your code like this:
 
-To generate a source map with the fromString option, you can also use an object:
-```javascript
-var result = UglifyJS.minify({"file1.js": "var a = function () {};"}, {
-  outSourceMap: "out.js.map",
-  outFileName: "out.js",
-  fromString: true
-});
-```
+    uglifyjs build/defines.js js/foo.js js/bar.js... -c
 
-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
-`//# sourceMappingURL=out.js.map` in `result.code`. The value of
-`outFileName` is only used to set `file` attribute in source map file.
+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 build will contain the `const` declarations if you use
+them. If you are targeting < ES6 environments which does not support `const`,
+using `var` with `reduce_vars` (enabled by default) should suffice.
 
-The `file` attribute in the source map (see [the spec][sm-spec]) will
-use `outFileName` firstly, if it's falsy, then will be deduced from
-`outSourceMap` (by removing `'.map'`).
+### Conditional compilation API
 
-You can set option `sourceMapInline` to be `true` and source map will
-be appended to code.
+You can also use conditional compilation via the programmatic API. With the difference that the
+property name is `global_defs` and is a compressor property:
 
-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"
+var result = UglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
+    compress: {
+        dead_code: true,
+        global_defs: {
+            DEBUG: false
+        }
+    }
 });
 ```
 
-If you're compressing compiled JavaScript and have a source map for it, you
-can use the `inSourceMap` argument:
+To replace an identifier with an arbitrary non-constant expression it is
+necessary to prefix the `global_defs` key with `"@"` to instruct UglifyJS
+to parse the value as an expression:
 ```javascript
-var result = UglifyJS.minify("compiled.js", {
-	inSourceMap: "compiled.js.map",
-	outSourceMap: "minified.js.map"
-});
-// same as before, it returns `code` and `map`
+UglifyJS.minify("alert('hello');", {
+    compress: {
+        global_defs: {
+            "@alert": "console.log"
+        }
+    }
+}).code;
+// returns: 'console.log("hello");'
 ```
 
-If your input source map is not in a file, you can pass it in as an object
-using the `inSourceMap` argument:
-
+Otherwise it would be replaced as string literal:
 ```javascript
-var result = UglifyJS.minify("compiled.js", {
-	inSourceMap: JSON.parse(my_source_map_string),
-	outSourceMap: "minified.js.map"
-});
+UglifyJS.minify("alert('hello');", {
+    compress: {
+        global_defs: {
+            "alert": "console.log"
+        }
+    }
+}).code;
+// returns: '"console.log"("hello");'
 ```
 
-The `inSourceMap` is only used if you also request `outSourceMap` (it makes
-no sense otherwise).
-
-To set the source map url, use the `sourceMapUrl` option.
-If you're using the X-SourceMap header instead, you can just set the `sourceMapUrl` option to false.
-Defaults to outSourceMap:
-
+### Using native Uglify AST with `minify()`
 ```javascript
-var result = UglifyJS.minify([ "file1.js" ], {
-  outSourceMap: "out.js.map",
-  sourceMapUrl: "localhost/out.js.map"
+// example: parse only, produce native Uglify AST
+
+var result = UglifyJS.minify(code, {
+    parse: {},
+    compress: false,
+    mangle: false,
+    output: {
+        ast: true,
+        code: false  // optional - faster if false
+    }
 });
-```
-
-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` (default `true`) — pass `false` to skip mangling names, or pass
-  an object to specify mangling options (see below).
-
-- `mangleProperties` (default `false`) — pass an object to specify custom
-  mangle property options.
-
-- `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].
-
-- `parse` (default {}) — pass an object if you wish to specify some
-  additional [parser options][parser]. (not all options available... see below)
-
-##### mangle
-
- - `except` - pass an array of identifiers that should be excluded from mangling
-
- - `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).
-
- - `keep_fnames` -- default `false`.  Pass `true` to not mangle
-  function names.  Useful for code relying on `Function.prototype.name`.
-  See also: the `keep_fnames` [compress option](#compressor-options).
-
-  Examples:
-
-  ```javascript
-  //tst.js
-  var globalVar;
-  function funcName(firstLongName, anotherLongName)
-  {
-    var myVariable = firstLongName +  anotherLongName;
-  }
-
-  UglifyJS.minify("tst.js").code;
-  // 'function funcName(a,n){}var globalVar;'
-
-  UglifyJS.minify("tst.js", { mangle: { except: ['firstLongName'] } }).code;
-  // 'function funcName(firstLongName,a){}var globalVar;'
-
-  UglifyJS.minify("tst.js", { mangle: { toplevel: true } }).code;
-  // 'function n(n,a){}var a;'
-  ```
 
-##### mangleProperties options
-
- - `regex` — Pass a RegExp to only mangle certain names (maps to the `--mangle-regex` CLI arguments option)
- - `ignore_quoted` – Only mangle unquoted property names (maps to the `--mangle-props 2` CLI arguments option)
- - `debug` – Mangle names with the original name still present (maps to the `--mangle-props-debug` CLI arguments option). Defaults to `false`. Pass an empty string to enable, or a non-empty string to set the suffix.
-
-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);
+// result.ast contains native Uglify AST
 ```
-
-`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
-- `bare_returns` — Allow return outside of functions. (maps to the
-  `--bare-returns` CLI arguments option and available to `minify` `parse`
-  other options object)
-- `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
-	});
+// example: accept native Uglify AST input and then compress and mangle
+//          to produce both code and native AST.
+
+var result = UglifyJS.minify(ast, {
+    compress: {},
+    mangle: {},
+    output: {
+        ast: true,
+        code: true  // optional - faster if false
+    }
 });
-```
-
-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()
+// result.ast contains native Uglify AST
+// result.code contains the minified code in string form.
 ```
 
-#### Compression
-
-Like this:
-```javascript
-var compressor = UglifyJS.Compressor(options);
-var compressed_ast = compressor.compress(toplevel);
-```
+### Working with Uglify AST
 
-The `options` can be missing.  Available options are discussed above in
-“Compressor options”.  Defaults should lead to best compression in most
-scripts.
+Transversal and transformation of the native AST can be performed through
+[`TreeWalker`](http://lisperator.net/uglifyjs/walk) and
+[`TreeTransformer`](http://lisperator.net/uglifyjs/transform) respectively.
 
-The compressor is destructive, so don't rely that `toplevel` remains the
-original tree.
+### ESTree / SpiderMonkey AST
 
-#### 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
-```
+UglifyJS 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.
 
-or, for a shortcut you can do:
-```javascript
-var code = compressed_ast.print_to_string(options);
-```
+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:
 
-As usual, `options` is optional.  The output stream accepts a lot of options,
-most of them documented above in section “Beautifier options”.  The two
-which we care about here are `source_map` and `comments`.
+    acorn file.js | uglifyjs -p spidermonkey -m -c
 
-#### Keeping comments in the output
+The `-p 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.
 
-In order to keep certain comments in the output you need to pass the
-`comments` option.  Pass a RegExp (as string starting and closing with `/`
-or pass a RegExp object), a boolean or a function.  Stringified options
-`all` and `some` can be passed too, where `some` behaves like it's cli
-equivalent `--comments` without passing a value. 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.
+### Use Acorn for parsing
 
-The comment token has these properties:
+More for fun, I added the `-p acorn` option which will use Acorn to do all
+the parsing.  If you pass this option, UglifyJS will `require("acorn")`.
 
-- `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.
+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.
 
-Your function should return `true` to keep the comment, or a falsy value
-otherwise.
+[acorn]: https://github.com/ternjs/acorn
+[sm-spec]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k
 
-#### Generating a source mapping
+### Uglify Fast Minify Mode
 
-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).
+It's not well known, but whitespace removal and symbol mangling accounts
+for 95% of the size reduction in minified code for most javascript - not
+elaborate code transforms. One can simply disable `compress` to speed up
+Uglify builds by 3 to 4 times. In this fast `mangle`-only mode Uglify has
+comparable minify speeds and gzip sizes to
+[`butternut`](https://www.npmjs.com/package/butternut):
 
-Example:
-```javascript
-var source_map = UglifyJS.SourceMap(source_map_options);
-var stream = UglifyJS.OutputStream({
-	...
-	source_map: source_map
-});
-compressed_ast.print(stream);
+| d3.js | minify size | gzip size | minify time (seconds) |
+| --- | ---: | ---: | ---: |
+| original | 451,131 | 108,733 | - |
+| uglify-js@3.0.24 mangle=false, compress=false | 316,600 | 85,245 | 0.70 |
+| uglify-js@3.0.24 mangle=true, compress=false | 220,216 | 72,730 | 1.13 |
+| butternut@0.4.6 | 217,568 | 72,738 | 1.41 |
+| uglify-js@3.0.24 mangle=true, compress=true | 212,511 | 71,560 | 3.36 |
+| babili@0.1.4 | 210,713 | 72,140 | 12.64 |
 
-var code = stream.toString();
-var map = source_map.toString(); // json output for your source map
+To enable fast minify mode from the CLI use:
+```
+uglifyjs file.js -m
+```
+To enable fast minify mode with the API use:
+```js
+UglifyJS.minify(code, { compress: false, mangle: true });
 ```
-
-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/ternjs/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
-  [parser]: http://lisperator.net/uglifyjs/parser
-
-#### Support for `const`
-
-`const` in `uglify-js@2.x` has function scope and as such behaves much like
-`var` - unlike `const` in ES2015 (ES6) which has block scope. It is recommended
-to avoid using `const` for this reason as it will have undefined behavior when
-run on an ES2015 compatible browser.
diff --git a/node_modules/uglify-js/bin/extract-props.js b/node_modules/uglify-js/bin/extract-props.js
deleted file mode 100644
index a5b61458c..000000000
--- a/node_modules/uglify-js/bin/extract-props.js
+++ /dev/null
@@ -1,77 +0,0 @@
-#! /usr/bin/env node
-
-"use strict";
-
-var U2 = require("../tools/node");
-var fs = require("fs");
-var yargs = require("yargs");
-var ARGS = yargs
-    .describe("o", "Output file")
-    .argv;
-var files = ARGS._.slice();
-var output = {
-    vars: {},
-    props: {}
-};
-
-if (ARGS.o) try {
-    output = JSON.parse(fs.readFileSync(ARGS.o, "utf8"));
-} catch(ex) {}
-
-files.forEach(getProps);
-
-if (ARGS.o) {
-    fs.writeFileSync(ARGS.o, JSON.stringify(output, null, 2), "utf8");
-} else {
-    console.log("%s", JSON.stringify(output, null, 2));
-}
-
-function getProps(filename) {
-    var code = fs.readFileSync(filename, "utf8");
-    var ast = U2.parse(code);
-
-    ast.walk(new U2.TreeWalker(function(node){
-        if (node instanceof U2.AST_ObjectKeyVal) {
-            add(node.key);
-        }
-        else if (node instanceof U2.AST_ObjectProperty) {
-            add(node.key.name);
-        }
-        else if (node instanceof U2.AST_Dot) {
-            add(node.property);
-        }
-        else if (node instanceof U2.AST_Sub) {
-            addStrings(node.property);
-        }
-    }));
-
-    function addStrings(node) {
-        var out = {};
-        try {
-            (function walk(node){
-                node.walk(new U2.TreeWalker(function(node){
-                    if (node instanceof U2.AST_Seq) {
-                        walk(node.cdr);
-                        return true;
-                    }
-                    if (node instanceof U2.AST_String) {
-                        add(node.value);
-                        return true;
-                    }
-                    if (node instanceof U2.AST_Conditional) {
-                        walk(node.consequent);
-                        walk(node.alternative);
-                        return true;
-                    }
-                    throw out;
-                }));
-            })(node);
-        } catch(ex) {
-            if (ex !== out) throw ex;
-        }
-    }
-
-    function add(name) {
-        output.props[name] = true;
-    }
-}
diff --git a/node_modules/uglify-js/bin/uglifyjs b/node_modules/uglify-js/bin/uglifyjs
index 63b2f26f1..8cbb3cadd 100755
--- a/node_modules/uglify-js/bin/uglifyjs
+++ b/node_modules/uglify-js/bin/uglifyjs
@@ -3,633 +3,399 @@
 
 "use strict";
 
-var UglifyJS = require("../tools/node");
-var sys = require("util");
-var yargs = require("yargs");
+// workaround for tty output truncation upon process.exit()
+[process.stdout, process.stderr].forEach(function(stream){
+    if (stream._handle && stream._handle.setBlocking)
+        stream._handle.setBlocking(true);
+});
+
 var fs = require("fs");
+var info = require("../package.json");
 var path = require("path");
-var acorn;
-var screw_ie8 = true;
-var ARGS = yargs
-    .usage("$0 input1.js [input2.js ...] [options]\n\
-Use a single dash to read input from the standard input.\
-\n\n\
-NOTE: by default there is no mangling/compression.\n\
-Without [options] it will simply parse input files and dump the AST\n\
-with whitespace and comments discarded.  To achieve compression and\n\
-mangling you need to use `-c` and `-m`.\
-")
-    .describe("source-map", "Specify an output file where to generate source map.")
-    .describe("source-map-root", "The path to the original source to be included in the source map.")
-    .describe("source-map-url", "The path to the source map to be added in //# sourceMappingURL.  Defaults to the value passed with --source-map.")
-    .describe("source-map-inline", "Write base64-encoded source map to the end of js output.  Disabled by default")
-    .describe("source-map-include-sources", "Pass this flag if you want to include the content of source files in the source map as sourcesContent property.")
-    .describe("in-source-map", "Input source map, useful if you're compressing JS that was generated from some other original code.")
-    .describe("screw-ie8", "Do not support Internet Explorer 6/7/8. This flag is enabled by default.")
-    .describe("support-ie8", "Support non-standard Internet Explorer 6/7/8 javascript.")
-    .describe("expr", "Parse a single expression, rather than a program (for parsing JSON)")
-    .describe("p", "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.")
-    .describe("o", "Output file (default STDOUT).")
-    .describe("b", "Beautify output/specify output options.")
-    .describe("m", "Mangle names/pass mangler options.")
-    .describe("r", "Reserved names to exclude from mangling.")
-    .describe("c", "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.")
-    .describe("d", "Global definitions")
-    .describe("e", "Embed everything in a big function, with a configurable parameter/argument list.")
-
-    .describe("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:\n\
-- \"all\" to keep all comments\n\
-- a valid JS RegExp like `/foo/`or `/^!/` to keep only matching comments.\n\
-\
-Note that currently not *all* comments can be kept when compression is on, \
-because of dead code removal or cascading statements into sequences.")
-
-    .describe("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.")
-
-    .describe("stats", "Display operations run time on STDERR.")
-    .describe("acorn", "Use Acorn for parsing.")
-    .describe("spidermonkey", "Assume input files are SpiderMonkey AST format (as JSON).")
-    .describe("self", "Build itself (UglifyJS2) as a library (implies --wrap=UglifyJS --export-all)")
-    .describe("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.")
-    .describe("export-all", "Only used when --wrap, this tells UglifyJS to add code to automatically export all globals.")
-    .describe("lint", "Display some scope warnings")
-    .describe("v", "Verbose")
-    .describe("V", "Print version number and exit.")
-    .describe("noerr", "Don't throw an error for unknown options in -c, -b or -m.")
-    .describe("bare-returns", "Allow return outside of functions.  Useful when minifying CommonJS modules.")
-    .describe("keep-fnames", "Do not mangle/drop function names.  Useful for code relying on Function.prototype.name.")
-    .describe("quotes", "Quote style (0 - auto, 1 - single, 2 - double, 3 - original)")
-    .describe("reserved-file", "File containing reserved names")
-    .describe("reserve-domprops", "Make (most?) DOM properties reserved for --mangle-props")
-    .describe("mangle-props", "Mangle property names (0 - disabled, 1 - mangle all properties, 2 - mangle unquoted properies)")
-    .describe("mangle-regex", "Only mangle property names matching the regex")
-    .describe("name-cache", "File to hold mangled names mappings")
-    .describe("pure-funcs", "List of functions that can be safely removed if their return value is not used")
-    .describe("dump-spidermonkey-ast", "Dump SpiderMonkey AST to stdout.")
-    .describe("wrap-iife", "Wrap IIFEs in parenthesis. Note: this disables the negate_iife compression option")
-
-    .alias("p", "prefix")
-    .alias("o", "output")
-    .alias("v", "verbose")
-    .alias("b", "beautify")
-    .alias("m", "mangle")
-    .alias("c", "compress")
-    .alias("d", "define")
-    .alias("r", "reserved")
-    .alias("V", "version")
-    .alias("e", "enclose")
-    .alias("q", "quotes")
-
-    .string("source-map")
-    .string("source-map-root")
-    .string("source-map-url")
-    .string("b")
-    .string("beautify")
-    .string("m")
-    .string("mangle")
-    .string("mangle-props-debug")
-    .string("c")
-    .string("compress")
-    .string("d")
-    .string("define")
-    .string("e")
-    .string("enclose")
-    .string("comments")
-    .string("wrap")
-    .string("p")
-    .string("prefix")
-    .string("name-cache")
-
-    .array("reserved-file")
-    .array("pure-funcs")
-
-    .boolean("expr")
-    .boolean("source-map-inline")
-    .boolean("source-map-include-sources")
-    .boolean("screw-ie8")
-    .boolean("support-ie8")
-    .boolean("export-all")
-    .boolean("self")
-    .boolean("v")
-    .boolean("verbose")
-    .boolean("stats")
-    .boolean("acorn")
-    .boolean("spidermonkey")
-    .boolean("dump-spidermonkey-ast")
-    .boolean("lint")
-    .boolean("V")
-    .boolean("version")
-    .boolean("noerr")
-    .boolean("bare-returns")
-    .boolean("keep-fnames")
-    .boolean("reserve-domprops")
-    .boolean("wrap-iife")
-
-    .wrap(80)
-
-    .argv
-;
-
-normalize(ARGS);
-
-if (ARGS.noerr) {
-    UglifyJS.DefaultsError.croak = function(msg, defs) {
-        print_error("WARN: " + msg);
-    };
-}
-
-if (ARGS.version || ARGS.V) {
-    var json = require("../package.json");
-    print(json.name + ' ' + json.version);
-    process.exit(0);
-}
-
-if (ARGS.ast_help) {
-    var desc = UglifyJS.describe_ast();
-    print(typeof desc == "string" ? desc : JSON.stringify(desc, null, 2));
-    process.exit(0);
-}
-
-if (ARGS.h || ARGS.help) {
-    print(yargs.help());
-    process.exit(0);
-}
-
-if (ARGS.acorn) {
-    acorn = require("acorn");
-}
-
-var COMPRESS = getOptions("c", true);
-var MANGLE = getOptions("m", true);
-var BEAUTIFY = getOptions("b", true);
-var RESERVED = null;
+var program = require("commander");
+var UglifyJS = require("../tools/node");
 
-if (ARGS.reserved_file) ARGS.reserved_file.forEach(function(filename){
-    RESERVED = UglifyJS.readReservedFile(filename, RESERVED);
+var skip_keys = [ "cname", "enclosed", "parent_scope", "scope", "thedef", "uses_eval", "uses_with" ];
+var files = {};
+var options = {
+    compress: false,
+    mangle: false
+};
+program.version(info.name + " " + info.version);
+program.parseArgv = program.parse;
+program.parse = undefined;
+if (process.argv.indexOf("ast") >= 0) program.helpInformation = UglifyJS.describe_ast;
+else if (process.argv.indexOf("options") >= 0) program.helpInformation = function() {
+    var text = [];
+    var options = UglifyJS.default_options();
+    for (var option in options) {
+        text.push("--" + (option == "output" ? "beautify" : option == "sourceMap" ? "source-map" : option) + " options:");
+        text.push(format_object(options[option]));
+        text.push("");
+    }
+    return text.join("\n");
+};
+program.option("-p, --parse <options>", "Specify parser options.", parse_js());
+program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js());
+program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js());
+program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js());
+program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js());
+program.option("-o, --output <file>", "Output file (default STDOUT).");
+program.option("--comments [filter]", "Preserve copyright comments in the output.");
+program.option("--config-file <file>", "Read minify() options from JSON file.");
+program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("define"));
+program.option("--ie8", "Support non-standard Internet Explorer 8.");
+program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
+program.option("--name-cache <file>", "File to hold mangled name mappings.");
+program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
+program.option("--source-map [options]", "Enable source map/specify source map options.", parse_source_map());
+program.option("--timings", "Display operations run time on STDERR.")
+program.option("--toplevel", "Compress and/or mangle variables in toplevel scope.");
+program.option("--verbose", "Print diagnostic messages.");
+program.option("--warn", "Print warning messages.");
+program.option("--wrap <name>", "Embed everything as a function with “exports” corresponding to “name” globally.");
+program.arguments("[files...]").parseArgv(process.argv);
+if (program.configFile) {
+    options = JSON.parse(read_file(program.configFile));
+}
+if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
+    fatal("ERROR: cannot write source map to STDOUT");
+}
+[
+    "compress",
+    "ie8",
+    "mangle",
+    "sourceMap",
+    "toplevel",
+    "wrap"
+].forEach(function(name) {
+    if (name in program) {
+        options[name] = program[name];
+    }
 });
-
-if (ARGS.reserve_domprops) {
-    RESERVED = UglifyJS.readDefaultReservedFile(RESERVED);
-}
-
-if (ARGS.d) {
-    if (COMPRESS) COMPRESS.global_defs = getOptions("d");
+if (program.beautify) {
+    options.output = typeof program.beautify == "object" ? program.beautify : {};
+    if (!("beautify" in options.output)) {
+        options.output.beautify = true;
+    }
 }
-
-if (ARGS.pure_funcs) {
-    if (COMPRESS) COMPRESS.pure_funcs = ARGS.pure_funcs;
+if (program.comments) {
+    if (typeof options.output != "object") options.output = {};
+    options.output.comments = typeof program.comments == "string" ? program.comments : "some";
 }
-
-if (ARGS.r) {
-    if (MANGLE) MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/);
+if (program.define) {
+    if (typeof options.compress != "object") options.compress = {};
+    if (typeof options.compress.global_defs != "object") options.compress.global_defs = {};
+    for (var expr in program.define) {
+        options.compress.global_defs[expr] = program.define[expr];
+    }
 }
-
-if (RESERVED && MANGLE) {
-    if (!MANGLE.except) MANGLE.except = RESERVED.vars;
-    else MANGLE.except = MANGLE.except.concat(RESERVED.vars);
+if (program.keepFnames) {
+    options.keep_fnames = true;
 }
-
-function readNameCache(key) {
-    return UglifyJS.readNameCache(ARGS.name_cache, key);
+if (program.mangleProps) {
+    if (program.mangleProps.domprops) {
+        delete program.mangleProps.domprops;
+    } else {
+        if (typeof program.mangleProps != "object") program.mangleProps = {};
+        if (!Array.isArray(program.mangleProps.reserved)) program.mangleProps.reserved = [];
+        require("../tools/domprops").forEach(function(name) {
+            UglifyJS._push_uniq(program.mangleProps.reserved, name);
+        });
+    }
+    if (typeof options.mangle != "object") options.mangle = {};
+    options.mangle.properties = program.mangleProps;
 }
-
-function writeNameCache(key, cache) {
-    return UglifyJS.writeNameCache(ARGS.name_cache, key, cache);
+if (program.nameCache) {
+    options.nameCache = JSON.parse(read_file(program.nameCache, "{}"));
 }
-
-function extractRegex(str) {
-  if (/^\/.*\/[a-zA-Z]*$/.test(str)) {
-    var regex_pos = str.lastIndexOf("/");
-    return new RegExp(str.substr(1, regex_pos - 1), str.substr(regex_pos + 1));
-  } else {
-    throw new Error("Invalid regular expression: " + str);
-  }
-}
-
-if (ARGS.quotes === true) {
-    ARGS.quotes = 3;
+if (program.output == "ast") {
+    options.output = {
+        ast: true,
+        code: false
+    };
 }
-
-if (ARGS.mangle_props === true) {
-    ARGS.mangle_props = 1;
-} else if (ARGS.mangle_props === "unquoted") {
-    ARGS.mangle_props = 2;
+if (program.parse) {
+    if (!program.parse.acorn && !program.parse.spidermonkey) {
+        options.parse = program.parse;
+    } else if (program.sourceMap && program.sourceMap.content == "inline") {
+        fatal("ERROR: inline source map only works with built-in parser");
+    }
 }
-
-var OUTPUT_OPTIONS = {
-    beautify     : BEAUTIFY ? true : false,
-    max_line_len : 32000,
-    preamble     : ARGS.preamble || null,
-    quote_style  : ARGS.quotes != null ? ARGS.quotes : 0,
+var convert_path = function(name) {
+    return name;
 };
-
-if (ARGS.mangle_props == 2) {
-    OUTPUT_OPTIONS.keep_quoted_props = true;
-    if (COMPRESS && !("properties" in COMPRESS))
-        COMPRESS.properties = false;
-}
-
-if (ARGS.support_ie8 === true && ARGS.screw_ie8 !== true) {
-    screw_ie8 = false;
-}
-
-if (COMPRESS) COMPRESS.screw_ie8 = screw_ie8;
-if (MANGLE) MANGLE.screw_ie8 = screw_ie8;
-OUTPUT_OPTIONS.screw_ie8 = screw_ie8;
-
-if (ARGS.keep_fnames) {
-    if (COMPRESS) COMPRESS.keep_fnames = true;
-    if (MANGLE) MANGLE.keep_fnames = true;
-}
-
-if (ARGS.wrap_iife) {
-    if (COMPRESS) COMPRESS.negate_iife = false;
-    OUTPUT_OPTIONS.wrap_iife = true;
-}
-
-if (BEAUTIFY)
-    UglifyJS.merge(OUTPUT_OPTIONS, BEAUTIFY);
-
-if (ARGS.comments === "") {
-    OUTPUT_OPTIONS.comments = "some";
-} else {
-    OUTPUT_OPTIONS.comments = ARGS.comments;
-}
-
-var files = ARGS._.slice();
-
-if (process.platform === "win32")
-    files = UglifyJS.simple_glob(files);
-
-if (ARGS.self) {
-    if (files.length > 0) {
+if (typeof program.sourceMap == "object" && "base" in program.sourceMap) {
+    convert_path = function() {
+        var base = program.sourceMap.base;
+        delete options.sourceMap.base;
+        return function(name) {
+            return path.relative(base, name);
+        };
+    }();
+}
+if (program.verbose) {
+    options.warnings = "verbose";
+} else if (program.warn) {
+    options.warnings = true;
+}
+if (program.self) {
+    if (program.args.length) {
         print_error("WARN: Ignoring input files since --self was passed");
     }
-    files = UglifyJS.FILES;
-    if (!ARGS.wrap) ARGS.wrap = "UglifyJS";
-}
-
-var ORIG_MAP = ARGS.in_source_map;
-
-if (ORIG_MAP && ORIG_MAP != "inline") {
-    ORIG_MAP = JSON.parse(fs.readFileSync(ORIG_MAP));
-    if (files.length == 0) {
-        print_error("INFO: Using file from the input source map: " + ORIG_MAP.file);
-        files = [ ORIG_MAP.file ];
-    }
-}
-
-if (files.length == 0) {
-    files = [ "-" ];
-}
-
-if (ORIG_MAP == "inline") {
-    if (files.length > 1) {
-        print_error("ERROR: Inline source map only works with singular input");
-        process.exit(1);
-    }
-    if (ARGS.acorn || ARGS.spidermonkey) {
-        print_error("ERROR: Inline source map only works with built-in parser");
-        process.exit(1);
-    }
-}
-
-if (files.indexOf("-") >= 0 && ARGS.source_map) {
-    print_error("ERROR: Source map doesn't work with input from STDIN");
-    process.exit(1);
+    if (!options.wrap) options.wrap = "UglifyJS";
+    simple_glob(UglifyJS.FILES).forEach(function(name) {
+        files[convert_path(name)] = read_file(name);
+    });
+    run();
+} else if (program.args.length) {
+    simple_glob(program.args).forEach(function(name) {
+        files[convert_path(name)] = read_file(name);
+    });
+    run();
+} else {
+    var chunks = [];
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", function(chunk) {
+        chunks.push(chunk);
+    }).on("end", function() {
+        files = [ chunks.join("") ];
+        run();
+    });
+    process.stdin.resume();
 }
 
-if (files.filter(function(el){ return el == "-" }).length > 1) {
-    print_error("ERROR: Can read a single file from STDIN (two or more dashes specified)");
-    process.exit(1);
+function convert_ast(fn) {
+    return UglifyJS.AST_Node.from_mozilla_ast(Object.keys(files).reduce(fn, null));
 }
 
-var STATS = {};
-var TOPLEVEL = null;
-var P_RELATIVE = ARGS.p && ARGS.p == "relative";
-var SOURCES_CONTENT = {};
-var index = 0;
-
-!function cb() {
-    if (index == files.length) return done();
-    var file = files[index++];
-    read_whole_file(file, function (err, code) {
-        if (err) {
-            print_error("ERROR: can't read file: " + file);
-            process.exit(1);
-        }
-        if (ORIG_MAP == "inline") {
-            ORIG_MAP = read_source_map(code);
-        }
-        if (ARGS.p != null) {
-            if (P_RELATIVE) {
-                file = path.relative(path.dirname(ARGS.source_map), file).replace(/\\/g, '/');
-            } else {
-                var p = parseInt(ARGS.p, 10);
-                if (!isNaN(p)) {
-                    file = file.replace(/^\/+/, "").split(/\/+/).slice(ARGS.p).join("/");
-                }
-            }
-        }
-        SOURCES_CONTENT[file] = code;
-        time_it("parse", function(){
-            if (ARGS.spidermonkey) {
-                var program = JSON.parse(code);
-                if (!TOPLEVEL) TOPLEVEL = program;
-                else TOPLEVEL.body = TOPLEVEL.body.concat(program.body);
-            }
-            else if (ARGS.acorn) {
-                TOPLEVEL = acorn.parse(code, {
-                    locations     : true,
-                    sourceFile    : file,
-                    program       : TOPLEVEL
+function run() {
+    UglifyJS.AST_Node.warn_function = function(msg) {
+        print_error("WARN: " + msg);
+    };
+    if (program.timings) options.timings = true;
+    try {
+        if (program.parse) {
+            if (program.parse.acorn) {
+                files = convert_ast(function(toplevel, name) {
+                    return require("acorn").parse(files[name], {
+                        locations: true,
+                        program: toplevel,
+                        sourceFile: name
+                    });
+                });
+            } else if (program.parse.spidermonkey) {
+                files = convert_ast(function(toplevel, name) {
+                    var obj = JSON.parse(files[name]);
+                    if (!toplevel) return obj;
+                    toplevel.body = toplevel.body.concat(obj.body);
+                    return toplevel;
                 });
             }
-            else {
-                try {
-                    TOPLEVEL = UglifyJS.parse(code, {
-                        filename     : file,
-                        toplevel     : TOPLEVEL,
-                        expression   : ARGS.expr,
-                        bare_returns : ARGS.bare_returns,
-                    });
-                } catch(ex) {
-                    if (ex instanceof UglifyJS.JS_Parse_Error) {
-                        print_error("Parse error at " + file + ":" + ex.line + "," + ex.col);
-                        var col = ex.col;
-                        var lines = code.split(/\r?\n/);
-                        var line = lines[ex.line - 1];
-                        if (!line && !col) {
-                            line = lines[ex.line - 2];
-                            col = line.length;
-                        }
-                        if (line) {
-                            if (col > 40) {
-                                line = line.slice(col - 40);
-                                col = 40;
-                            }
-                            print_error(line.slice(0, 80));
-                            print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
-                        }
-                        print_error(ex.stack);
-                        process.exit(1);
-                    }
-                    throw ex;
-                }
-            };
-        });
-        cb();
-    });
-}();
-
-function done() {
-    var OUTPUT_FILE = ARGS.o;
-
-    var SOURCE_MAP = (ARGS.source_map || ARGS.source_map_inline) ? UglifyJS.SourceMap({
-        file: P_RELATIVE ? path.relative(path.dirname(ARGS.source_map), OUTPUT_FILE) : OUTPUT_FILE,
-        root: ARGS.source_map_root || ORIG_MAP && ORIG_MAP.sourceRoot,
-        orig: ORIG_MAP,
-    }) : null;
-
-    OUTPUT_OPTIONS.source_map = SOURCE_MAP;
-
-    try {
-        var output = UglifyJS.OutputStream(OUTPUT_OPTIONS);
-        var compressor = COMPRESS && UglifyJS.Compressor(COMPRESS);
-    } catch(ex) {
-        if (ex instanceof UglifyJS.DefaultsError) {
-            print_error(ex.message);
-            print_error("Supported options:");
-            print_error(sys.inspect(ex.defs));
-            process.exit(1);
         }
+    } catch (ex) {
+        fatal(ex);
     }
-
-    if (ARGS.acorn || ARGS.spidermonkey) time_it("convert_ast", function(){
-        TOPLEVEL = UglifyJS.AST_Node.from_mozilla_ast(TOPLEVEL);
-    });
-
-    if (ARGS.wrap != null) {
-        TOPLEVEL = TOPLEVEL.wrap_commonjs(ARGS.wrap, ARGS.export_all);
-    }
-
-    if (ARGS.enclose != null) {
-        var arg_parameter_list = ARGS.enclose;
-        if (arg_parameter_list === true) {
-            arg_parameter_list = [];
-        }
-        else if (!(arg_parameter_list instanceof Array)) {
-            arg_parameter_list = [arg_parameter_list];
+    var result = UglifyJS.minify(files, options);
+    if (result.error) {
+        var ex = result.error;
+        if (ex.name == "SyntaxError") {
+            print_error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
+            var col = ex.col;
+            var lines = files[ex.filename].split(/\r?\n/);
+            var line = lines[ex.line - 1];
+            if (!line && !col) {
+                line = lines[ex.line - 2];
+                col = line.length;
+            }
+            if (line) {
+                var limit = 70;
+                if (col > limit) {
+                    line = line.slice(col - limit);
+                    col = limit;
+                }
+                print_error(line.slice(0, 80));
+                print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
+            }
         }
-        TOPLEVEL = TOPLEVEL.wrap_enclose(arg_parameter_list);
-    }
-
-    if (ARGS.mangle_props || ARGS.name_cache) (function(){
-        var reserved = RESERVED ? RESERVED.props : null;
-        var cache = readNameCache("props");
-        var regex;
-
-        try {
-          regex = ARGS.mangle_regex ? extractRegex(ARGS.mangle_regex) : null;
-        } catch (e) {
-            print_error("ERROR: Invalid --mangle-regex: " + e.message);
-            process.exit(1);
+        if (ex.defs) {
+            print_error("Supported options:");
+            print_error(format_object(ex.defs));
         }
-
-        TOPLEVEL = UglifyJS.mangle_properties(TOPLEVEL, {
-            reserved      : reserved,
-            cache         : cache,
-            only_cache    : !ARGS.mangle_props,
-            regex         : regex,
-            ignore_quoted : ARGS.mangle_props == 2,
-            debug         : typeof ARGS.mangle_props_debug === "undefined" ? false : ARGS.mangle_props_debug
-        });
-        writeNameCache("props", cache);
-    })();
-
-    var SCOPE_IS_NEEDED = COMPRESS || MANGLE || ARGS.lint
-    var TL_CACHE = readNameCache("vars");
-    if (MANGLE) MANGLE.cache = TL_CACHE;
-
-    if (SCOPE_IS_NEEDED) {
-        time_it("scope", function(){
-            TOPLEVEL.figure_out_scope(MANGLE || { screw_ie8: screw_ie8, cache: TL_CACHE });
-            if (ARGS.lint) {
-                TOPLEVEL.scope_warnings();
-            }
-        });
-    }
-
-    if (COMPRESS) {
-        time_it("squeeze", function(){
-            TOPLEVEL = compressor.compress(TOPLEVEL);
-        });
-    }
-
-    if (SCOPE_IS_NEEDED) {
-        time_it("scope", function(){
-            TOPLEVEL.figure_out_scope(MANGLE || { screw_ie8: screw_ie8, cache: TL_CACHE });
-            if (MANGLE && !TL_CACHE) {
-                TOPLEVEL.compute_char_frequency(MANGLE);
+        fatal(ex);
+    } else if (program.output == "ast") {
+        print(JSON.stringify(result.ast, function(key, value) {
+            if (skip_key(key)) return;
+            if (value instanceof UglifyJS.AST_Token) return;
+            if (value instanceof UglifyJS.Dictionary) return;
+            if (value instanceof UglifyJS.AST_Node) {
+                var result = {
+                    _class: "AST_" + value.TYPE
+                };
+                value.CTOR.PROPS.forEach(function(prop) {
+                    result[prop] = value[prop];
+                });
+                return result;
             }
-        });
-    }
-
-    if (MANGLE) time_it("mangle", function(){
-        TOPLEVEL.mangle_names(MANGLE);
-    });
-
-    writeNameCache("vars", TL_CACHE);
-
-    if (ARGS.source_map_include_sources) {
-        for (var file in SOURCES_CONTENT) {
-            if (SOURCES_CONTENT.hasOwnProperty(file)) {
-                SOURCE_MAP.get().setSourceContent(file, SOURCES_CONTENT[file]);
+            return value;
+        }, 2));
+    } else if (program.output == "spidermonkey") {
+        print(JSON.stringify(UglifyJS.minify(result.code, {
+            compress: false,
+            mangle: false,
+            output: {
+                ast: true,
+                code: false
             }
+        }).ast.to_mozilla_ast(), null, 2));
+    } else if (program.output) {
+        fs.writeFileSync(program.output, result.code);
+        if (result.map) {
+            fs.writeFileSync(program.output + ".map", result.map);
         }
-    }
-
-    if (ARGS.dump_spidermonkey_ast) {
-        print(JSON.stringify(TOPLEVEL.to_mozilla_ast(), null, 2));
     } else {
-        time_it("generate", function(){
-            TOPLEVEL.print(output);
-        });
-
-        output = output.get();
+        print(result.code);
+    }
+    if (program.nameCache) {
+        fs.writeFileSync(program.nameCache, JSON.stringify(options.nameCache));
+    }
+    if (result.timings) for (var phase in result.timings) {
+        print_error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
+    }
+}
 
-        if (SOURCE_MAP) {
-            if (ARGS.source_map_inline) {
-                var base64_string = new Buffer(SOURCE_MAP.toString()).toString('base64');
-                output += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + base64_string;
-            } else {
-                fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
-                var source_map_url = ARGS.source_map_url || (
-                    P_RELATIVE
-                        ? path.relative(path.dirname(OUTPUT_FILE), ARGS.source_map)
-                        : ARGS.source_map
-                );
-                output += "\n//# sourceMappingURL=" + source_map_url;
-            }
-        }
+function fatal(message) {
+    if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
+    print_error(message);
+    process.exit(1);
+}
 
-        if (OUTPUT_FILE) {
-            fs.writeFileSync(OUTPUT_FILE, output, "utf8");
-        } else {
-            print(output);
-        }
+// A file glob function that only supports "*" and "?" wildcards in the basename.
+// Example: "foo/bar/*baz??.*.js"
+// Argument `glob` may be a string or an array of strings.
+// Returns an array of strings. Garbage in, garbage out.
+function simple_glob(glob) {
+    if (Array.isArray(glob)) {
+        return [].concat.apply([], glob.map(simple_glob));
     }
-
-    if (ARGS.stats) {
-        print_error(UglifyJS.string_template("Timing information (compressed {count} files):", {
-            count: files.length
-        }));
-        for (var i in STATS) if (STATS.hasOwnProperty(i)) {
-            print_error(UglifyJS.string_template("- {name}: {time}s", {
-                name: i,
-                time: (STATS[i] / 1000).toFixed(3)
-            }));
+    if (glob.match(/\*|\?/)) {
+        var dir = path.dirname(glob);
+        try {
+            var entries = fs.readdirSync(dir);
+        } catch (ex) {}
+        if (entries) {
+            var pattern = "^" + path.basename(glob)
+                .replace(/[.+^$[\]\\(){}]/g, "\\$&")
+                .replace(/\*/g, "[^/\\\\]*")
+                .replace(/\?/g, "[^/\\\\]") + "$";
+            var mod = process.platform === "win32" ? "i" : "";
+            var rx = new RegExp(pattern, mod);
+            var results = entries.filter(function(name) {
+                return rx.test(name);
+            }).map(function(name) {
+                return path.join(dir, name);
+            });
+            if (results.length) return results;
         }
     }
+    return [ glob ];
 }
 
-/* -----[ functions ]----- */
-
-function normalize(o) {
-    for (var i in o) if (o.hasOwnProperty(i) && /-/.test(i)) {
-        o[i.replace(/-/g, "_")] = o[i];
-        delete o[i];
+function read_file(path, default_value) {
+    try {
+        return fs.readFileSync(path, "utf8");
+    } catch (ex) {
+        if (ex.code == "ENOENT" && default_value != null) return default_value;
+        fatal(ex);
     }
 }
 
-function getOptions(flag, constants) {
-    var x = ARGS[flag];
-    if (x == null || x === false) return null;
-    var ret = {};
-    if (x !== "") {
-        if (Array.isArray(x)) x = x.map(function (v) { return "(" + v + ")"; }).join(", ");
-
-        var ast;
+function parse_js(flag) {
+    return function(value, options) {
+        options = options || {};
         try {
-            ast = UglifyJS.parse(x, { cli: true, expression: true });
+            UglifyJS.minify(value, {
+                parse: {
+                    expression: true
+                },
+                compress: false,
+                mangle: false,
+                output: {
+                    ast: true,
+                    code: false
+                }
+            }).ast.walk(new UglifyJS.TreeWalker(function(node) {
+                if (node instanceof UglifyJS.AST_Assign) {
+                    var name = node.left.print_to_string();
+                    var value = node.right;
+                    if (flag) {
+                        options[name] = value;
+                    } else if (value instanceof UglifyJS.AST_Array) {
+                        options[name] = value.elements.map(to_string);
+                    } else {
+                        options[name] = to_string(value);
+                    }
+                    return true;
+                }
+                if (node instanceof UglifyJS.AST_Symbol || node instanceof UglifyJS.AST_PropAccess) {
+                    var name = node.print_to_string();
+                    options[name] = true;
+                    return true;
+                }
+                if (!(node instanceof UglifyJS.AST_Sequence)) throw node;
+
+                function to_string(value) {
+                    return value instanceof UglifyJS.AST_Constant ? value.getValue() : value.print_to_string({
+                        quote_keys: true
+                    });
+                }
+            }));
         } catch(ex) {
-            if (ex instanceof UglifyJS.JS_Parse_Error) {
-                print_error("Error parsing arguments for flag `" + flag + "': " + x);
-                process.exit(1);
+            if (flag) {
+                fatal("Error parsing arguments for '" + flag + "': " + value);
+            } else {
+                options[value] = null;
             }
         }
-        ast.walk(new UglifyJS.TreeWalker(function(node){
-            if (node instanceof UglifyJS.AST_Seq) return; // descend
-            if (node instanceof UglifyJS.AST_Assign) {
-                var name = node.left.print_to_string().replace(/-/g, "_");
-                var value = node.right;
-                if (constants)
-                    value = new Function("return (" + value.print_to_string() + ")")();
-                ret[name] = value;
-                return true;    // no descend
-            }
-            if (node instanceof UglifyJS.AST_Symbol || node instanceof UglifyJS.AST_Binary) {
-                var name = node.print_to_string().replace(/-/g, "_");
-                ret[name] = true;
-                return true;    // no descend
-            }
-            print_error(node.TYPE)
-            print_error("Error parsing arguments for flag `" + flag + "': " + x);
-            process.exit(1);
-        }));
+        return options;
     }
-    return ret;
 }
 
-function read_whole_file(filename, cb) {
-    if (filename == "-") {
-        var chunks = [];
-        process.stdin.setEncoding('utf-8');
-        process.stdin.on('data', function (chunk) {
-            chunks.push(chunk);
-        }).on('end', function () {
-            cb(null, chunks.join(""));
-        });
-        process.openStdin();
-    } else {
-        fs.readFile(filename, "utf-8", cb);
+function parse_source_map() {
+    var parse = parse_js();
+    return function(value, options) {
+        var hasContent = options && "content" in options;
+        var settings = parse(value, options);
+        if (!hasContent && settings.content && settings.content != "inline") {
+            print_error("INFO: Using input source map: " + settings.content);
+            settings.content = read_file(settings.content, settings.content);
+        }
+        return settings;
     }
 }
 
-function read_source_map(code) {
-    var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
-    if (!match) {
-        print_error("WARN: inline source map not found");
-        return null;
-    }
-    return JSON.parse(new Buffer(match[2], "base64"));
+function skip_key(key) {
+    return skip_keys.indexOf(key) >= 0;
 }
 
-function time_it(name, cont) {
-    var t1 = new Date().getTime();
-    var ret = cont();
-    if (ARGS.stats) {
-        var spent = new Date().getTime() - t1;
-        if (STATS[name]) STATS[name] += spent;
-        else STATS[name] = spent;
-    }
-    return ret;
+function format_object(obj) {
+    var lines = [];
+    var padding = "";
+    Object.keys(obj).map(function(name) {
+        if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
+        return [ name, JSON.stringify(obj[name]) ];
+    }).forEach(function(tokens) {
+        lines.push("  " + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
+    });
+    return lines.join("\n");
 }
 
 function print_error(msg) {
-    console.error("%s", msg);
+    process.stderr.write(msg);
+    process.stderr.write("\n");
 }
 
 function print(txt) {
-    console.log("%s", txt);
+    process.stdout.write(txt);
+    process.stdout.write("\n");
 }
diff --git a/node_modules/uglify-js/lib/ast.js b/node_modules/uglify-js/lib/ast.js
index 028772f3f..0918574d1 100644
--- a/node_modules/uglify-js/lib/ast.js
+++ b/node_modules/uglify-js/lib/ast.js
@@ -182,21 +182,13 @@ var AST_BlockStatement = DEFNODE("BlockStatement", null, {
 }, AST_Block);
 
 var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
-    $documentation: "The empty statement (empty block or simply a semicolon)",
-    _walk: function(visitor) {
-        return visitor._visit(this);
-    }
+    $documentation: "The empty statement (empty block or simply a semicolon)"
 }, AST_Statement);
 
 var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
     $documentation: "Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`",
     $propdoc: {
         body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
-    },
-    _walk: function(visitor) {
-        return visitor._visit(this, function(){
-            this.body._walk(visitor);
-        });
     }
 }, AST_Statement);
 
@@ -326,62 +318,13 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     $propdoc: {
         globals: "[Object/S] a map of name -> SymbolDef for all undeclared names",
     },
-    wrap_enclose: function(arg_parameter_pairs) {
-        var self = this;
-        var args = [];
-        var parameters = [];
-
-        arg_parameter_pairs.forEach(function(pair) {
-            var splitAt = pair.lastIndexOf(":");
-
-            args.push(pair.substr(0, splitAt));
-            parameters.push(pair.substr(splitAt + 1));
-        });
-
-        var wrapped_tl = "(function(" + parameters.join(",") + "){ '$ORIG'; })(" + args.join(",") + ")";
+    wrap_commonjs: function(name) {
+        var body = this.body;
+        var wrapped_tl = "(function(exports){'$ORIG';})(typeof " + name + "=='undefined'?(" + name + "={}):" + name + ");";
         wrapped_tl = parse(wrapped_tl);
         wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){
             if (node instanceof AST_Directive && node.value == "$ORIG") {
-                return MAP.splice(self.body);
-            }
-        }));
-        return wrapped_tl;
-    },
-    wrap_commonjs: function(name, export_all) {
-        var self = this;
-        var to_export = [];
-        if (export_all) {
-            self.figure_out_scope();
-            self.walk(new TreeWalker(function(node){
-                if (node instanceof AST_SymbolDeclaration && node.definition().global) {
-                    if (!find_if(function(n){ return n.name == node.name }, to_export))
-                        to_export.push(node);
-                }
-            }));
-        }
-        var wrapped_tl = "(function(exports, global){ '$ORIG'; '$EXPORTS'; global['" + name + "'] = exports; }({}, (function(){return this}())))";
-        wrapped_tl = parse(wrapped_tl);
-        wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){
-            if (node instanceof AST_Directive) {
-                switch (node.value) {
-                  case "$ORIG":
-                    return MAP.splice(self.body);
-                  case "$EXPORTS":
-                    var body = [];
-                    to_export.forEach(function(sym){
-                        body.push(new AST_SimpleStatement({
-                            body: new AST_Assign({
-                                left: new AST_Sub({
-                                    expression: new AST_SymbolRef({ name: "exports" }),
-                                    property: new AST_String({ value: sym.name }),
-                                }),
-                                operator: "=",
-                                right: new AST_SymbolRef(sym),
-                            }),
-                        }));
-                    });
-                    return MAP.splice(body);
-                }
+                return MAP.splice(body);
             }
         }));
         return wrapped_tl;
@@ -552,10 +495,10 @@ var AST_Finally = DEFNODE("Finally", null, {
     $documentation: "A `finally` node; only makes sense as part of a `try` statement"
 }, AST_Block);
 
-/* -----[ VAR/CONST ]----- */
+/* -----[ VAR ]----- */
 
 var AST_Definitions = DEFNODE("Definitions", "definitions", {
-    $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
+    $documentation: "Base class for `var` nodes (variable declarations/initializations)",
     $propdoc: {
         definitions: "[AST_VarDef*] array of variable definitions"
     },
@@ -573,14 +516,10 @@ var AST_Var = DEFNODE("Var", null, {
     $documentation: "A `var` statement"
 }, AST_Definitions);
 
-var AST_Const = DEFNODE("Const", null, {
-    $documentation: "A `const` statement"
-}, AST_Definitions);
-
 var AST_VarDef = DEFNODE("VarDef", "name value", {
     $documentation: "A variable declaration; only appears in a AST_Definitions node",
     $propdoc: {
-        name: "[AST_SymbolVar|AST_SymbolConst] name of the variable",
+        name: "[AST_SymbolVar] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer"
     },
     _walk: function(visitor) {
@@ -601,11 +540,11 @@ var AST_Call = DEFNODE("Call", "expression args", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.expression._walk(visitor);
             var args = this.args;
             for (var i = 0, len = args.length; i < len; i++) {
                 args[i]._walk(visitor);
             }
+            this.expression._walk(visitor);
         });
     }
 });
@@ -614,68 +553,16 @@ var AST_New = DEFNODE("New", null, {
     $documentation: "An object instantiation.  Derives from a function call since it has exactly the same properties"
 }, AST_Call);
 
-var AST_Seq = DEFNODE("Seq", "car cdr", {
-    $documentation: "A sequence expression (two comma-separated expressions)",
+var AST_Sequence = DEFNODE("Sequence", "expressions", {
+    $documentation: "A sequence expression (comma-separated expressions)",
     $propdoc: {
-        car: "[AST_Node] first element in sequence",
-        cdr: "[AST_Node] second element in sequence"
-    },
-    $cons: function(x, y) {
-        var seq = new AST_Seq(x);
-        seq.car = x;
-        seq.cdr = y;
-        return seq;
-    },
-    $from_array: function(array) {
-        if (array.length == 0) return null;
-        if (array.length == 1) return array[0].clone();
-        var list = null;
-        for (var i = array.length; --i >= 0;) {
-            list = AST_Seq.cons(array[i], list);
-        }
-        var p = list;
-        while (p) {
-            if (p.cdr && !p.cdr.cdr) {
-                p.cdr = p.cdr.car;
-                break;
-            }
-            p = p.cdr;
-        }
-        return list;
-    },
-    to_array: function() {
-        var p = this, a = [];
-        while (p) {
-            a.push(p.car);
-            if (p.cdr && !(p.cdr instanceof AST_Seq)) {
-                a.push(p.cdr);
-                break;
-            }
-            p = p.cdr;
-        }
-        return a;
-    },
-    add: function(node) {
-        var p = this;
-        while (p) {
-            if (!(p.cdr instanceof AST_Seq)) {
-                var cell = AST_Seq.cons(p.cdr, node);
-                return p.cdr = cell;
-            }
-            p = p.cdr;
-        }
-    },
-    len: function() {
-        if (this.cdr instanceof AST_Seq) {
-            return this.cdr.len() + 1;
-        } else {
-            return 2;
-        }
+        expressions: "[AST_Node*] array of expressions (at least two)"
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.car._walk(visitor);
-            if (this.cdr) this.cdr._walk(visitor);
+            this.expressions.forEach(function(node) {
+                node._walk(visitor);
+            });
         });
     }
 });
@@ -728,7 +615,7 @@ var AST_UnaryPostfix = DEFNODE("UnaryPostfix", null, {
     $documentation: "Unary postfix expression, i.e. `i++`"
 }, AST_Unary);
 
-var AST_Binary = DEFNODE("Binary", "left operator right", {
+var AST_Binary = DEFNODE("Binary", "operator left right", {
     $documentation: "Binary expression, i.e. `a + b`",
     $propdoc: {
         left: "[AST_Node] left-hand side expression",
@@ -837,17 +724,13 @@ var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
 }, AST_Symbol);
 
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
-    $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
+    $documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)",
 }, AST_Symbol);
 
 var AST_SymbolVar = DEFNODE("SymbolVar", null, {
     $documentation: "Symbol defining a variable",
 }, AST_SymbolDeclaration);
 
-var AST_SymbolConst = DEFNODE("SymbolConst", null, {
-    $documentation: "A constant declaration"
-}, AST_SymbolDeclaration);
-
 var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
     $documentation: "Symbol naming a function argument",
 }, AST_SymbolVar);
@@ -976,13 +859,13 @@ TreeWalker.prototype = {
         if (!ret && descend) {
             descend.call(node);
         }
-        this.pop(node);
+        this.pop();
         return ret;
     },
     parent: function(n) {
         return this.stack[this.stack.length - 2 - (n || 0)];
     },
-    push: function (node) {
+    push: function(node) {
         if (node instanceof AST_Lambda) {
             this.directives = Object.create(this.directives);
         } else if (node instanceof AST_Directive && !this.directives[node.value]) {
@@ -990,9 +873,8 @@ TreeWalker.prototype = {
         }
         this.stack.push(node);
     },
-    pop: function(node) {
-        this.stack.pop();
-        if (node instanceof AST_Lambda) {
+    pop: function() {
+        if (this.stack.pop() instanceof AST_Lambda) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },
diff --git a/node_modules/uglify-js/lib/compress.js b/node_modules/uglify-js/lib/compress.js
index d8a491ebc..7a16ba86b 100644
--- a/node_modules/uglify-js/lib/compress.js
+++ b/node_modules/uglify-js/lib/compress.js
@@ -48,7 +48,6 @@ function Compressor(options, false_by_default) {
         return new Compressor(options, false_by_default);
     TreeTransformer.call(this, this.before, this.after);
     this.options = defaults(options, {
-        angular       : false,
         booleans      : !false_by_default,
         cascade       : !false_by_default,
         collapse_vars : !false_by_default,
@@ -62,7 +61,9 @@ function Compressor(options, false_by_default) {
         global_defs   : {},
         hoist_funs    : !false_by_default,
         hoist_vars    : false,
+        ie8           : false,
         if_return     : !false_by_default,
+        inline        : !false_by_default,
         join_vars     : !false_by_default,
         keep_fargs    : true,
         keep_fnames   : false,
@@ -74,20 +75,29 @@ function Compressor(options, false_by_default) {
         pure_getters  : !false_by_default && "strict",
         pure_funcs    : null,
         reduce_vars   : !false_by_default,
-        screw_ie8     : true,
         sequences     : !false_by_default,
         side_effects  : !false_by_default,
         switches      : !false_by_default,
         top_retain    : null,
         toplevel      : !!(options && options["top_retain"]),
+        typeofs       : !false_by_default,
         unsafe        : false,
         unsafe_comps  : false,
+        unsafe_Func   : false,
         unsafe_math   : false,
         unsafe_proto  : false,
         unsafe_regexp : false,
         unused        : !false_by_default,
-        warnings      : true,
+        warnings      : false,
     }, true);
+    var global_defs = this.options["global_defs"];
+    if (typeof global_defs == "object") for (var key in global_defs) {
+        if (/^@/.test(key) && HOP(global_defs, key)) {
+            global_defs[key.slice(1)] = parse(global_defs[key], {
+                expression: true
+            });
+        }
+    }
     var pure_funcs = this.options["pure_funcs"];
     if (typeof pure_funcs == "function") {
         this.pure_funcs = pure_funcs;
@@ -111,26 +121,50 @@ function Compressor(options, false_by_default) {
             return top_retain.indexOf(def.name) >= 0;
         };
     }
+    var toplevel = this.options["toplevel"];
+    this.toplevel = typeof toplevel == "string" ? {
+        funcs: /funcs/.test(toplevel),
+        vars: /vars/.test(toplevel)
+    } : {
+        funcs: toplevel,
+        vars: toplevel
+    };
     var sequences = this.options["sequences"];
-    this.sequences_limit = sequences == 1 ? 200 : sequences | 0;
+    this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
     this.warnings_produced = {};
 };
 
 Compressor.prototype = new TreeTransformer;
 merge(Compressor.prototype, {
     option: function(key) { return this.options[key] },
+    exposed: function(def) {
+        if (def.global) for (var i = 0, len = def.orig.length; i < len; i++)
+            if (!this.toplevel[def.orig[i] instanceof AST_SymbolDefun ? "funcs" : "vars"])
+                return true;
+        return false;
+    },
     compress: function(node) {
         if (this.option("expression")) {
-            node = node.process_expression(true);
+            node.process_expression(true);
         }
         var passes = +this.options.passes || 1;
-        for (var pass = 0; pass < passes && pass < 3; ++pass) {
+        var last_count = 1 / 0;
+        for (var pass = 0; pass < passes; pass++) {
             if (pass > 0 || this.option("reduce_vars"))
                 node.reset_opt_flags(this, true);
             node = node.transform(this);
+            if (passes > 1) {
+                var count = 0;
+                node.walk(new TreeWalker(function() {
+                    count++;
+                }));
+                this.info("pass " + pass + ": last_count: " + last_count + ", count: " + count);
+                if (count >= last_count) break;
+                last_count = count;
+            }
         }
         if (this.option("expression")) {
-            node = node.process_expression(false);
+            node.process_expression(false);
         }
         return node;
     },
@@ -202,7 +236,7 @@ merge(Compressor.prototype, {
         return this.TYPE == node.TYPE && this.print_to_string() == node.print_to_string();
     });
 
-    AST_Node.DEFMETHOD("process_expression", function(insert, compressor) {
+    AST_Scope.DEFMETHOD("process_expression", function(insert, compressor) {
         var self = this;
         var tt = new TreeTransformer(function(node) {
             if (insert && node instanceof AST_SimpleStatement) {
@@ -246,21 +280,20 @@ merge(Compressor.prototype, {
             }
             return node;
         });
-        return self.transform(tt);
+        self.transform(tt);
     });
 
-    AST_Node.DEFMETHOD("reset_opt_flags", function(compressor, rescan){
+    AST_Node.DEFMETHOD("reset_opt_flags", function(compressor, rescan) {
         var reduce_vars = rescan && compressor.option("reduce_vars");
-        var toplevel = compressor.option("toplevel");
         var safe_ids = Object.create(null);
         var suppressor = new TreeWalker(function(node) {
-            if (node instanceof AST_Symbol) {
-                var d = node.definition();
-                if (node instanceof AST_SymbolRef) d.references.push(node);
-                d.fixed = false;
-            }
+            if (!(node instanceof AST_Symbol)) return;
+            var d = node.definition();
+            if (!d) return;
+            if (node instanceof AST_SymbolRef) d.references.push(node);
+            d.fixed = false;
         });
-        var tw = new TreeWalker(function(node, descend){
+        var tw = new TreeWalker(function(node, descend) {
             node._squeezed = false;
             node._optimized = false;
             if (reduce_vars) {
@@ -269,8 +302,8 @@ merge(Compressor.prototype, {
                 if (node instanceof AST_SymbolRef) {
                     var d = node.definition();
                     d.references.push(node);
-                    if (d.fixed === undefined || !is_safe(d)
-                        || is_modified(node, 0, node.fixed_value() instanceof AST_Lambda)) {
+                    if (d.fixed === undefined || !safe_to_read(d)
+                        || is_modified(node, 0, is_immutable(node.fixed_value()))) {
                         d.fixed = false;
                     } else {
                         var parent = tw.parent();
@@ -287,7 +320,7 @@ merge(Compressor.prototype, {
                 }
                 if (node instanceof AST_VarDef) {
                     var d = node.name.definition();
-                    if (d.fixed == null) {
+                    if (d.fixed === undefined || safe_to_assign(d, node.value)) {
                         if (node.value) {
                             d.fixed = function() {
                                 return node.value;
@@ -303,9 +336,24 @@ merge(Compressor.prototype, {
                         d.fixed = false;
                     }
                 }
+                if (node instanceof AST_Assign
+                    && node.operator == "="
+                    && node.left instanceof AST_SymbolRef) {
+                    var d = node.left.definition();
+                    if (safe_to_assign(d, node.right)) {
+                        d.references.push(node.left);
+                        d.fixed = function() {
+                            return node.right;
+                        };
+                        mark(d, false);
+                        node.right.walk(tw);
+                        mark(d, true);
+                        return true;
+                    }
+                }
                 if (node instanceof AST_Defun) {
                     var d = node.name.definition();
-                    if (!toplevel && d.global || is_safe(d)) {
+                    if (compressor.exposed(d) || safe_to_read(d)) {
                         d.fixed = false;
                     } else {
                         d.fixed = node;
@@ -367,7 +415,7 @@ merge(Compressor.prototype, {
                     pop();
                     return true;
                 }
-                if (node instanceof AST_If || node instanceof AST_DWLoop) {
+                if (node instanceof AST_If) {
                     node.condition.walk(tw);
                     push();
                     node.body.walk(tw);
@@ -379,6 +427,13 @@ merge(Compressor.prototype, {
                     }
                     return true;
                 }
+                if (node instanceof AST_DWLoop) {
+                    push();
+                    node.condition.walk(tw);
+                    node.body.walk(tw);
+                    pop();
+                    return true;
+                }
                 if (node instanceof AST_LabeledStatement) {
                     push();
                     node.body.walk(tw);
@@ -387,11 +442,19 @@ merge(Compressor.prototype, {
                 }
                 if (node instanceof AST_For) {
                     if (node.init) node.init.walk(tw);
+                    if (node.condition) {
+                        push();
+                        node.condition.walk(tw);
+                        pop();
+                    }
                     push();
-                    if (node.condition) node.condition.walk(tw);
                     node.body.walk(tw);
-                    if (node.step) node.step.walk(tw);
                     pop();
+                    if (node.step) {
+                        push();
+                        node.step.walk(tw);
+                        pop();
+                    }
                     return true;
                 }
                 if (node instanceof AST_ForIn) {
@@ -428,7 +491,7 @@ merge(Compressor.prototype, {
             safe_ids[def.id] = safe;
         }
 
-        function is_safe(def) {
+        function safe_to_read(def) {
             if (safe_ids[def.id]) {
                 if (def.fixed == null) {
                     var orig = def.orig[0];
@@ -439,6 +502,17 @@ merge(Compressor.prototype, {
             }
         }
 
+        function safe_to_assign(def, value) {
+            if (!HOP(safe_ids, def.id)) return false;
+            if (!safe_to_read(def)) return false;
+            if (def.fixed === false) return false;
+            if (def.fixed != null && (!value || def.references.length > 0)) return false;
+            return !def.orig.some(function(sym) {
+                return sym instanceof AST_SymbolDefun
+                    || sym instanceof AST_SymbolLambda;
+            });
+        }
+
         function push() {
             safe_ids = Object.create(safe_ids);
         }
@@ -451,7 +525,7 @@ merge(Compressor.prototype, {
             def.escaped = false;
             if (def.scope.uses_eval) {
                 def.fixed = false;
-            } else if (toplevel || !def.global || def.orig[0] instanceof AST_SymbolConst) {
+            } else if (!compressor.exposed(def)) {
                 def.fixed = undefined;
             } else {
                 def.fixed = false;
@@ -460,13 +534,17 @@ merge(Compressor.prototype, {
             def.should_replace = undefined;
         }
 
-        function is_modified(node, level, func) {
+        function is_immutable(value) {
+            return value && value.is_constant() || value instanceof AST_Lambda;
+        }
+
+        function is_modified(node, level, immutable) {
             var parent = tw.parent(level);
             if (is_lhs(node, parent)
-                || !func && parent instanceof AST_Call && parent.expression === node) {
+                || !immutable && parent instanceof AST_Call && parent.expression === node) {
                 return true;
             } else if (parent instanceof AST_PropAccess && parent.expression === node) {
-                return !func && is_modified(parent, level + 1);
+                return !immutable && is_modified(parent, level + 1);
             }
         }
     });
@@ -477,12 +555,25 @@ merge(Compressor.prototype, {
         return fixed();
     });
 
-    function is_reference_const(ref) {
-        if (!(ref instanceof AST_SymbolRef)) return false;
-        var orig = ref.definition().orig;
-        for (var i = orig.length; --i >= 0;) {
-            if (orig[i] instanceof AST_SymbolConst) return true;
+    AST_SymbolRef.DEFMETHOD("is_immutable", function() {
+        var orig = this.definition().orig;
+        return orig.length == 1 && orig[0] instanceof AST_SymbolLambda;
+    });
+
+    function is_lhs_read_only(lhs) {
+        if (lhs instanceof AST_SymbolRef) return lhs.definition().orig[0] instanceof AST_SymbolLambda;
+        if (lhs instanceof AST_PropAccess) {
+            lhs = lhs.expression;
+            if (lhs instanceof AST_SymbolRef) {
+                if (lhs.is_immutable()) return false;
+                lhs = lhs.fixed_value();
+            }
+            if (!lhs) return true;
+            if (lhs instanceof AST_RegExp) return false;
+            if (lhs instanceof AST_Constant) return true;
+            return is_lhs_read_only(lhs);
         }
+        return false;
     }
 
     function find_variable(compressor, name) {
@@ -506,6 +597,13 @@ merge(Compressor.prototype, {
         return new ctor(props);
     };
 
+    function make_sequence(orig, expressions) {
+        if (expressions.length == 1) return expressions[0];
+        return make_node(AST_Sequence, orig, {
+            expressions: expressions
+        });
+    }
+
     function make_node_from_constant(val, orig) {
         switch (typeof val) {
           case "string":
@@ -548,16 +646,19 @@ merge(Compressor.prototype, {
         if (parent instanceof AST_UnaryPrefix && parent.operator == "delete"
             || parent instanceof AST_Call && parent.expression === orig
                 && (val instanceof AST_PropAccess || val instanceof AST_SymbolRef && val.name == "eval")) {
-            return make_node(AST_Seq, orig, {
-                car: make_node(AST_Number, orig, {
-                    value: 0
-                }),
-                cdr: val
-            });
+            return make_sequence(orig, [ make_node(AST_Number, orig, { value: 0 }), val ]);
         }
         return val;
     }
 
+    function merge_sequence(array, node) {
+        if (node instanceof AST_Sequence) {
+            array.push.apply(array, node.expressions);
+        } else {
+            array.push(node);
+        }
+    }
+
     function as_statement_array(thing) {
         if (thing === null) return [];
         if (thing instanceof AST_BlockStatement) return thing.body;
@@ -588,436 +689,425 @@ merge(Compressor.prototype, {
         return false;
     }
 
+    function is_undeclared_ref(node) {
+        return node instanceof AST_SymbolRef && node.definition().undeclared;
+    }
+
+    var global_names = makePredicate("Array Boolean console Error Function Math Number RegExp Object String");
+    AST_SymbolRef.DEFMETHOD("is_declared", function(compressor) {
+        return !this.definition().undeclared
+            || compressor.option("unsafe") && global_names(this.name);
+    });
+
     function tighten_body(statements, compressor) {
         var CHANGED, max_iter = 10;
         do {
             CHANGED = false;
-            if (compressor.option("angular")) {
-                statements = process_for_angular(statements);
-            }
-            statements = eliminate_spurious_blocks(statements);
+            eliminate_spurious_blocks(statements);
             if (compressor.option("dead_code")) {
-                statements = eliminate_dead_code(statements, compressor);
+                eliminate_dead_code(statements, compressor);
             }
             if (compressor.option("if_return")) {
-                statements = handle_if_return(statements, compressor);
+                handle_if_return(statements, compressor);
             }
             if (compressor.sequences_limit > 0) {
-                statements = sequencesize(statements, compressor);
+                sequencesize(statements, compressor);
             }
             if (compressor.option("join_vars")) {
-                statements = join_consecutive_vars(statements, compressor);
+                join_consecutive_vars(statements, compressor);
             }
             if (compressor.option("collapse_vars")) {
-                statements = collapse_single_use_vars(statements, compressor);
+                collapse(statements, compressor);
             }
         } while (CHANGED && max_iter-- > 0);
 
-        return statements;
-
-        function collapse_single_use_vars(statements, compressor) {
-            // Iterate statements backwards looking for a statement with a var/const
-            // declaration immediately preceding it. Grab the rightmost var definition
-            // and if it has exactly one reference then attempt to replace its reference
-            // in the statement with the var value and then erase the var definition.
-
-            var self = compressor.self();
-            var var_defs_removed = false;
-            var toplevel = compressor.option("toplevel");
-            for (var stat_index = statements.length; --stat_index >= 0;) {
-                var stat = statements[stat_index];
-                if (stat instanceof AST_Definitions) continue;
-
-                // Process child blocks of statement if present.
-                [stat, stat.body, stat.alternative, stat.bcatch, stat.bfinally].forEach(function(node) {
-                    node && node.body && collapse_single_use_vars(node.body, compressor);
-                });
-
-                // The variable definition must precede a statement.
-                if (stat_index <= 0) break;
-                var prev_stat_index = stat_index - 1;
-                var prev_stat = statements[prev_stat_index];
-                if (!(prev_stat instanceof AST_Definitions)) continue;
-                var var_defs = prev_stat.definitions;
-                if (var_defs == null) continue;
-
-                var var_names_seen = {};
-                var side_effects_encountered = false;
-                var lvalues_encountered = false;
-                var lvalues = {};
-
-                // Scan variable definitions from right to left.
-                for (var var_defs_index = var_defs.length; --var_defs_index >= 0;) {
-
-                    // Obtain var declaration and var name with basic sanity check.
-                    var var_decl = var_defs[var_defs_index];
-                    if (var_decl.value == null) break;
-                    var var_name = var_decl.name.name;
-                    if (!var_name || !var_name.length) break;
-
-                    // Bail if we've seen a var definition of same name before.
-                    if (var_name in var_names_seen) break;
-                    var_names_seen[var_name] = true;
-
-                    // Only interested in cases with just one reference to the variable.
-                    var def = self.find_variable && self.find_variable(var_name);
-                    if (!def || !def.references || def.references.length !== 1
-                        || var_name == "arguments" || (!toplevel && def.global)) {
-                        side_effects_encountered = true;
-                        continue;
-                    }
-                    var ref = def.references[0];
-
-                    // Don't replace ref if eval() or with statement in scope.
-                    if (ref.scope.uses_eval || ref.scope.uses_with) break;
-
-                    // Constant single use vars can be replaced in any scope.
-                    if (var_decl.value.is_constant()) {
-                        var ctt = new TreeTransformer(function(node) {
-                            var parent = ctt.parent();
-                            if (parent instanceof AST_IterationStatement
-                                && (parent.condition === node || parent.init === node)) {
+        // Search from right to left for assignment-like expressions:
+        // - `var a = x;`
+        // - `a = x;`
+        // - `++a`
+        // For each candidate, scan from left to right for first usage, then try
+        // to fold assignment into the site for compression.
+        // Will not attempt to collapse assignments into or past code blocks
+        // which are not sequentially executed, e.g. loops and conditionals.
+        function collapse(statements, compressor) {
+            var scope = compressor.find_parent(AST_Scope);
+            if (scope.uses_eval || scope.uses_with) return statements;
+            var candidates = [];
+            var stat_index = statements.length;
+            while (--stat_index >= 0) {
+                // Treat parameters as collapsible in IIFE, i.e.
+                //   function(a, b){ ... }(x());
+                // would be translated into equivalent assignments:
+                //   var a = x(), b = undefined;
+                if (stat_index == 0 && compressor.option("unused")) extract_args();
+                // Find collapsible assignments
+                extract_candidates(statements[stat_index]);
+                while (candidates.length > 0) {
+                    var candidate = candidates.pop();
+                    var lhs = get_lhs(candidate);
+                    if (!lhs || is_lhs_read_only(lhs)) continue;
+                    // Locate symbols which may execute code outside of scanning range
+                    var lvalues = get_lvalues(candidate);
+                    if (lhs instanceof AST_SymbolRef) lvalues[lhs.name] = false;
+                    var side_effects = value_has_side_effects(candidate);
+                    var hit = candidate.name instanceof AST_SymbolFunarg;
+                    var abort = false, replaced = false;
+                    var tt = new TreeTransformer(function(node, descend) {
+                        if (abort) return node;
+                        // Skip nodes before `candidate` as quickly as possible
+                        if (!hit) {
+                            if (node === candidate) {
+                                hit = true;
                                 return node;
                             }
-                            if (node === ref)
-                                return replace_var(node, parent, true);
-                        });
-                        stat.transform(ctt);
-                        continue;
-                    }
-
-                    // Restrict var replacement to constants if side effects encountered.
-                    if (side_effects_encountered |= lvalues_encountered) continue;
-
-                    var value_has_side_effects = var_decl.value.has_side_effects(compressor);
-                    // Non-constant single use vars can only be replaced in same scope.
-                    if (ref.scope !== self) {
-                        side_effects_encountered |= value_has_side_effects;
-                        continue;
-                    }
-
-                    // Detect lvalues in var value.
-                    var tw = new TreeWalker(function(node){
-                        if (node instanceof AST_SymbolRef && is_lvalue(node, tw.parent())) {
-                            lvalues[node.name] = lvalues_encountered = true;
+                            return;
                         }
-                    });
-                    var_decl.value.walk(tw);
-
-                    // Replace the non-constant single use var in statement if side effect free.
-                    var unwind = false;
-                    var tt = new TreeTransformer(
-                        function preorder(node) {
-                            if (unwind) return node;
-                            var parent = tt.parent();
-                            if (node instanceof AST_Lambda
-                                || node instanceof AST_Try
-                                || node instanceof AST_With
-                                || node instanceof AST_Case
-                                || node instanceof AST_IterationStatement
-                                || (parent instanceof AST_If          && node !== parent.condition)
-                                || (parent instanceof AST_Conditional && node !== parent.condition)
-                                || (node instanceof AST_SymbolRef
-                                    && value_has_side_effects
-                                    && !are_references_in_scope(node.definition(), self))
-                                || (parent instanceof AST_Binary
-                                    && (parent.operator == "&&" || parent.operator == "||")
-                                    && node === parent.right)
-                                || (parent instanceof AST_Switch && node !== parent.expression)) {
-                                return side_effects_encountered = unwind = true, node;
+                        // Stop immediately if these node types are encountered
+                        var parent = tt.parent();
+                        if (node instanceof AST_Assign && node.operator != "=" && lhs.equivalent_to(node.left)
+                            || node instanceof AST_Call && lhs instanceof AST_PropAccess && lhs.equivalent_to(node.expression)
+                            || node instanceof AST_Debugger
+                            || node instanceof AST_IterationStatement && !(node instanceof AST_For)
+                            || node instanceof AST_SymbolRef && !node.is_declared(compressor)
+                            || node instanceof AST_Try
+                            || node instanceof AST_With
+                            || parent instanceof AST_For && node !== parent.init) {
+                            abort = true;
+                            return node;
+                        }
+                        // Replace variable with assignment when found
+                        if (!(node instanceof AST_SymbolDeclaration)
+                            && !is_lhs(node, parent)
+                            && lhs.equivalent_to(node)) {
+                            CHANGED = replaced = abort = true;
+                            compressor.info("Collapsing {name} [{file}:{line},{col}]", {
+                                name: node.print_to_string(),
+                                file: node.start.file,
+                                line: node.start.line,
+                                col: node.start.col
+                            });
+                            if (candidate instanceof AST_UnaryPostfix) {
+                                return make_node(AST_UnaryPrefix, candidate, candidate);
                             }
-                            function are_references_in_scope(def, scope) {
-                                if (def.orig.length === 1
-                                    && def.orig[0] instanceof AST_SymbolDefun) return true;
-                                if (def.scope !== scope) return false;
-                                var refs = def.references;
-                                for (var i = 0, len = refs.length; i < len; i++) {
-                                    if (refs[i].scope !== scope) return false;
+                            if (candidate instanceof AST_VarDef) {
+                                var def = candidate.name.definition();
+                                if (def.references.length == 1 && !compressor.exposed(def)) {
+                                    return maintain_this_binding(parent, node, candidate.value);
                                 }
-                                return true;
-                            }
-                        },
-                        function postorder(node) {
-                            if (unwind) return node;
-                            if (node === ref)
-                                return unwind = true, replace_var(node, tt.parent(), false);
-                            if (side_effects_encountered |= node.has_side_effects(compressor))
-                                return unwind = true, node;
-                            if (lvalues_encountered && node instanceof AST_SymbolRef && node.name in lvalues) {
-                                side_effects_encountered = true;
-                                return unwind = true, node;
+                                return make_node(AST_Assign, candidate, {
+                                    operator: "=",
+                                    left: make_node(AST_SymbolRef, candidate.name, candidate.name),
+                                    right: candidate.value
+                                });
                             }
+                            candidate.write_only = false;
+                            return candidate;
                         }
-                    );
-                    stat.transform(tt);
+                        // These node types have child nodes that execute sequentially,
+                        // but are otherwise not safe to scan into or beyond them.
+                        var sym;
+                        if (node instanceof AST_Call
+                            || node instanceof AST_Exit
+                            || node instanceof AST_PropAccess
+                            || node instanceof AST_SymbolRef
+                               && (lvalues[node.name]
+                                   || side_effects && !references_in_scope(node.definition()))
+                            || (sym = lhs_or_def(node)) && get_symbol(sym).name in lvalues
+                            || parent instanceof AST_Binary
+                                && (parent.operator == "&&" || parent.operator == "||")
+                            || parent instanceof AST_Case
+                            || parent instanceof AST_Conditional
+                            || parent instanceof AST_For
+                            || parent instanceof AST_If) {
+                            if (!(node instanceof AST_Scope)) descend(node, tt);
+                            abort = true;
+                            return node;
+                        }
+                        // Skip (non-executed) functions and (leading) default case in switch statements
+                        if (node instanceof AST_Default || node instanceof AST_Scope) return node;
+                    });
+                    for (var i = stat_index; !abort && i < statements.length; i++) {
+                        statements[i].transform(tt);
+                    }
+                    if (replaced && !remove_candidate(candidate)) statements.splice(stat_index, 1);
                 }
             }
 
-            // Remove extraneous empty statments in block after removing var definitions.
-            // Leave at least one statement in `statements`.
-            if (var_defs_removed) for (var i = statements.length; --i >= 0;) {
-                if (statements.length > 1 && statements[i] instanceof AST_EmptyStatement)
-                    statements.splice(i, 1);
+            function extract_args() {
+                var iife, fn = compressor.self();
+                if (fn instanceof AST_Function
+                    && !fn.name
+                    && !fn.uses_arguments
+                    && !fn.uses_eval
+                    && (iife = compressor.parent()) instanceof AST_Call
+                    && iife.expression === fn) {
+                    var names = Object.create(null);
+                    for (var i = fn.argnames.length; --i >= 0;) {
+                        var sym = fn.argnames[i];
+                        if (sym.name in names) continue;
+                        names[sym.name] = true;
+                        var arg = iife.args[i];
+                        if (!arg) arg = make_node(AST_Undefined, sym);
+                        else {
+                            var tw = new TreeWalker(function(node) {
+                                if (!arg) return true;
+                                if (node instanceof AST_SymbolRef && fn.variables.has(node.name)) {
+                                    var s = node.definition().scope;
+                                    if (s !== scope) while (s = s.parent_scope) {
+                                        if (s === scope) return true;
+                                    }
+                                    arg = null;
+                                }
+                                if (node instanceof AST_This && !tw.find_parent(AST_Scope)) {
+                                    arg = null;
+                                    return true;
+                                }
+                            });
+                            arg.walk(tw);
+                        }
+                        if (arg) candidates.unshift(make_node(AST_VarDef, sym, {
+                            name: sym,
+                            value: arg
+                        }));
+                    }
+                }
             }
 
-            return statements;
-
-            function is_lvalue(node, parent) {
-                return node instanceof AST_SymbolRef && is_lhs(node, parent);
+            function extract_candidates(expr) {
+                if (expr instanceof AST_Assign && !expr.left.has_side_effects(compressor)
+                    || expr instanceof AST_Unary && (expr.operator == "++" || expr.operator == "--")) {
+                    candidates.push(expr);
+                } else if (expr instanceof AST_Sequence) {
+                    expr.expressions.forEach(extract_candidates);
+                } else if (expr instanceof AST_Definitions) {
+                    expr.definitions.forEach(function(var_def) {
+                        if (var_def.value) candidates.push(var_def);
+                    });
+                } else if (expr instanceof AST_SimpleStatement) {
+                    extract_candidates(expr.body);
+                } else if (expr instanceof AST_For && expr.init) {
+                    extract_candidates(expr.init);
+                }
             }
-            function replace_var(node, parent, is_constant) {
-                if (is_lvalue(node, parent)) return node;
 
-                // Remove var definition and return its value to the TreeTransformer to replace.
-                var value = maintain_this_binding(parent, node, var_decl.value);
-                var_decl.value = null;
-
-                var_defs.splice(var_defs_index, 1);
-                if (var_defs.length === 0) {
-                    statements[prev_stat_index] = make_node(AST_EmptyStatement, self);
-                    var_defs_removed = true;
+            function get_lhs(expr) {
+                if (expr instanceof AST_VarDef) {
+                    var def = expr.name.definition();
+                    if (def.orig.length > 1 && !(expr.name instanceof AST_SymbolFunarg)
+                        || def.references.length == 1 && !compressor.exposed(def)) {
+                        return make_node(AST_SymbolRef, expr.name, expr.name);
+                    }
+                } else {
+                    return expr[expr instanceof AST_Assign ? "left" : "expression"];
                 }
-                // Further optimize statement after substitution.
-                stat.reset_opt_flags(compressor);
-
-                compressor.info("Collapsing " + (is_constant ? "constant" : "variable") +
-                    " " + var_name + " [{file}:{line},{col}]", node.start);
-                CHANGED = true;
-                return value;
             }
-        }
 
-        function process_for_angular(statements) {
-            function has_inject(comment) {
-                return /@ngInject/.test(comment.value);
+            function get_symbol(node) {
+                while (node instanceof AST_PropAccess) node = node.expression;
+                return node;
             }
-            function make_arguments_names_list(func) {
-                return func.argnames.map(function(sym){
-                    return make_node(AST_String, sym, { value: sym.name });
+
+            function get_lvalues(expr) {
+                var lvalues = Object.create(null);
+                if (expr instanceof AST_Unary) return lvalues;
+                var scope;
+                var tw = new TreeWalker(function(node, descend) {
+                    if (node instanceof AST_Scope) {
+                        var save_scope = scope;
+                        descend();
+                        scope = save_scope;
+                        return true;
+                    }
+                    if (node instanceof AST_SymbolRef || node instanceof AST_PropAccess) {
+                        var sym = get_symbol(node);
+                        if (sym instanceof AST_SymbolRef) {
+                            lvalues[sym.name] = lvalues[sym.name] || is_lhs(node, tw.parent());
+                        }
+                    }
                 });
+                expr[expr instanceof AST_Assign ? "right" : "value"].walk(tw);
+                return lvalues;
             }
-            function make_array(orig, elements) {
-                return make_node(AST_Array, orig, { elements: elements });
-            }
-            function make_injector(func, name) {
-                return make_node(AST_SimpleStatement, func, {
-                    body: make_node(AST_Assign, func, {
-                        operator: "=",
-                        left: make_node(AST_Dot, name, {
-                            expression: make_node(AST_SymbolRef, name, name),
-                            property: "$inject"
-                        }),
-                        right: make_array(func, make_arguments_names_list(func))
-                    })
-                });
+
+            function lhs_or_def(node) {
+                if (node instanceof AST_VarDef) return node.value && node.name;
+                return is_lhs(node.left, node);
             }
-            function check_expression(body) {
-                if (body && body.args) {
-                    // if this is a function call check all of arguments passed
-                    body.args.forEach(function(argument, index, array) {
-                        var comments = argument.start.comments_before;
-                        // if the argument is function preceded by @ngInject
-                        if (argument instanceof AST_Lambda && comments.length && has_inject(comments[0])) {
-                            // replace the function with an array of names of its parameters and function at the end
-                            array[index] = make_array(argument, make_arguments_names_list(argument).concat(argument));
-                        }
+
+            function remove_candidate(expr) {
+                if (expr.name instanceof AST_SymbolFunarg) {
+                    var index = compressor.self().argnames.indexOf(expr.name);
+                    var args = compressor.parent().args;
+                    if (args[index]) args[index] = make_node(AST_Number, args[index], {
+                        value: 0
                     });
-                    // if this is chained call check previous one recursively
-                    if (body.expression && body.expression.expression) {
-                        check_expression(body.expression.expression);
-                    }
+                    return true;
                 }
-            }
-            return statements.reduce(function(a, stat){
-                a.push(stat);
-
-                if (stat.body && stat.body.args) {
-                    check_expression(stat.body);
-                } else {
-                    var token = stat.start;
-                    var comments = token.comments_before;
-                    if (comments && comments.length > 0) {
-                        var last = comments.pop();
-                        if (has_inject(last)) {
-                            // case 1: defun
-                            if (stat instanceof AST_Defun) {
-                                a.push(make_injector(stat, stat.name));
-                            }
-                            else if (stat instanceof AST_Definitions) {
-                                stat.definitions.forEach(function(def) {
-                                    if (def.value && def.value instanceof AST_Lambda) {
-                                        a.push(make_injector(def.value, def.name));
-                                    }
-                                });
-                            }
-                            else {
-                                compressor.warn("Unknown statement marked with @ngInject [{file}:{line},{col}]", token);
-                            }
+                var found = false;
+                return statements[stat_index].transform(new TreeTransformer(function(node, descend, in_list) {
+                    if (found) return node;
+                    if (node === expr) {
+                        found = true;
+                        if (node instanceof AST_VarDef) {
+                            remove(node.name.definition().orig, node.name);
                         }
+                        return in_list ? MAP.skip : null;
                     }
-                }
+                }, function(node) {
+                    if (node instanceof AST_Sequence) switch (node.expressions.length) {
+                      case 0: return null;
+                      case 1: return node.expressions[0];
+                    }
+                    if (node instanceof AST_Definitions && node.definitions.length == 0
+                        || node instanceof AST_SimpleStatement && !node.body) {
+                        return null;
+                    }
+                }));
+            }
+
+            function value_has_side_effects(expr) {
+                if (expr instanceof AST_Unary) return false;
+                return expr[expr instanceof AST_Assign ? "right" : "value"].has_side_effects(compressor);
+            }
 
-                return a;
-            }, []);
+            function references_in_scope(def) {
+                if (def.orig.length == 1 && def.orig[0] instanceof AST_SymbolDefun) return true;
+                if (def.scope !== scope) return false;
+                return def.references.every(function(ref) {
+                    return ref.scope === scope;
+                });
+            }
         }
 
         function eliminate_spurious_blocks(statements) {
             var seen_dirs = [];
-            return statements.reduce(function(a, stat){
+            for (var i = 0; i < statements.length;) {
+                var stat = statements[i];
                 if (stat instanceof AST_BlockStatement) {
                     CHANGED = true;
-                    a.push.apply(a, eliminate_spurious_blocks(stat.body));
+                    eliminate_spurious_blocks(stat.body);
+                    [].splice.apply(statements, [i, 1].concat(stat.body));
+                    i += stat.body.length;
                 } else if (stat instanceof AST_EmptyStatement) {
                     CHANGED = true;
+                    statements.splice(i, 1);
                 } else if (stat instanceof AST_Directive) {
                     if (seen_dirs.indexOf(stat.value) < 0) {
-                        a.push(stat);
+                        i++;
                         seen_dirs.push(stat.value);
                     } else {
                         CHANGED = true;
+                        statements.splice(i, 1);
                     }
-                } else {
-                    a.push(stat);
-                }
-                return a;
-            }, []);
-        };
+                } else i++;
+            }
+        }
 
         function handle_if_return(statements, compressor) {
             var self = compressor.self();
             var multiple_if_returns = has_multiple_if_returns(statements);
             var in_lambda = self instanceof AST_Lambda;
-            var ret = []; // Optimized statements, build from tail to front
-            loop: for (var i = statements.length; --i >= 0;) {
+            for (var i = statements.length; --i >= 0;) {
                 var stat = statements[i];
-                switch (true) {
-                  case (in_lambda && stat instanceof AST_Return && !stat.value && ret.length == 0):
-                    CHANGED = true;
-                    // note, ret.length is probably always zero
-                    // because we drop unreachable code before this
-                    // step.  nevertheless, it's good to check.
-                    continue loop;
-                  case stat instanceof AST_If:
-                    if (stat.body instanceof AST_Return) {
-                        //---
-                        // pretty silly case, but:
-                        // if (foo()) return; return; ==> foo(); return;
-                        if (((in_lambda && ret.length == 0)
-                             || (ret[0] instanceof AST_Return && !ret[0].value))
-                            && !stat.body.value && !stat.alternative) {
-                            CHANGED = true;
-                            var cond = make_node(AST_SimpleStatement, stat.condition, {
-                                body: stat.condition
-                            });
-                            ret.unshift(cond);
-                            continue loop;
-                        }
-                        //---
-                        // if (foo()) return x; return y; ==> return foo() ? x : y;
-                        if (ret[0] instanceof AST_Return && stat.body.value && ret[0].value && !stat.alternative) {
-                            CHANGED = true;
-                            stat = stat.clone();
-                            stat.alternative = ret[0];
-                            ret[0] = stat.transform(compressor);
-                            continue loop;
-                        }
-                        //---
-                        // if (foo()) return x; [ return ; ] ==> return foo() ? x : undefined;
-                        if (multiple_if_returns && (ret.length == 0 || ret[0] instanceof AST_Return)
-                            && stat.body.value && !stat.alternative && in_lambda) {
-                            CHANGED = true;
-                            stat = stat.clone();
-                            stat.alternative = ret[0] || make_node(AST_Return, stat, {
-                                value: null
-                            });
-                            ret[0] = stat.transform(compressor);
-                            continue loop;
-                        }
-                        //---
-                        // if (foo()) return; [ else x... ]; y... ==> if (!foo()) { x...; y... }
-                        if (!stat.body.value && in_lambda) {
-                            CHANGED = true;
-                            stat = stat.clone();
-                            stat.condition = stat.condition.negate(compressor);
-                            var body = as_statement_array(stat.alternative).concat(ret);
-                            var funs = extract_functions_from_statement_array(body);
-                            stat.body = make_node(AST_BlockStatement, stat, {
-                                body: body
-                            });
-                            stat.alternative = null;
-                            ret = funs.concat([ stat.transform(compressor) ]);
-                            continue loop;
-                        }
+                var next = statements[i + 1];
 
-                        //---
-                        // if (a) return b; if (c) return d; e; ==> return a ? b : c ? d : void e;
-                        //
-                        // if sequences is not enabled, this can lead to an endless loop (issue #866).
-                        // however, with sequences on this helps producing slightly better output for
-                        // the example code.
-                        if (compressor.option("sequences")
-                            && i > 0 && statements[i - 1] instanceof AST_If && statements[i - 1].body instanceof AST_Return
-                            && ret.length == 1 && in_lambda && ret[0] instanceof AST_SimpleStatement
-                            && !stat.alternative) {
-                            CHANGED = true;
-                            ret.push(make_node(AST_Return, ret[0], {
-                                value: null
-                            }).transform(compressor));
-                            ret.unshift(stat);
-                            continue loop;
-                        }
-                    }
+                if (in_lambda && stat instanceof AST_Return && !stat.value && !next) {
+                    CHANGED = true;
+                    statements.length--;
+                    continue;
+                }
 
+                if (stat instanceof AST_If) {
                     var ab = aborts(stat.body);
-                    var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;
-                    if (ab && ((ab instanceof AST_Return && !ab.value && in_lambda)
-                               || (ab instanceof AST_Continue && self === loop_body(lct))
-                               || (ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct))) {
+                    if (can_merge_flow(ab)) {
                         if (ab.label) {
                             remove(ab.label.thedef.references, ab);
                         }
                         CHANGED = true;
-                        var body = as_statement_array(stat.body).slice(0, -1);
                         stat = stat.clone();
                         stat.condition = stat.condition.negate(compressor);
+                        var body = as_statement_array_with_return(stat.body, ab);
                         stat.body = make_node(AST_BlockStatement, stat, {
-                            body: as_statement_array(stat.alternative).concat(ret)
+                            body: as_statement_array(stat.alternative).concat(extract_functions())
                         });
                         stat.alternative = make_node(AST_BlockStatement, stat, {
                             body: body
                         });
-                        ret = [ stat.transform(compressor) ];
-                        continue loop;
+                        statements[i] = stat.transform(compressor);
+                        continue;
                     }
 
                     var ab = aborts(stat.alternative);
-                    var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;
-                    if (ab && ((ab instanceof AST_Return && !ab.value && in_lambda)
-                               || (ab instanceof AST_Continue && self === loop_body(lct))
-                               || (ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct))) {
+                    if (can_merge_flow(ab)) {
                         if (ab.label) {
                             remove(ab.label.thedef.references, ab);
                         }
                         CHANGED = true;
                         stat = stat.clone();
                         stat.body = make_node(AST_BlockStatement, stat.body, {
-                            body: as_statement_array(stat.body).concat(ret)
+                            body: as_statement_array(stat.body).concat(extract_functions())
                         });
+                        var body = as_statement_array_with_return(stat.alternative, ab);
                         stat.alternative = make_node(AST_BlockStatement, stat.alternative, {
-                            body: as_statement_array(stat.alternative).slice(0, -1)
+                            body: body
                         });
-                        ret = [ stat.transform(compressor) ];
-                        continue loop;
+                        statements[i] = stat.transform(compressor);
+                        continue;
                     }
+                }
 
-                    ret.unshift(stat);
-                    break;
-                  default:
-                    ret.unshift(stat);
-                    break;
+                if (stat instanceof AST_If && stat.body instanceof AST_Return) {
+                    var value = stat.body.value;
+                    //---
+                    // pretty silly case, but:
+                    // if (foo()) return; return; ==> foo(); return;
+                    if (!value && !stat.alternative
+                        && (in_lambda && !next || next instanceof AST_Return && !next.value)) {
+                        CHANGED = true;
+                        statements[i] = make_node(AST_SimpleStatement, stat.condition, {
+                            body: stat.condition
+                        });
+                        continue;
+                    }
+                    //---
+                    // if (foo()) return x; return y; ==> return foo() ? x : y;
+                    if (value && !stat.alternative && next instanceof AST_Return && next.value) {
+                        CHANGED = true;
+                        stat = stat.clone();
+                        stat.alternative = next;
+                        statements.splice(i, 2, stat.transform(compressor));
+                        continue;
+                    }
+                    //---
+                    // if (foo()) return x; [ return ; ] ==> return foo() ? x : undefined;
+                    if (multiple_if_returns && in_lambda && value && !stat.alternative
+                        && (!next || next instanceof AST_Return)) {
+                        CHANGED = true;
+                        stat = stat.clone();
+                        stat.alternative = next || make_node(AST_Return, stat, {
+                            value: null
+                        });
+                        statements.splice(i, next ? 2 : 1, stat.transform(compressor));
+                        continue;
+                    }
+                    //---
+                    // if (a) return b; if (c) return d; e; ==> return a ? b : c ? d : void e;
+                    //
+                    // if sequences is not enabled, this can lead to an endless loop (issue #866).
+                    // however, with sequences on this helps producing slightly better output for
+                    // the example code.
+                    var prev = statements[i - 1];
+                    if (compressor.option("sequences") && in_lambda && !stat.alternative
+                        && prev instanceof AST_If && prev.body instanceof AST_Return
+                        && i + 2 == statements.length && next instanceof AST_SimpleStatement) {
+                        CHANGED = true;
+                        statements.push(make_node(AST_Return, next, {
+                            value: null
+                        }).transform(compressor));
+                        continue;
+                    }
                 }
             }
-            return ret;
 
             function has_multiple_if_returns(statements) {
                 var n = 0;
@@ -1029,108 +1119,133 @@ merge(Compressor.prototype, {
                 }
                 return false;
             }
-        };
+
+            function is_return_void(value) {
+                return !value || value instanceof AST_UnaryPrefix && value.operator == "void";
+            }
+
+            function can_merge_flow(ab) {
+                if (!ab) return false;
+                var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;
+                return ab instanceof AST_Return && in_lambda && is_return_void(ab.value)
+                    || ab instanceof AST_Continue && self === loop_body(lct)
+                    || ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct;
+            }
+
+            function extract_functions() {
+                var tail = statements.slice(i + 1);
+                statements.length = i + 1;
+                return tail.filter(function(stat) {
+                    if (stat instanceof AST_Defun) {
+                        statements.push(stat);
+                        return false;
+                    }
+                    return true;
+                });
+            }
+
+            function as_statement_array_with_return(node, ab) {
+                var body = as_statement_array(node).slice(0, -1);
+                if (ab.value) {
+                    body.push(make_node(AST_SimpleStatement, ab.value, {
+                        body: ab.value.expression
+                    }));
+                }
+                return body;
+            }
+        }
 
         function eliminate_dead_code(statements, compressor) {
-            var has_quit = false;
-            var orig = statements.length;
+            var has_quit;
             var self = compressor.self();
-            statements = statements.reduce(function(a, stat){
-                if (has_quit) {
-                    extract_declarations_from_unreachable_code(compressor, stat, a);
-                } else {
-                    if (stat instanceof AST_LoopControl) {
-                        var lct = compressor.loopcontrol_target(stat);
-                        if ((stat instanceof AST_Break
-                             && !(lct instanceof AST_IterationStatement)
-                             && loop_body(lct) === self) || (stat instanceof AST_Continue
-                                                             && loop_body(lct) === self)) {
-                            if (stat.label) {
-                                remove(stat.label.thedef.references, stat);
-                            }
-                        } else {
-                            a.push(stat);
+            for (var i = 0, n = 0, len = statements.length; i < len; i++) {
+                var stat = statements[i];
+                if (stat instanceof AST_LoopControl) {
+                    var lct = compressor.loopcontrol_target(stat);
+                    if (stat instanceof AST_Break
+                            && !(lct instanceof AST_IterationStatement)
+                            && loop_body(lct) === self
+                        || stat instanceof AST_Continue
+                            && loop_body(lct) === self) {
+                        if (stat.label) {
+                            remove(stat.label.thedef.references, stat);
                         }
                     } else {
-                        a.push(stat);
+                        statements[n++] = stat;
                     }
-                    if (aborts(stat)) has_quit = true;
+                } else {
+                    statements[n++] = stat;
                 }
-                return a;
-            }, []);
-            CHANGED = statements.length != orig;
-            return statements;
-        };
+                if (aborts(stat)) {
+                    has_quit = statements.slice(i + 1);
+                    break;
+                }
+            }
+            statements.length = n;
+            CHANGED = n != len;
+            if (has_quit) has_quit.forEach(function(stat) {
+                extract_declarations_from_unreachable_code(compressor, stat, statements);
+            });
+        }
 
         function sequencesize(statements, compressor) {
-            if (statements.length < 2) return statements;
-            var seq = [], ret = [];
+            if (statements.length < 2) return;
+            var seq = [], n = 0;
             function push_seq() {
-                seq = AST_Seq.from_array(seq);
-                if (seq) ret.push(make_node(AST_SimpleStatement, seq, {
-                    body: seq
-                }));
+                if (!seq.length) return;
+                var body = make_sequence(seq[0], seq);
+                statements[n++] = make_node(AST_SimpleStatement, body, { body: body });
                 seq = [];
-            };
-            statements.forEach(function(stat){
+            }
+            for (var i = 0, len = statements.length; i < len; i++) {
+                var stat = statements[i];
                 if (stat instanceof AST_SimpleStatement) {
-                    if (seqLength(seq) >= compressor.sequences_limit) push_seq();
+                    if (seq.length >= compressor.sequences_limit) push_seq();
                     var body = stat.body;
                     if (seq.length > 0) body = body.drop_side_effect_free(compressor);
-                    if (body) seq.push(body);
+                    if (body) merge_sequence(seq, body);
                 } else {
                     push_seq();
-                    ret.push(stat);
-                }
-            });
-            push_seq();
-            ret = sequencesize_2(ret, compressor);
-            CHANGED = ret.length != statements.length;
-            return ret;
-        };
-
-        function seqLength(a) {
-            for (var len = 0, i = 0; i < a.length; ++i) {
-                var stat = a[i];
-                if (stat instanceof AST_Seq) {
-                    len += stat.len();
-                } else {
-                    len++;
+                    statements[n++] = stat;
                 }
             }
-            return len;
-        };
+            push_seq();
+            statements.length = n;
+            sequencesize_2(statements, compressor);
+            CHANGED = statements.length != len;
+        }
 
         function sequencesize_2(statements, compressor) {
             function cons_seq(right) {
-                ret.pop();
+                n--;
                 var left = prev.body;
-                if (left instanceof AST_Seq) {
-                    left.add(right);
-                } else {
-                    left = AST_Seq.cons(left, right);
+                if (!(left instanceof AST_Sequence)) {
+                    left = make_node(AST_Sequence, left, {
+                        expressions: [ left ]
+                    });
                 }
+                merge_sequence(left.expressions, right);
                 return left.transform(compressor);
             };
-            var ret = [], prev = null;
-            statements.forEach(function(stat){
+            var n = 0, prev;
+            for (var i = 0, len = statements.length; i < len; i++) {
+                var stat = statements[i];
                 if (prev) {
-                    if (stat instanceof AST_For) {
-                        var opera = {};
-                        try {
-                            prev.body.walk(new TreeWalker(function(node){
-                                if (node instanceof AST_Binary && node.operator == "in")
-                                    throw opera;
-                            }));
-                            if (stat.init && !(stat.init instanceof AST_Definitions)) {
-                                stat.init = cons_seq(stat.init);
+                    if (stat instanceof AST_For && !(stat.init instanceof AST_Definitions)) {
+                        var abort = false;
+                        prev.body.walk(new TreeWalker(function(node) {
+                            if (abort || node instanceof AST_Scope) return true;
+                            if (node instanceof AST_Binary && node.operator == "in") {
+                                abort = true;
+                                return true;
                             }
-                            else if (!stat.init) {
+                        }));
+                        if (!abort) {
+                            if (stat.init) stat.init = cons_seq(stat.init);
+                            else {
                                 stat.init = prev.body.drop_side_effect_free(compressor);
-                                ret.pop();
+                                n--;
                             }
-                        } catch(ex) {
-                            if (ex !== opera) throw ex;
                         }
                     }
                     else if (stat instanceof AST_If) {
@@ -1149,15 +1264,16 @@ merge(Compressor.prototype, {
                         stat.expression = cons_seq(stat.expression);
                     }
                 }
-                ret.push(stat);
+                statements[n++] = stat;
                 prev = stat instanceof AST_SimpleStatement ? stat : null;
-            });
-            return ret;
-        };
+            }
+            statements.length = n;
+        }
 
         function join_consecutive_vars(statements, compressor) {
-            var prev = null;
-            return statements.reduce(function(a, stat){
+            for (var i = 0, j = -1, len = statements.length; i < len; i++) {
+                var stat = statements[i];
+                var prev = statements[j];
                 if (stat instanceof AST_Definitions && prev && prev.TYPE == stat.TYPE) {
                     prev.definitions = prev.definitions.concat(stat.definitions);
                     CHANGED = true;
@@ -1166,35 +1282,19 @@ merge(Compressor.prototype, {
                          && prev instanceof AST_Var
                          && (!stat.init || stat.init.TYPE == prev.TYPE)) {
                     CHANGED = true;
-                    a.pop();
                     if (stat.init) {
                         stat.init.definitions = prev.definitions.concat(stat.init.definitions);
                     } else {
                         stat.init = prev;
                     }
-                    a.push(stat);
-                    prev = stat;
+                    statements[j] = stat;
                 }
                 else {
-                    prev = stat;
-                    a.push(stat);
+                    statements[++j] = stat;
                 }
-                return a;
-            }, []);
-        };
-
-    };
-
-    function extract_functions_from_statement_array(statements) {
-        var funs = [];
-        for (var i = statements.length - 1; i >= 0; --i) {
-            var stat = statements[i];
-            if (stat instanceof AST_Defun) {
-                statements.splice(i, 1);
-                funs.unshift(stat);
             }
-        }
-        return funs;
+            statements.length = j + 1;
+        };
     }
 
     function extract_declarations_from_unreachable_code(compressor, stat, target) {
@@ -1208,7 +1308,7 @@ merge(Compressor.prototype, {
                 target.push(node);
                 return true;
             }
-            if (node instanceof AST_Defun) {
+            if (node instanceof AST_Defun && (node === stat || !compressor.has_directive("use strict"))) {
                 target.push(node);
                 return true;
             }
@@ -1230,12 +1330,12 @@ merge(Compressor.prototype, {
     // returns true if this node may be null, undefined or contain `AST_Accessor`
     (function(def) {
         AST_Node.DEFMETHOD("may_throw_on_access", function(compressor) {
-            var pure_getters = compressor.option("pure_getters");
-            return !pure_getters || this._throw_on_access(pure_getters);
+            return !compressor.option("pure_getters")
+                || this._dot_throw(compressor);
         });
 
-        function is_strict(pure_getters) {
-            return /strict/.test(pure_getters);
+        function is_strict(compressor) {
+            return /strict/.test(compressor.option("pure_getters"));
         }
 
         def(AST_Node, is_strict);
@@ -1243,8 +1343,8 @@ merge(Compressor.prototype, {
         def(AST_Undefined, return_true);
         def(AST_Constant, return_false);
         def(AST_Array, return_false);
-        def(AST_Object, function(pure_getters) {
-            if (!is_strict(pure_getters)) return false;
+        def(AST_Object, function(compressor) {
+            if (!is_strict(compressor)) return false;
             for (var i = this.properties.length; --i >=0;)
                 if (this.properties[i].value instanceof AST_Accessor) return true;
             return false;
@@ -1254,42 +1354,44 @@ merge(Compressor.prototype, {
         def(AST_UnaryPrefix, function() {
             return this.operator == "void";
         });
-        def(AST_Binary, function(pure_getters) {
+        def(AST_Binary, function(compressor) {
             switch (this.operator) {
               case "&&":
-                return this.left._throw_on_access(pure_getters);
+                return this.left._dot_throw(compressor);
               case "||":
-                return this.left._throw_on_access(pure_getters)
-                    && this.right._throw_on_access(pure_getters);
+                return this.left._dot_throw(compressor)
+                    && this.right._dot_throw(compressor);
               default:
                 return false;
             }
         })
-        def(AST_Assign, function(pure_getters) {
+        def(AST_Assign, function(compressor) {
             return this.operator == "="
-                && this.right._throw_on_access(pure_getters);
+                && this.right._dot_throw(compressor);
         })
-        def(AST_Conditional, function(pure_getters) {
-            return this.consequent._throw_on_access(pure_getters)
-                || this.alternative._throw_on_access(pure_getters);
+        def(AST_Conditional, function(compressor) {
+            return this.consequent._dot_throw(compressor)
+                || this.alternative._dot_throw(compressor);
         })
-        def(AST_Seq, function(pure_getters) {
-            return this.cdr._throw_on_access(pure_getters);
+        def(AST_Sequence, function(compressor) {
+            return this.expressions[this.expressions.length - 1]._dot_throw(compressor);
         });
-        def(AST_SymbolRef, function(pure_getters) {
+        def(AST_SymbolRef, function(compressor) {
             if (this.is_undefined) return true;
-            if (!is_strict(pure_getters)) return false;
+            if (!is_strict(compressor)) return false;
+            if (is_undeclared_ref(this) && this.is_declared(compressor)) return false;
+            if (this.is_immutable()) return false;
             var fixed = this.fixed_value();
-            return !fixed || fixed._throw_on_access(pure_getters);
+            return !fixed || fixed._dot_throw(compressor);
         });
     })(function(node, func) {
-        node.DEFMETHOD("_throw_on_access", func);
+        node.DEFMETHOD("_dot_throw", func);
     });
 
     /* -----[ boolean/negation helpers ]----- */
 
     // methods to determine whether an expression has a boolean result type
-    (function (def){
+    (function(def){
         var unary_bool = [ "!", "delete" ];
         var binary_bool = [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ];
         def(AST_Node, return_false);
@@ -1307,8 +1409,8 @@ merge(Compressor.prototype, {
         def(AST_Assign, function(){
             return this.operator == "=" && this.right.is_boolean();
         });
-        def(AST_Seq, function(){
-            return this.cdr.is_boolean();
+        def(AST_Sequence, function(){
+            return this.expressions[this.expressions.length - 1].is_boolean();
         });
         def(AST_True, return_true);
         def(AST_False, return_true);
@@ -1317,7 +1419,7 @@ merge(Compressor.prototype, {
     });
 
     // methods to determine if an expression has a numeric result type
-    (function (def){
+    (function(def){
         def(AST_Node, return_false);
         def(AST_Number, return_true);
         var unary = makePredicate("+ - ~ ++ --");
@@ -1334,8 +1436,8 @@ merge(Compressor.prototype, {
             return binary(this.operator.slice(0, -1))
                 || this.operator == "=" && this.right.is_number(compressor);
         });
-        def(AST_Seq, function(compressor){
-            return this.cdr.is_number(compressor);
+        def(AST_Sequence, function(compressor){
+            return this.expressions[this.expressions.length - 1].is_number(compressor);
         });
         def(AST_Conditional, function(compressor){
             return this.consequent.is_number(compressor) && this.alternative.is_number(compressor);
@@ -1345,7 +1447,7 @@ merge(Compressor.prototype, {
     });
 
     // methods to determine if an expression has a string result type
-    (function (def){
+    (function(def){
         def(AST_Node, return_false);
         def(AST_String, return_true);
         def(AST_UnaryPrefix, function(){
@@ -1358,8 +1460,8 @@ merge(Compressor.prototype, {
         def(AST_Assign, function(compressor){
             return (this.operator == "=" || this.operator == "+=") && this.right.is_string(compressor);
         });
-        def(AST_Seq, function(compressor){
-            return this.cdr.is_string(compressor);
+        def(AST_Sequence, function(compressor){
+            return this.expressions[this.expressions.length - 1].is_string(compressor);
         });
         def(AST_Conditional, function(compressor){
             return this.consequent.is_string(compressor) && this.alternative.is_string(compressor);
@@ -1375,7 +1477,7 @@ merge(Compressor.prototype, {
         if (parent instanceof AST_Assign && parent.left === node) return node;
     }
 
-    (function (def){
+    (function(def){
         AST_Node.DEFMETHOD("resolve_defines", function(compressor) {
             if (!compressor.option("global_defs")) return;
             var def = this._find_defs(compressor, "");
@@ -1401,7 +1503,7 @@ merge(Compressor.prototype, {
             });
             if (value && typeof value == "object") {
                 var props = [];
-                for (var key in value) {
+                for (var key in value) if (HOP(value, key)) {
                     props.push(make_node(AST_ObjectKeyVal, orig, {
                         key: key,
                         value: to_node(value[key], orig)
@@ -1456,7 +1558,7 @@ merge(Compressor.prototype, {
     }
 
     // methods to evaluate a constant expression
-    (function (def){
+    (function(def){
         // If the node has been successfully reduced to a constant,
         // then its value is returned; otherwise the element itself
         // is returned.
@@ -1464,13 +1566,8 @@ merge(Compressor.prototype, {
         // descendant of AST_Node.
         AST_Node.DEFMETHOD("evaluate", function(compressor){
             if (!compressor.option("evaluate")) return this;
-            try {
-                var val = this._eval(compressor);
-                return !val || val instanceof RegExp || typeof val != "object" ? val : this;
-            } catch(ex) {
-                if (ex !== def) throw ex;
-                return this;
-            }
+            var val = this._eval(compressor);
+            return !val || val instanceof RegExp || typeof val != "object" ? val : this;
         });
         var unaryPrefix = makePredicate("! ~ - + void");
         AST_Node.DEFMETHOD("is_constant", function(){
@@ -1516,27 +1613,28 @@ merge(Compressor.prototype, {
         def(AST_Statement, function(){
             throw new Error(string_template("Cannot evaluate a statement [{file}:{line},{col}]", this.start));
         });
-        def(AST_Lambda, function(){
-            throw def;
-        });
+        def(AST_Lambda, return_this);
         function ev(node, compressor) {
             if (!compressor) throw new Error("Compressor must be passed");
 
             return node._eval(compressor);
         };
-        def(AST_Node, function(){
-            throw def;          // not constant
-        });
+        def(AST_Node, return_this);
         def(AST_Constant, function(){
             return this.getValue();
         });
         def(AST_Array, function(compressor){
             if (compressor.option("unsafe")) {
-                return this.elements.map(function(element) {
-                    return ev(element, compressor);
-                });
+                var elements = [];
+                for (var i = 0, len = this.elements.length; i < len; i++) {
+                    var element = this.elements[i];
+                    var value = ev(element, compressor);
+                    if (element === value) return this;
+                    elements.push(value);
+                }
+                return elements;
             }
-            throw def;
+            return this;
         });
         def(AST_Object, function(compressor){
             if (compressor.option("unsafe")) {
@@ -1548,106 +1646,255 @@ merge(Compressor.prototype, {
                         key = key.name;
                     } else if (key instanceof AST_Node) {
                         key = ev(key, compressor);
+                        if (key === prop.key) return this;
                     }
                     if (typeof Object.prototype[key] === 'function') {
-                        throw def;
+                        return this;
                     }
                     val[key] = ev(prop.value, compressor);
+                    if (val[key] === prop.value) return this;
                 }
                 return val;
             }
-            throw def;
+            return this;
         });
         def(AST_UnaryPrefix, function(compressor){
-            var e = this.expression;
+            // Function would be evaluated to an array and so typeof would
+            // incorrectly return 'object'. Hence making is a special case.
+            if (this.operator == "typeof" && this.expression instanceof AST_Function) {
+                return typeof function(){};
+            }
+            var e = ev(this.expression, compressor);
+            if (e === this.expression) return this;
             switch (this.operator) {
-              case "!": return !ev(e, compressor);
+              case "!": return !e;
               case "typeof":
-                // Function would be evaluated to an array and so typeof would
-                // incorrectly return 'object'. Hence making is a special case.
-                if (e instanceof AST_Function) return typeof function(){};
-
-                e = ev(e, compressor);
-
                 // typeof <RegExp> returns "object" or "function" on different platforms
                 // so cannot evaluate reliably
-                if (e instanceof RegExp) throw def;
-
+                if (e instanceof RegExp) return this;
                 return typeof e;
-              case "void": return void ev(e, compressor);
-              case "~": return ~ev(e, compressor);
-              case "-": return -ev(e, compressor);
-              case "+": return +ev(e, compressor);
+              case "void": return void e;
+              case "~": return ~e;
+              case "-": return -e;
+              case "+": return +e;
             }
-            throw def;
+            return this;
         });
-        def(AST_Binary, function(c){
-            var left = this.left, right = this.right, result;
+        def(AST_Binary, function(compressor){
+            var left = ev(this.left, compressor);
+            if (left === this.left) return this;
+            var right = ev(this.right, compressor);
+            if (right === this.right) return this;
+            var result;
             switch (this.operator) {
-              case "&&"  : result = ev(left, c) &&  ev(right, c); break;
-              case "||"  : result = ev(left, c) ||  ev(right, c); break;
-              case "|"   : result = ev(left, c) |   ev(right, c); break;
-              case "&"   : result = ev(left, c) &   ev(right, c); break;
-              case "^"   : result = ev(left, c) ^   ev(right, c); break;
-              case "+"   : result = ev(left, c) +   ev(right, c); break;
-              case "*"   : result = ev(left, c) *   ev(right, c); break;
-              case "/"   : result = ev(left, c) /   ev(right, c); break;
-              case "%"   : result = ev(left, c) %   ev(right, c); break;
-              case "-"   : result = ev(left, c) -   ev(right, c); break;
-              case "<<"  : result = ev(left, c) <<  ev(right, c); break;
-              case ">>"  : result = ev(left, c) >>  ev(right, c); break;
-              case ">>>" : result = ev(left, c) >>> ev(right, c); break;
-              case "=="  : result = ev(left, c) ==  ev(right, c); break;
-              case "===" : result = ev(left, c) === ev(right, c); break;
-              case "!="  : result = ev(left, c) !=  ev(right, c); break;
-              case "!==" : result = ev(left, c) !== ev(right, c); break;
-              case "<"   : result = ev(left, c) <   ev(right, c); break;
-              case "<="  : result = ev(left, c) <=  ev(right, c); break;
-              case ">"   : result = ev(left, c) >   ev(right, c); break;
-              case ">="  : result = ev(left, c) >=  ev(right, c); break;
+              case "&&"  : result = left &&  right; break;
+              case "||"  : result = left ||  right; break;
+              case "|"   : result = left |   right; break;
+              case "&"   : result = left &   right; break;
+              case "^"   : result = left ^   right; break;
+              case "+"   : result = left +   right; break;
+              case "*"   : result = left *   right; break;
+              case "/"   : result = left /   right; break;
+              case "%"   : result = left %   right; break;
+              case "-"   : result = left -   right; break;
+              case "<<"  : result = left <<  right; break;
+              case ">>"  : result = left >>  right; break;
+              case ">>>" : result = left >>> right; break;
+              case "=="  : result = left ==  right; break;
+              case "===" : result = left === right; break;
+              case "!="  : result = left !=  right; break;
+              case "!==" : result = left !== right; break;
+              case "<"   : result = left <   right; break;
+              case "<="  : result = left <=  right; break;
+              case ">"   : result = left >   right; break;
+              case ">="  : result = left >=  right; break;
               default:
-                  throw def;
+                  return this;
             }
-            if (isNaN(result) && c.find_parent(AST_With)) {
+            if (isNaN(result) && compressor.find_parent(AST_With)) {
                 // leave original expression as is
-                throw def;
+                return this;
             }
             return result;
         });
         def(AST_Conditional, function(compressor){
-            return ev(this.condition, compressor)
-                ? ev(this.consequent, compressor)
-                : ev(this.alternative, compressor);
+            var condition = ev(this.condition, compressor);
+            if (condition === this.condition) return this;
+            var node = condition ? this.consequent : this.alternative;
+            var value = ev(node, compressor);
+            return value === node ? this : value;
         });
         def(AST_SymbolRef, function(compressor){
-            if (!compressor.option("reduce_vars") || this._evaluating) throw def;
-            this._evaluating = true;
-            try {
-                var fixed = this.fixed_value();
-                if (!fixed) throw def;
-                var value = ev(fixed, compressor);
-                if (!HOP(fixed, "_eval")) fixed._eval = function() {
-                    return value;
-                };
-                if (value && typeof value == "object" && this.definition().escaped) throw def;
+            if (!compressor.option("reduce_vars")) return this;
+            var fixed = this.fixed_value();
+            if (!fixed) return this;
+            this._eval = return_this;
+            var value = ev(fixed, compressor);
+            if (value === fixed) {
+                delete this._eval;
+                return this;
+            }
+            if (!HOP(fixed, "_eval")) fixed._eval = function() {
                 return value;
-            } finally {
-                this._evaluating = false;
+            };
+            if (value && typeof value == "object" && this.definition().escaped) {
+                delete this._eval;
+                return this;
             }
+            this._eval = fixed._eval;
+            return value;
         });
+        var global_objs = {
+            Array: Array,
+            Math: Math,
+            Number: Number,
+            String: String,
+        };
+        function convert_to_predicate(obj) {
+            for (var key in obj) {
+                obj[key] = makePredicate(obj[key]);
+            }
+        }
+        var static_values = {
+            Math: [
+                "E",
+                "LN10",
+                "LN2",
+                "LOG2E",
+                "LOG10E",
+                "PI",
+                "SQRT1_2",
+                "SQRT2",
+            ],
+            Number: [
+                "MAX_VALUE",
+                "MIN_VALUE",
+                "NaN",
+                "NEGATIVE_INFINITY",
+                "POSITIVE_INFINITY",
+            ],
+        };
+        convert_to_predicate(static_values);
         def(AST_PropAccess, function(compressor){
             if (compressor.option("unsafe")) {
                 var key = this.property;
                 if (key instanceof AST_Node) {
                     key = ev(key, compressor);
+                    if (key === this.property) return this;
+                }
+                var exp = this.expression;
+                var val;
+                if (is_undeclared_ref(exp)) {
+                    if (!(static_values[exp.name] || return_false)(key)) return this;
+                    val = global_objs[exp.name];
+                } else {
+                    val = ev(exp, compressor);
+                    if (!val || val === exp || !HOP(val, key)) return this;
+                }
+                return val[key];
+            }
+            return this;
+        });
+        var object_fns = [
+            "constructor",
+            "toString",
+            "valueOf",
+        ];
+        var native_fns = {
+            Array: [
+                "indexOf",
+                "join",
+                "lastIndexOf",
+                "slice",
+            ].concat(object_fns),
+            Boolean: object_fns,
+            Number: [
+                "toExponential",
+                "toFixed",
+                "toPrecision",
+            ].concat(object_fns),
+            RegExp: [
+                "test",
+            ].concat(object_fns),
+            String: [
+                "charAt",
+                "charCodeAt",
+                "concat",
+                "indexOf",
+                "italics",
+                "lastIndexOf",
+                "match",
+                "replace",
+                "search",
+                "slice",
+                "split",
+                "substr",
+                "substring",
+                "trim",
+            ].concat(object_fns),
+        };
+        convert_to_predicate(native_fns);
+        var static_fns = {
+            Array: [
+                "isArray",
+            ],
+            Math: [
+                "abs",
+                "acos",
+                "asin",
+                "atan",
+                "ceil",
+                "cos",
+                "exp",
+                "floor",
+                "log",
+                "round",
+                "sin",
+                "sqrt",
+                "tan",
+                "atan2",
+                "pow",
+                "max",
+                "min"
+            ],
+            Number: [
+                "isFinite",
+                "isNaN",
+            ],
+            String: [
+                "fromCharCode",
+            ],
+        };
+        convert_to_predicate(static_fns);
+        def(AST_Call, function(compressor){
+            var exp = this.expression;
+            if (compressor.option("unsafe") && exp instanceof AST_PropAccess) {
+                var key = exp.property;
+                if (key instanceof AST_Node) {
+                    key = ev(key, compressor);
+                    if (key === exp.property) return this;
+                }
+                var val;
+                var e = exp.expression;
+                if (is_undeclared_ref(e)) {
+                    if (!(static_fns[e.name] || return_false)(key)) return this;
+                    val = global_objs[e.name];
+                } else {
+                    val = ev(e, compressor);
+                    if (val === e || !(val && native_fns[val.constructor.name] || return_false)(key)) return this;
                 }
-                var val = ev(this.expression, compressor);
-                if (val && HOP(val, key)) {
-                    return val[key];
+                var args = [];
+                for (var i = 0, len = this.args.length; i < len; i++) {
+                    var arg = this.args[i];
+                    var value = ev(arg, compressor);
+                    if (arg === value) return this;
+                    args.push(value);
                 }
+                return val[key].apply(val, args);
             }
-            throw def;
+            return this;
         });
+        def(AST_New, return_this);
     })(function(node, func){
         node.DEFMETHOD("_eval", func);
     });
@@ -1684,10 +1931,10 @@ merge(Compressor.prototype, {
                 return this.expression;
             return basic_negation(this);
         });
-        def(AST_Seq, function(compressor){
-            var self = this.clone();
-            self.cdr = self.cdr.negate(compressor);
-            return self;
+        def(AST_Sequence, function(compressor){
+            var expressions = this.expressions.slice();
+            expressions.push(expressions.pop().negate(compressor));
+            return make_sequence(this, expressions);
         });
         def(AST_Conditional, function(compressor, first_in_statement){
             var self = this.clone();
@@ -1811,8 +2058,9 @@ merge(Compressor.prototype, {
                 || this.expression.has_side_effects(compressor);
         });
         def(AST_SymbolRef, function(compressor){
-            return this.undeclared();
+            return !this.is_declared(compressor);
         });
+        def(AST_SymbolDeclaration, return_false);
         def(AST_Object, function(compressor){
             return any(this.properties, compressor);
         });
@@ -1831,14 +2079,44 @@ merge(Compressor.prototype, {
                 || this.expression.has_side_effects(compressor)
                 || this.property.has_side_effects(compressor);
         });
-        def(AST_Seq, function(compressor){
-            return this.car.has_side_effects(compressor)
-                || this.cdr.has_side_effects(compressor);
+        def(AST_Sequence, function(compressor){
+            return this.expressions.some(function(expression, index) {
+                return expression.has_side_effects(compressor);
+            });
         });
     })(function(node, func){
         node.DEFMETHOD("has_side_effects", func);
     });
 
+    // determine if expression is constant
+    (function(def){
+        function all(list) {
+            for (var i = list.length; --i >= 0;)
+                if (!list[i].is_constant_expression())
+                    return false;
+            return true;
+        }
+        def(AST_Node, return_false);
+        def(AST_Constant, return_true);
+        def(AST_Unary, function(){
+            return this.expression.is_constant_expression();
+        });
+        def(AST_Binary, function(){
+            return this.left.is_constant_expression() && this.right.is_constant_expression();
+        });
+        def(AST_Array, function(){
+            return all(this.elements);
+        });
+        def(AST_Object, function(){
+            return all(this.properties);
+        });
+        def(AST_ObjectProperty, function(){
+            return this.value.is_constant_expression();
+        });
+    })(function(node, func){
+        node.DEFMETHOD("is_constant_expression", func);
+    });
+
     // tell me if a statement aborts
     function aborts(thing) {
         return thing && thing.aborts();
@@ -1883,12 +2161,12 @@ merge(Compressor.prototype, {
     });
 
     OPT(AST_Block, function(self, compressor){
-        self.body = tighten_body(self.body, compressor);
+        tighten_body(self.body, compressor);
         return self;
     });
 
     OPT(AST_BlockStatement, function(self, compressor){
-        self.body = tighten_body(self.body, compressor);
+        tighten_body(self.body, compressor);
         switch (self.body.length) {
           case 1: return self.body[0];
           case 0: return make_node(AST_EmptyStatement, self);
@@ -1897,269 +2175,290 @@ merge(Compressor.prototype, {
     });
 
     AST_Scope.DEFMETHOD("drop_unused", function(compressor){
+        if (!compressor.option("unused")) return;
+        if (compressor.has_directive("use asm")) return;
         var self = this;
-        if (compressor.has_directive("use asm")) return self;
-        var toplevel = compressor.option("toplevel");
-        if (compressor.option("unused")
-            && (!(self instanceof AST_Toplevel) || toplevel)
-            && !self.uses_eval
-            && !self.uses_with) {
-            var assign_as_unused = !/keep_assign/.test(compressor.option("unused"));
-            var drop_funcs = /funcs/.test(toplevel);
-            var drop_vars = /vars/.test(toplevel);
-            if (!(self instanceof AST_Toplevel) || toplevel == true) {
-                drop_funcs = drop_vars = true;
-            }
-            var in_use = [];
-            var in_use_ids = Object.create(null); // avoid expensive linear scans of in_use
-            if (self instanceof AST_Toplevel && compressor.top_retain) {
-                self.variables.each(function(def) {
-                    if (compressor.top_retain(def) && !(def.id in in_use_ids)) {
-                        in_use_ids[def.id] = true;
-                        in_use.push(def);
+        if (self.uses_eval || self.uses_with) return;
+        var drop_funcs = !(self instanceof AST_Toplevel) || compressor.toplevel.funcs;
+        var drop_vars = !(self instanceof AST_Toplevel) || compressor.toplevel.vars;
+        if (!drop_funcs && !drop_vars) return;
+        var assign_as_unused = /keep_assign/.test(compressor.option("unused")) ? return_false : function(node) {
+            if (node instanceof AST_Assign && (node.write_only || node.operator == "=")) {
+                return node.left;
+            }
+            if (node instanceof AST_Unary && node.write_only) return node.expression;
+        };
+        var in_use = [];
+        var in_use_ids = Object.create(null); // avoid expensive linear scans of in_use
+        if (self instanceof AST_Toplevel && compressor.top_retain) {
+            self.variables.each(function(def) {
+                if (compressor.top_retain(def) && !(def.id in in_use_ids)) {
+                    in_use_ids[def.id] = true;
+                    in_use.push(def);
+                }
+            });
+        }
+        var var_defs_by_id = new Dictionary();
+        var initializations = new Dictionary();
+        // pass 1: find out which symbols are directly used in
+        // this scope (not in nested scopes).
+        var scope = this;
+        var tw = new TreeWalker(function(node, descend){
+            if (node !== self) {
+                if (node instanceof AST_Defun) {
+                    if (!drop_funcs && scope === self) {
+                        var node_def = node.name.definition();
+                        if (!(node_def.id in in_use_ids)) {
+                            in_use_ids[node_def.id] = true;
+                            in_use.push(node_def);
+                        }
                     }
-                });
-            }
-            var initializations = new Dictionary();
-            // pass 1: find out which symbols are directly used in
-            // this scope (not in nested scopes).
-            var scope = this;
-            var tw = new TreeWalker(function(node, descend){
-                if (node !== self) {
-                    if (node instanceof AST_Defun) {
-                        if (!drop_funcs && scope === self) {
-                            var node_def = node.name.definition();
+                    initializations.add(node.name.name, node);
+                    return true; // don't go in nested scopes
+                }
+                if (node instanceof AST_Definitions && scope === self) {
+                    node.definitions.forEach(function(def){
+                        var node_def = def.name.definition();
+                        if (def.name instanceof AST_SymbolVar) {
+                            var_defs_by_id.add(node_def.id, def);
+                        }
+                        if (!drop_vars) {
                             if (!(node_def.id in in_use_ids)) {
                                 in_use_ids[node_def.id] = true;
                                 in_use.push(node_def);
                             }
                         }
-                        initializations.add(node.name.name, node);
-                        return true; // don't go in nested scopes
-                    }
-                    if (node instanceof AST_Definitions && scope === self) {
-                        node.definitions.forEach(function(def){
-                            if (!drop_vars) {
-                                var node_def = def.name.definition();
-                                if (!(node_def.id in in_use_ids)) {
-                                    in_use_ids[node_def.id] = true;
-                                    in_use.push(node_def);
-                                }
+                        if (def.value) {
+                            initializations.add(def.name.name, def.value);
+                            if (def.value.has_side_effects(compressor)) {
+                                def.value.walk(tw);
                             }
-                            if (def.value) {
-                                initializations.add(def.name.name, def.value);
-                                if (def.value.has_side_effects(compressor)) {
-                                    def.value.walk(tw);
-                                }
-                            }
-                        });
-                        return true;
-                    }
-                    if (assign_as_unused
-                        && node instanceof AST_Assign
-                        && node.operator == "="
-                        && node.left instanceof AST_SymbolRef
-                        && !is_reference_const(node.left)
-                        && scope === self) {
-                        node.right.walk(tw);
-                        return true;
-                    }
-                    if (node instanceof AST_SymbolRef) {
-                        var node_def = node.definition();
-                        if (!(node_def.id in in_use_ids)) {
-                            in_use_ids[node_def.id] = true;
-                            in_use.push(node_def);
                         }
-                        return true;
-                    }
-                    if (node instanceof AST_Scope) {
-                        var save_scope = scope;
-                        scope = node;
-                        descend();
-                        scope = save_scope;
-                        return true;
+                    });
+                    return true;
+                }
+                if (assign_as_unused(node) instanceof AST_SymbolRef && scope === self) {
+                    if (node instanceof AST_Assign) node.right.walk(tw);
+                    return true;
+                }
+                if (node instanceof AST_SymbolRef) {
+                    var node_def = node.definition();
+                    if (!(node_def.id in in_use_ids)) {
+                        in_use_ids[node_def.id] = true;
+                        in_use.push(node_def);
                     }
+                    return true;
                 }
-            });
-            self.walk(tw);
-            // pass 2: for every used symbol we need to walk its
-            // initialization code to figure out if it uses other
-            // symbols (that may not be in_use).
-            for (var i = 0; i < in_use.length; ++i) {
-                in_use[i].orig.forEach(function(decl){
-                    // undeclared globals will be instanceof AST_SymbolRef
-                    var init = initializations.get(decl.name);
-                    if (init) init.forEach(function(init){
-                        var tw = new TreeWalker(function(node){
-                            if (node instanceof AST_SymbolRef) {
-                                var node_def = node.definition();
-                                if (!(node_def.id in in_use_ids)) {
-                                    in_use_ids[node_def.id] = true;
-                                    in_use.push(node_def);
-                                }
+                if (node instanceof AST_Scope) {
+                    var save_scope = scope;
+                    scope = node;
+                    descend();
+                    scope = save_scope;
+                    return true;
+                }
+            }
+        });
+        self.walk(tw);
+        // pass 2: for every used symbol we need to walk its
+        // initialization code to figure out if it uses other
+        // symbols (that may not be in_use).
+        for (var i = 0; i < in_use.length; ++i) {
+            in_use[i].orig.forEach(function(decl){
+                // undeclared globals will be instanceof AST_SymbolRef
+                var init = initializations.get(decl.name);
+                if (init) init.forEach(function(init){
+                    var tw = new TreeWalker(function(node){
+                        if (node instanceof AST_SymbolRef) {
+                            var node_def = node.definition();
+                            if (!(node_def.id in in_use_ids)) {
+                                in_use_ids[node_def.id] = true;
+                                in_use.push(node_def);
                             }
-                        });
-                        init.walk(tw);
+                        }
                     });
+                    init.walk(tw);
                 });
-            }
-            // pass 3: we should drop declarations not in_use
-            var tt = new TreeTransformer(
-                function before(node, descend, in_list) {
-                    if (node instanceof AST_Function
-                        && node.name
-                        && !compressor.option("keep_fnames")) {
-                        var def = node.name.definition();
-                        // any declarations with same name will overshadow
-                        // name of this anonymous function and can therefore
-                        // never be used anywhere
-                        if (!(def.id in in_use_ids) || def.orig.length > 1)
-                            node.name = null;
-                    }
-                    if (node instanceof AST_Lambda && !(node instanceof AST_Accessor)) {
-                        var trim = !compressor.option("keep_fargs");
-                        for (var a = node.argnames, i = a.length; --i >= 0;) {
-                            var sym = a[i];
-                            if (!(sym.definition().id in in_use_ids)) {
-                                sym.__unused = true;
-                                if (trim) {
-                                    a.pop();
-                                    compressor[sym.unreferenced() ? "warn" : "info"]("Dropping unused function argument {name} [{file}:{line},{col}]", {
-                                        name : sym.name,
-                                        file : sym.start.file,
-                                        line : sym.start.line,
-                                        col  : sym.start.col
-                                    });
-                                }
-                            }
-                            else {
-                                trim = false;
+            });
+        }
+        // pass 3: we should drop declarations not in_use
+        var tt = new TreeTransformer(
+            function before(node, descend, in_list) {
+                if (node instanceof AST_Function
+                    && node.name
+                    && !compressor.option("keep_fnames")) {
+                    var def = node.name.definition();
+                    // any declarations with same name will overshadow
+                    // name of this anonymous function and can therefore
+                    // never be used anywhere
+                    if (!(def.id in in_use_ids) || def.orig.length > 1)
+                        node.name = null;
+                }
+                if (node instanceof AST_Lambda && !(node instanceof AST_Accessor)) {
+                    var trim = !compressor.option("keep_fargs");
+                    for (var a = node.argnames, i = a.length; --i >= 0;) {
+                        var sym = a[i];
+                        if (!(sym.definition().id in in_use_ids)) {
+                            sym.__unused = true;
+                            if (trim) {
+                                a.pop();
+                                compressor[sym.unreferenced() ? "warn" : "info"]("Dropping unused function argument {name} [{file}:{line},{col}]", template(sym));
                             }
                         }
-                    }
-                    if (drop_funcs && node instanceof AST_Defun && node !== self) {
-                        if (!(node.name.definition().id in in_use_ids)) {
-                            compressor[node.name.unreferenced() ? "warn" : "info"]("Dropping unused function {name} [{file}:{line},{col}]", {
-                                name : node.name.name,
-                                file : node.name.start.file,
-                                line : node.name.start.line,
-                                col  : node.name.start.col
-                            });
-                            return make_node(AST_EmptyStatement, node);
+                        else {
+                            trim = false;
                         }
-                        return node;
                     }
-                    if (drop_vars && node instanceof AST_Definitions && !(tt.parent() instanceof AST_ForIn && tt.parent().init === node)) {
-                        var def = node.definitions.filter(function(def){
-                            if (def.value) def.value = def.value.transform(tt);
-                            var sym = def.name.definition();
-                            if (sym.id in in_use_ids) return true;
-                            if (sym.orig[0] instanceof AST_SymbolCatch) {
-                                def.value = def.value && def.value.drop_side_effect_free(compressor);
-                                return true;
-                            }
-                            var w = {
-                                name : def.name.name,
-                                file : def.name.start.file,
-                                line : def.name.start.line,
-                                col  : def.name.start.col
-                            };
-                            if (def.value && (def._unused_side_effects = def.value.drop_side_effect_free(compressor))) {
-                                compressor.warn("Side effects in initialization of unused variable {name} [{file}:{line},{col}]", w);
-                                return true;
+                }
+                if (drop_funcs && node instanceof AST_Defun && node !== self) {
+                    if (!(node.name.definition().id in in_use_ids)) {
+                        compressor[node.name.unreferenced() ? "warn" : "info"]("Dropping unused function {name} [{file}:{line},{col}]", template(node.name));
+                        return make_node(AST_EmptyStatement, node);
+                    }
+                    return node;
+                }
+                if (drop_vars && node instanceof AST_Definitions && !(tt.parent() instanceof AST_ForIn && tt.parent().init === node)) {
+                    // place uninitialized names at the start
+                    var body = [], head = [], tail = [];
+                    // for unused names whose initialization has
+                    // side effects, we can cascade the init. code
+                    // into the next one, or next statement.
+                    var side_effects = [];
+                    node.definitions.forEach(function(def) {
+                        if (def.value) def.value = def.value.transform(tt);
+                        var sym = def.name.definition();
+                        if (sym.id in in_use_ids) {
+                            if (def.name instanceof AST_SymbolVar) {
+                                var var_defs = var_defs_by_id.get(sym.id);
+                                if (var_defs.length > 1 && !def.value) {
+                                    compressor.warn("Dropping duplicated definition of variable {name} [{file}:{line},{col}]", template(def.name));
+                                    remove(var_defs, def);
+                                    remove(sym.orig, def.name);
+                                    return;
+                                }
                             }
-                            compressor[def.name.unreferenced() ? "warn" : "info"]("Dropping unused variable {name} [{file}:{line},{col}]", w);
-                            return false;
-                        });
-                        // place uninitialized names at the start
-                        def = mergeSort(def, function(a, b){
-                            if (!a.value && b.value) return -1;
-                            if (!b.value && a.value) return 1;
-                            return 0;
-                        });
-                        // for unused names whose initialization has
-                        // side effects, we can cascade the init. code
-                        // into the next one, or next statement.
-                        var side_effects = [];
-                        for (var i = 0; i < def.length;) {
-                            var x = def[i];
-                            if (x._unused_side_effects) {
-                                side_effects.push(x._unused_side_effects);
-                                def.splice(i, 1);
-                            } else {
+                            if (def.value) {
                                 if (side_effects.length > 0) {
-                                    side_effects.push(x.value);
-                                    x.value = AST_Seq.from_array(side_effects);
+                                    if (tail.length > 0) {
+                                        merge_sequence(side_effects, def.value);
+                                        def.value = make_sequence(def.value, side_effects);
+                                    } else {
+                                        body.push(make_node(AST_SimpleStatement, node, {
+                                            body: make_sequence(node, side_effects)
+                                        }));
+                                    }
                                     side_effects = [];
                                 }
-                                ++i;
+                                tail.push(def);
+                            } else {
+                                head.push(def);
                             }
-                        }
-                        if (side_effects.length > 0) {
-                            side_effects = make_node(AST_BlockStatement, node, {
-                                body: [ make_node(AST_SimpleStatement, node, {
-                                    body: AST_Seq.from_array(side_effects)
-                                }) ]
-                            });
+                        } else if (sym.orig[0] instanceof AST_SymbolCatch) {
+                            var value = def.value && def.value.drop_side_effect_free(compressor);
+                            if (value) merge_sequence(side_effects, value);
+                            def.value = null;
+                            head.push(def);
                         } else {
-                            side_effects = null;
-                        }
-                        if (def.length == 0 && !side_effects) {
-                            return make_node(AST_EmptyStatement, node);
-                        }
-                        if (def.length == 0) {
-                            return in_list ? MAP.splice(side_effects.body) : side_effects;
+                            var value = def.value && def.value.drop_side_effect_free(compressor);
+                            if (value) {
+                                compressor.warn("Side effects in initialization of unused variable {name} [{file}:{line},{col}]", template(def.name));
+                                merge_sequence(side_effects, value);
+                            } else {
+                                compressor[def.name.unreferenced() ? "warn" : "info"]("Dropping unused variable {name} [{file}:{line},{col}]", template(def.name));
+                            }
+                            remove(sym.orig, def.name);
                         }
-                        node.definitions = def;
-                        if (side_effects) {
-                            side_effects.body.unshift(node);
-                            return in_list ? MAP.splice(side_effects.body) : side_effects;
+                    });
+                    if (head.length == 0 && tail.length == 1 && tail[0].name instanceof AST_SymbolVar) {
+                        var var_defs = var_defs_by_id.get(tail[0].name.definition().id);
+                        if (var_defs.length > 1) {
+                            var def = tail.pop();
+                            compressor.warn("Converting duplicated definition of variable {name} to assignment [{file}:{line},{col}]", template(def.name));
+                            remove(var_defs, def);
+                            remove(def.name.definition().orig, def.name);
+                            side_effects.unshift(make_node(AST_Assign, def, {
+                                operator: "=",
+                                left: make_node(AST_SymbolRef, def.name, def.name),
+                                right: def.value
+                            }));
                         }
-                        return node;
                     }
-                    if (drop_vars && assign_as_unused
-                        && node instanceof AST_Assign
-                        && node.operator == "="
-                        && node.left instanceof AST_SymbolRef) {
-                        var def = node.left.definition();
-                        if (!(def.id in in_use_ids)
-                            && self.variables.get(def.name) === def) {
+                    if (head.length > 0 || tail.length > 0) {
+                        node.definitions = head.concat(tail);
+                        body.push(node);
+                    }
+                    if (side_effects.length > 0) {
+                        body.push(make_node(AST_SimpleStatement, node, {
+                            body: make_sequence(node, side_effects)
+                        }));
+                    }
+                    switch (body.length) {
+                        case 0:
+                        return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);
+                        case 1:
+                        return body[0];
+                        default:
+                        return in_list ? MAP.splice(body) : make_node(AST_BlockStatement, node, {
+                            body: body
+                        });
+                    }
+                }
+                if (drop_vars) {
+                    var def = assign_as_unused(node);
+                    if (def instanceof AST_SymbolRef
+                        && !((def = def.definition()).id in in_use_ids)
+                        && self.variables.get(def.name) === def) {
+                        if (node instanceof AST_Assign) {
                             return maintain_this_binding(tt.parent(), node, node.right.transform(tt));
                         }
+                        return make_node(AST_Number, node, {
+                            value: 0
+                        });
                     }
-                    // certain combination of unused name + side effect leads to:
-                    //    https://github.com/mishoo/UglifyJS2/issues/44
-                    //    https://github.com/mishoo/UglifyJS2/issues/1830
-                    // that's an invalid AST.
-                    // We fix it at this stage by moving the `var` outside the `for`.
-                    if (node instanceof AST_For) {
-                        descend(node, this);
-                        if (node.init instanceof AST_BlockStatement) {
-                            var block = node.init;
-                            node.init = block.body.pop();
-                            block.body.push(node);
-                            return in_list ? MAP.splice(block.body) : block;
-                        } else if (is_empty(node.init)) {
-                            node.init = null;
-                        }
-                        return node;
+                }
+                // certain combination of unused name + side effect leads to:
+                //    https://github.com/mishoo/UglifyJS2/issues/44
+                //    https://github.com/mishoo/UglifyJS2/issues/1830
+                //    https://github.com/mishoo/UglifyJS2/issues/1838
+                // that's an invalid AST.
+                // We fix it at this stage by moving the `var` outside the `for`.
+                if (node instanceof AST_For) {
+                    descend(node, this);
+                    if (node.init instanceof AST_BlockStatement) {
+                        var block = node.init;
+                        node.init = block.body.pop();
+                        block.body.push(node);
+                        return in_list ? MAP.splice(block.body) : block;
+                    } else if (node.init instanceof AST_SimpleStatement) {
+                        node.init = node.init.body;
+                    } else if (is_empty(node.init)) {
+                        node.init = null;
                     }
-                    if (node instanceof AST_LabeledStatement && node.body instanceof AST_For) {
-                        descend(node, this);
-                        if (node.body instanceof AST_BlockStatement) {
-                            var block = node.body;
-                            node.body = block.body.pop();
-                            block.body.push(node);
-                            return in_list ? MAP.splice(block.body) : block;
-                        }
-                        return node;
+                    return node;
+                }
+                if (node instanceof AST_LabeledStatement && node.body instanceof AST_For) {
+                    descend(node, this);
+                    if (node.body instanceof AST_BlockStatement) {
+                        var block = node.body;
+                        node.body = block.body.pop();
+                        block.body.push(node);
+                        return in_list ? MAP.splice(block.body) : block;
                     }
-                    if (node instanceof AST_Scope && node !== self)
-                        return node;
+                    return node;
                 }
-            );
-            self.transform(tt);
-        }
+                if (node instanceof AST_Scope && node !== self)
+                    return node;
+
+                function template(sym) {
+                    return {
+                        name : sym.name,
+                        file : sym.start.file,
+                        line : sym.start.line,
+                        col  : sym.start.col
+                    };
+                }
+            }
+        );
+        self.transform(tt);
     });
 
     AST_Scope.DEFMETHOD("hoist_declarations", function(compressor){
@@ -2189,11 +2488,12 @@ merge(Compressor.prototype, {
                             dirs.push(node);
                             return make_node(AST_EmptyStatement, node);
                         }
-                        if (node instanceof AST_Defun && hoist_funs) {
+                        if (hoist_funs && node instanceof AST_Defun
+                            && (tt.parent() === self || !compressor.has_directive("use strict"))) {
                             hoisted.push(node);
                             return make_node(AST_EmptyStatement, node);
                         }
-                        if (node instanceof AST_Var && hoist_vars) {
+                        if (hoist_vars && node instanceof AST_Var) {
                             node.definitions.forEach(function(def){
                                 vars.set(def.name.name, def);
                                 ++vars_found;
@@ -2254,8 +2554,8 @@ merge(Compressor.prototype, {
                                 self.body.splice(i, 1);
                                 continue;
                             }
-                            if (expr instanceof AST_Seq
-                                && (assign = expr.car) instanceof AST_Assign
+                            if (expr instanceof AST_Sequence
+                                && (assign = expr.expressions[0]) instanceof AST_Assign
                                 && assign.operator == "="
                                 && (sym = assign.left) instanceof AST_Symbol
                                 && vars.has(sym.name))
@@ -2265,7 +2565,7 @@ merge(Compressor.prototype, {
                                 def.value = assign.right;
                                 remove(defs, def);
                                 defs.push(def);
-                                self.body[i].body = expr.cdr;
+                                self.body[i].body = make_sequence(expr, expr.expressions.slice(1));
                                 continue;
                             }
                         }
@@ -2299,12 +2599,14 @@ merge(Compressor.prototype, {
         // if all elements were dropped. Note: original array may be
         // returned if nothing changed.
         function trim(nodes, compressor, first_in_statement) {
+            var len = nodes.length;
+            if (!len) return null;
             var ret = [], changed = false;
-            for (var i = 0, len = nodes.length; i < len; i++) {
+            for (var i = 0; i < len; i++) {
                 var node = nodes[i].drop_side_effect_free(compressor, first_in_statement);
                 changed |= node !== nodes[i];
                 if (node) {
-                    ret.push(node);
+                    merge_sequence(ret, node);
                     first_in_statement = false;
                 }
             }
@@ -2319,7 +2621,7 @@ merge(Compressor.prototype, {
                 if (this.expression instanceof AST_Function
                     && (!this.expression.name || !this.expression.name.definition().references.length)) {
                     var node = this.clone();
-                    node.expression = node.expression.process_expression(false, compressor);
+                    node.expression.process_expression(false, compressor);
                     return node;
                 }
                 return this;
@@ -2329,7 +2631,7 @@ merge(Compressor.prototype, {
                 this.pure.value = this.pure.value.replace(/[@#]__PURE__/g, ' ');
             }
             var args = trim(this.args, compressor, first_in_statement);
-            return args && AST_Seq.from_array(args);
+            return args && make_sequence(this, args);
         });
         def(AST_Accessor, return_null);
         def(AST_Function, return_null);
@@ -2346,13 +2648,13 @@ merge(Compressor.prototype, {
               default:
                 var left = this.left.drop_side_effect_free(compressor, first_in_statement);
                 if (!left) return this.right.drop_side_effect_free(compressor, first_in_statement);
-                return make_node(AST_Seq, this, {
-                    car: left,
-                    cdr: right
-                });
+                return make_sequence(this, [ left, right ]);
             }
         });
-        def(AST_Assign, return_this);
+        def(AST_Assign, function(compressor){
+            this.write_only = !this.left.has_side_effects(compressor);
+            return this;
+        });
         def(AST_Conditional, function(compressor){
             var consequent = this.consequent.drop_side_effect_free(compressor);
             var alternative = this.alternative.drop_side_effect_free(compressor);
@@ -2373,7 +2675,10 @@ merge(Compressor.prototype, {
             return node;
         });
         def(AST_Unary, function(compressor, first_in_statement){
-            if (unary_side_effects(this.operator)) return this;
+            if (unary_side_effects(this.operator)) {
+                this.write_only = !this.expression.has_side_effects(compressor);
+                return this;
+            }
             if (this.operator == "typeof" && this.expression instanceof AST_SymbolRef) return null;
             var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
             if (first_in_statement
@@ -2387,19 +2692,19 @@ merge(Compressor.prototype, {
             }
             return expression;
         });
-        def(AST_SymbolRef, function() {
-            return this.undeclared() ? this : null;
+        def(AST_SymbolRef, function(compressor) {
+            return this.is_declared(compressor) ? null : this;
         });
         def(AST_Object, function(compressor, first_in_statement){
             var values = trim(this.properties, compressor, first_in_statement);
-            return values && AST_Seq.from_array(values);
+            return values && make_sequence(this, values);
         });
         def(AST_ObjectProperty, function(compressor, first_in_statement){
             return this.value.drop_side_effect_free(compressor, first_in_statement);
         });
         def(AST_Array, function(compressor, first_in_statement){
             var values = trim(this.elements, compressor, first_in_statement);
-            return values && AST_Seq.from_array(values);
+            return values && make_sequence(this, values);
         });
         def(AST_Dot, function(compressor, first_in_statement){
             if (this.expression.may_throw_on_access(compressor)) return this;
@@ -2411,19 +2716,15 @@ merge(Compressor.prototype, {
             if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);
             var property = this.property.drop_side_effect_free(compressor);
             if (!property) return expression;
-            return make_node(AST_Seq, this, {
-                car: expression,
-                cdr: property
-            });
+            return make_sequence(this, [ expression, property ]);
         });
-        def(AST_Seq, function(compressor){
-            var cdr = this.cdr.drop_side_effect_free(compressor);
-            if (cdr === this.cdr) return this;
-            if (!cdr) return this.car;
-            return make_node(AST_Seq, this, {
-                car: this.car,
-                cdr: cdr
-            });
+        def(AST_Sequence, function(compressor){
+            var last = this.expressions[this.expressions.length - 1];
+            var expr = last.drop_side_effect_free(compressor);
+            if (expr === last) return this;
+            var expressions = this.expressions.slice(0, -1);
+            if (expr) merge_sequence(expressions, expr);
+            return make_sequence(this, expressions);
         });
     })(function(node, func){
         node.DEFMETHOD("drop_side_effect_free", func);
@@ -2782,7 +3083,7 @@ merge(Compressor.prototype, {
     });
 
     OPT(AST_Try, function(self, compressor){
-        self.body = tighten_body(self.body, compressor);
+        tighten_body(self.body, compressor);
         if (self.bcatch && self.bfinally && all(self.bfinally.body, is_empty)) self.bfinally = null;
         if (all(self.body, is_empty)) {
             var body = [];
@@ -2814,7 +3115,7 @@ merge(Compressor.prototype, {
             return a;
         }, []);
         if (assignments.length == 0) return null;
-        return AST_Seq.from_array(assignments);
+        return make_sequence(this, assignments);
     });
 
     OPT(AST_Definitions, function(self, compressor){
@@ -2825,33 +3126,18 @@ merge(Compressor.prototype, {
 
     OPT(AST_Call, function(self, compressor){
         var exp = self.expression;
-        if (compressor.option("reduce_vars")
-            && exp instanceof AST_SymbolRef) {
-            var def = exp.definition();
-            var fixed = exp.fixed_value();
-            if (fixed instanceof AST_Defun) {
-                def.fixed = fixed = make_node(AST_Function, fixed, fixed).clone(true);
-            }
-            if (fixed instanceof AST_Function) {
-                exp = fixed;
-                if (compressor.option("unused")
-                    && def.references.length == 1
-                    && !(def.scope.uses_arguments
-                        && def.orig[0] instanceof AST_SymbolFunarg)
-                    && !def.scope.uses_eval
-                    && compressor.find_parent(AST_Scope) === def.scope) {
-                    self.expression = exp;
-                }
-            }
-        }
+        var fn = exp;
         if (compressor.option("unused")
-            && exp instanceof AST_Function
-            && !exp.uses_arguments
-            && !exp.uses_eval) {
+            && (fn instanceof AST_Function
+                || compressor.option("reduce_vars")
+                    && fn instanceof AST_SymbolRef
+                    && (fn = fn.fixed_value()) instanceof AST_Function)
+            && !fn.uses_arguments
+            && !fn.uses_eval) {
             var pos = 0, last = 0;
             for (var i = 0, len = self.args.length; i < len; i++) {
-                var trim = i >= exp.argnames.length;
-                if (trim || exp.argnames[i].__unused) {
+                var trim = i >= fn.argnames.length;
+                if (trim || fn.argnames[i].__unused) {
                     var node = self.args[i].drop_side_effect_free(compressor);
                     if (node) {
                         self.args[pos++] = node;
@@ -2869,7 +3155,7 @@ merge(Compressor.prototype, {
             self.args.length = last;
         }
         if (compressor.option("unsafe")) {
-            if (exp instanceof AST_SymbolRef && exp.undeclared()) {
+            if (is_undeclared_ref(exp)) {
                 switch (exp.name) {
                   case "Array":
                     if (self.args.length != 1) {
@@ -2913,62 +3199,6 @@ merge(Compressor.prototype, {
                         operator: "!"
                     }).optimize(compressor);
                     break;
-                  case "Function":
-                    // new Function() => function(){}
-                    if (self.args.length == 0) return make_node(AST_Function, self, {
-                        argnames: [],
-                        body: []
-                    });
-                    if (all(self.args, function(x){ return x instanceof AST_String })) {
-                        // quite a corner-case, but we can handle it:
-                        //   https://github.com/mishoo/UglifyJS2/issues/203
-                        // if the code argument is a constant, then we can minify it.
-                        try {
-                            var code = "(function(" + self.args.slice(0, -1).map(function(arg){
-                                return arg.value;
-                            }).join(",") + "){" + self.args[self.args.length - 1].value + "})()";
-                            var ast = parse(code);
-                            ast.figure_out_scope({ screw_ie8: compressor.option("screw_ie8") });
-                            var comp = new Compressor(compressor.options);
-                            ast = ast.transform(comp);
-                            ast.figure_out_scope({ screw_ie8: compressor.option("screw_ie8") });
-                            ast.mangle_names();
-                            var fun;
-                            try {
-                                ast.walk(new TreeWalker(function(node){
-                                    if (node instanceof AST_Lambda) {
-                                        fun = node;
-                                        throw ast;
-                                    }
-                                }));
-                            } catch(ex) {
-                                if (ex !== ast) throw ex;
-                            };
-                            if (!fun) return self;
-                            var args = fun.argnames.map(function(arg, i){
-                                return make_node(AST_String, self.args[i], {
-                                    value: arg.print_to_string()
-                                });
-                            });
-                            var code = OutputStream();
-                            AST_BlockStatement.prototype._codegen.call(fun, fun, code);
-                            code = code.toString().replace(/^\{|\}$/g, "");
-                            args.push(make_node(AST_String, self.args[self.args.length - 1], {
-                                value: code
-                            }));
-                            self.args = args;
-                            return self;
-                        } catch(ex) {
-                            if (ex instanceof JS_Parse_Error) {
-                                compressor.warn("Error parsing code passed to new Function [{file}:{line},{col}]", self.args[self.args.length - 1].start);
-                                compressor.warn(ex.toString());
-                            } else {
-                                console.log(ex);
-                                throw ex;
-                            }
-                        }
-                    }
-                    break;
                 }
             }
             else if (exp instanceof AST_Dot && exp.property == "toString" && self.args.length == 0) {
@@ -3051,17 +3281,116 @@ merge(Compressor.prototype, {
                 }
             }
         }
+        if (compressor.option("unsafe_Func")
+            && is_undeclared_ref(exp)
+            && exp.name == "Function") {
+            // new Function() => function(){}
+            if (self.args.length == 0) return make_node(AST_Function, self, {
+                argnames: [],
+                body: []
+            });
+            if (all(self.args, function(x) {
+                return x instanceof AST_String;
+            })) {
+                // quite a corner-case, but we can handle it:
+                //   https://github.com/mishoo/UglifyJS2/issues/203
+                // if the code argument is a constant, then we can minify it.
+                try {
+                    var code = "n(function(" + self.args.slice(0, -1).map(function(arg) {
+                        return arg.value;
+                    }).join(",") + "){" + self.args[self.args.length - 1].value + "})";
+                    var ast = parse(code);
+                    var mangle = { ie8: compressor.option("ie8") };
+                    ast.figure_out_scope(mangle);
+                    var comp = new Compressor(compressor.options);
+                    ast = ast.transform(comp);
+                    ast.figure_out_scope(mangle);
+                    base54.reset();
+                    ast.compute_char_frequency(mangle);
+                    ast.mangle_names(mangle);
+                    var fun;
+                    ast.walk(new TreeWalker(function(node) {
+                        if (fun) return true;
+                        if (node instanceof AST_Lambda) {
+                            fun = node;
+                            return true;
+                        }
+                    }));
+                    var code = OutputStream();
+                    AST_BlockStatement.prototype._codegen.call(fun, fun, code);
+                    self.args = [
+                        make_node(AST_String, self, {
+                            value: fun.argnames.map(function(arg) {
+                                return arg.print_to_string();
+                            }).join(",")
+                        }),
+                        make_node(AST_String, self.args[self.args.length - 1], {
+                            value: code.get().replace(/^\{|\}$/g, "")
+                        })
+                    ];
+                    return self;
+                } catch (ex) {
+                    if (ex instanceof JS_Parse_Error) {
+                        compressor.warn("Error parsing code passed to new Function [{file}:{line},{col}]", self.args[self.args.length - 1].start);
+                        compressor.warn(ex.toString());
+                    } else {
+                        throw ex;
+                    }
+                }
+            }
+        }
+        var stat = fn instanceof AST_Function && fn.body[0];
+        if (compressor.option("inline") && stat instanceof AST_Return) {
+            var value = stat.value;
+            if (!value || value.is_constant_expression()) {
+                var args = self.args.concat(value || make_node(AST_Undefined, self));
+                return make_sequence(self, args).optimize(compressor);
+            }
+        }
         if (exp instanceof AST_Function) {
-            if (exp.body[0] instanceof AST_Return) {
-                var value = exp.body[0].value;
-                if (!value || value.is_constant()) {
-                    var args = self.args.concat(value || make_node(AST_Undefined, self));
-                    return AST_Seq.from_array(args).transform(compressor);
+            if (compressor.option("inline")
+                && !exp.name
+                && !exp.uses_arguments
+                && !exp.uses_eval
+                && exp.body.length == 1
+                && all(exp.argnames, function(arg) {
+                    return arg.__unused;
+                })
+                && !self.has_pure_annotation(compressor)) {
+                var value;
+                if (stat instanceof AST_Return) {
+                    value = stat.value;
+                } else if (stat instanceof AST_SimpleStatement) {
+                    value = make_node(AST_UnaryPrefix, stat, {
+                        operator: "void",
+                        expression: stat.body
+                    });
+                }
+                if (value) {
+                    var tw = new TreeWalker(function(node) {
+                        if (!value) return true;
+                        if (node instanceof AST_SymbolRef) {
+                            var ref = node.scope.find_variable(node);
+                            if (ref && ref.scope.parent_scope === fn.parent_scope) {
+                                value = null;
+                                return true;
+                            }
+                        }
+                        if (node instanceof AST_This && !tw.find_parent(AST_Scope)) {
+                            value = null;
+                            return true;
+                        }
+                    });
+                    value.walk(tw);
+                }
+                if (value) {
+                    var args = self.args.concat(value);
+                    return make_sequence(self, args).optimize(compressor);
                 }
             }
             if (compressor.option("side_effects") && all(exp.body, is_empty)) {
                 var args = self.args.concat(make_node(AST_Undefined, self));
-                return AST_Seq.from_array(args).transform(compressor);
+                return make_sequence(self, args).optimize(compressor);
             }
         }
         if (compressor.option("drop_console")) {
@@ -3070,9 +3399,7 @@ merge(Compressor.prototype, {
                 while (name.expression) {
                     name = name.expression;
                 }
-                if (name instanceof AST_SymbolRef
-                    && name.name == "console"
-                    && name.undeclared()) {
+                if (is_undeclared_ref(name) && name.name == "console") {
                     return make_node(AST_Undefined, self).optimize(compressor);
                 }
             }
@@ -3082,13 +3409,18 @@ merge(Compressor.prototype, {
             && is_iife_call(self)) {
             return self.negate(compressor, true);
         }
+        var ev = self.evaluate(compressor);
+        if (ev !== self) {
+            ev = make_node_from_constant(ev, self).optimize(compressor);
+            return best_of(compressor, ev, self);
+        }
         return self;
     });
 
     OPT(AST_New, function(self, compressor){
         if (compressor.option("unsafe")) {
             var exp = self.expression;
-            if (exp instanceof AST_SymbolRef && exp.undeclared()) {
+            if (is_undeclared_ref(exp)) {
                 switch (exp.name) {
                   case "Object":
                   case "RegExp":
@@ -3102,73 +3434,118 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_Seq, function(self, compressor){
-        if (!compressor.option("side_effects"))
+    OPT(AST_Sequence, function(self, compressor){
+        if (!compressor.option("side_effects")) return self;
+        var expressions = [];
+        filter_for_side_effects();
+        var end = expressions.length - 1;
+        trim_right_for_undefined();
+        if (end > 0 && compressor.option("cascade")) trim_left_for_assignment();
+        if (end == 0) {
+            self = maintain_this_binding(compressor.parent(), self, expressions[0]);
+            if (!(self instanceof AST_Sequence)) self = self.optimize(compressor);
             return self;
-        self.car = self.car.drop_side_effect_free(compressor, first_in_statement(compressor));
-        if (!self.car) return maintain_this_binding(compressor.parent(), self, self.cdr);
-        if (compressor.option("cascade")) {
-            var left;
-            if (self.car instanceof AST_Assign
-                && !self.car.left.has_side_effects(compressor)) {
-                left = self.car.left;
-            } else if (self.car instanceof AST_Unary
-                && (self.car.operator == "++" || self.car.operator == "--")) {
-                left = self.car.expression;
-            }
-            if (left
-                && !(left instanceof AST_SymbolRef
-                    && (left.definition().orig[0] instanceof AST_SymbolLambda
-                        || is_reference_const(left)))) {
-                var parent, field;
-                var cdr = self.cdr;
+        }
+        self.expressions = expressions;
+        return self;
+
+        function filter_for_side_effects() {
+            var first = first_in_statement(compressor);
+            var last = self.expressions.length - 1;
+            self.expressions.forEach(function(expr, index) {
+                if (index < last) expr = expr.drop_side_effect_free(compressor, first);
+                if (expr) {
+                    merge_sequence(expressions, expr);
+                    first = false;
+                }
+            });
+        }
+
+        function trim_right_for_undefined() {
+            while (end > 0 && is_undefined(expressions[end], compressor)) end--;
+            if (end < expressions.length - 1) {
+                expressions[end] = make_node(AST_UnaryPrefix, self, {
+                    operator   : "void",
+                    expression : expressions[end]
+                });
+                expressions.length = end + 1;
+            }
+        }
+
+        function trim_left_for_assignment() {
+            for (var i = 0, j = 1; j <= end; j++) {
+                var left = expressions[i];
+                var cdr = expressions[j];
+                if (left instanceof AST_Assign
+                    && !left.left.has_side_effects(compressor)) {
+                    left = left.left;
+                } else if (left instanceof AST_Unary
+                    && (left.operator == "++" || left.operator == "--")) {
+                    left = left.expression;
+                } else left = null;
+                if (!left || is_lhs_read_only(left)) {
+                    expressions[++i] = cdr;
+                    continue;
+                }
+                var parent = null, field;
+                expressions[j] = cdr = cdr.clone();
                 while (true) {
                     if (cdr.equivalent_to(left)) {
-                        var car = self.car instanceof AST_UnaryPostfix ? make_node(AST_UnaryPrefix, self.car, {
-                            operator: self.car.operator,
-                            expression: left
-                        }) : self.car;
+                        var car = expressions[i];
+                        if (car instanceof AST_UnaryPostfix) {
+                            car = make_node(AST_UnaryPrefix, car, {
+                                operator: car.operator,
+                                expression: left
+                            });
+                        } else {
+                            car.write_only = false;
+                        }
                         if (parent) {
                             parent[field] = car;
-                            return self.cdr;
+                            expressions[i] = expressions[j];
+                        } else {
+                            expressions[i] = car;
                         }
-                        return car;
+                        break;
                     }
                     if (cdr instanceof AST_Binary && !(cdr instanceof AST_Assign)) {
                         if (cdr.left.is_constant()) {
-                            if (cdr.operator == "||" || cdr.operator == "&&") break;
+                            if (cdr.operator == "||" || cdr.operator == "&&") {
+                                expressions[++i] = expressions[j];
+                                break;
+                            }
                             field = "right";
                         } else {
                             field = "left";
                         }
                     } else if (cdr instanceof AST_Call
+                            && !(left instanceof AST_PropAccess && cdr.expression.equivalent_to(left))
+                        || cdr instanceof AST_PropAccess
                         || cdr instanceof AST_Unary && !unary_side_effects(cdr.operator)) {
                         field = "expression";
-                    } else break;
+                    } else if (cdr instanceof AST_Conditional) {
+                        field = "condition";
+                    } else {
+                        expressions[++i] = expressions[j];
+                        break;
+                    }
                     parent = cdr;
-                    cdr = cdr[field];
+                    cdr = cdr[field] = cdr[field].clone();
                 }
             }
+            end = i;
+            expressions.length = end + 1;
         }
-        if (is_undefined(self.cdr, compressor)) {
-            return make_node(AST_UnaryPrefix, self, {
-                operator   : "void",
-                expression : self.car
-            });
-        }
-        return self;
     });
 
     AST_Unary.DEFMETHOD("lift_sequences", function(compressor){
         if (compressor.option("sequences")) {
-            if (this.expression instanceof AST_Seq) {
-                var seq = this.expression;
-                var x = seq.to_array();
+            if (this.expression instanceof AST_Sequence) {
+                var x = this.expression.expressions.slice();
                 var e = this.clone();
                 e.expression = x.pop();
                 x.push(e);
-                seq = AST_Seq.from_array(x).transform(compressor);
-                return seq;
+                return make_sequence(this, x).optimize(compressor);
             }
         }
         return this;
@@ -3186,15 +3563,12 @@ merge(Compressor.prototype, {
                 || e instanceof AST_NaN
                 || e instanceof AST_Infinity
                 || e instanceof AST_Undefined)) {
-            if (e instanceof AST_Seq) {
-                e = e.to_array();
+            if (e instanceof AST_Sequence) {
+                e = e.expressions.slice();
                 e.push(make_node(AST_True, self));
-                return AST_Seq.from_array(e).optimize(compressor);
+                return make_sequence(self, e).optimize(compressor);
             }
-            return make_node(AST_Seq, self, {
-                car: e,
-                cdr: make_node(AST_True, self)
-            }).optimize(compressor);
+            return make_sequence(self, [ e, make_node(AST_True, self) ]).optimize(compressor);
         }
         var seq = self.lift_sequences(compressor);
         if (seq !== self) {
@@ -3224,10 +3598,10 @@ merge(Compressor.prototype, {
                 // typeof always returns a non-empty string, thus it's
                 // always true in booleans
                 compressor.warn("Boolean expression always true [{file}:{line},{col}]", self.start);
-                return (e instanceof AST_SymbolRef ? make_node(AST_True, self) : make_node(AST_Seq, self, {
-                    car: e,
-                    cdr: make_node(AST_True, self)
-                })).optimize(compressor);
+                return (e instanceof AST_SymbolRef ? make_node(AST_True, self) : make_sequence(self, [
+                    e,
+                    make_node(AST_True, self)
+                ])).optimize(compressor);
             }
         }
         if (self.operator == "-" && e instanceof AST_Infinity) {
@@ -3259,29 +3633,32 @@ merge(Compressor.prototype, {
 
     AST_Binary.DEFMETHOD("lift_sequences", function(compressor){
         if (compressor.option("sequences")) {
-            if (this.left instanceof AST_Seq) {
-                var seq = this.left;
-                var x = seq.to_array();
+            if (this.left instanceof AST_Sequence) {
+                var x = this.left.expressions.slice();
                 var e = this.clone();
                 e.left = x.pop();
                 x.push(e);
-                return AST_Seq.from_array(x).optimize(compressor);
+                return make_sequence(this, x).optimize(compressor);
             }
-            if (this.right instanceof AST_Seq && !this.left.has_side_effects(compressor)) {
+            if (this.right instanceof AST_Sequence && !this.left.has_side_effects(compressor)) {
                 var assign = this.operator == "=" && this.left instanceof AST_SymbolRef;
-                var root = this.right.clone();
-                var cursor, seq = root;
-                while (assign || !seq.car.has_side_effects(compressor)) {
-                    cursor = seq;
-                    if (seq.cdr instanceof AST_Seq) {
-                        seq = seq.cdr = seq.cdr.clone();
-                    } else break;
+                var x = this.right.expressions;
+                var last = x.length - 1;
+                for (var i = 0; i < last; i++) {
+                    if (!assign && x[i].has_side_effects(compressor)) break;
                 }
-                if (cursor) {
+                if (i == last) {
+                    x = x.slice();
                     var e = this.clone();
-                    e.right = cursor.cdr;
-                    cursor.cdr = e;
-                    return root.optimize(compressor);
+                    e.right = x.pop();
+                    x.push(e);
+                    return make_sequence(this, x).optimize(compressor);
+                } else if (i > 0) {
+                    var e = this.clone();
+                    e.right = make_sequence(this.right, x.slice(i));
+                    x = x.slice(0, i);
+                    x.push(e);
+                    return make_sequence(this, x).optimize(compressor);
                 }
             }
         }
@@ -3331,13 +3708,14 @@ merge(Compressor.prototype, {
           case "==":
           case "!=":
             // "undefined" == typeof x => undefined === x
-            if (self.left instanceof AST_String
+            if (compressor.option("typeofs")
+                && self.left instanceof AST_String
                 && self.left.value == "undefined"
                 && self.right instanceof AST_UnaryPrefix
                 && self.right.operator == "typeof") {
                 var expr = self.right.expression;
-                if (expr instanceof AST_SymbolRef ? !expr.undeclared()
-                    : !(expr instanceof AST_PropAccess) || compressor.option("screw_ie8")) {
+                if (expr instanceof AST_SymbolRef ? expr.is_declared(compressor)
+                    : !(expr instanceof AST_PropAccess && compressor.option("ie8"))) {
                     self.right = expr;
                     self.left = make_node(AST_Undefined, self.left).optimize(compressor);
                     if (self.operator.length == 2) self.operator += "=";
@@ -3350,17 +3728,17 @@ merge(Compressor.prototype, {
             var rr = self.right.evaluate(compressor);
             if (ll && typeof ll == "string") {
                 compressor.warn("+ in boolean context always true [{file}:{line},{col}]", self.start);
-                return make_node(AST_Seq, self, {
-                    car: self.right,
-                    cdr: make_node(AST_True, self)
-                }).optimize(compressor);
+                return make_sequence(self, [
+                    self.right,
+                    make_node(AST_True, self)
+                ]).optimize(compressor);
             }
             if (rr && typeof rr == "string") {
                 compressor.warn("+ in boolean context always true [{file}:{line},{col}]", self.start);
-                return make_node(AST_Seq, self, {
-                    car: self.left,
-                    cdr: make_node(AST_True, self)
-                }).optimize(compressor);
+                return make_sequence(self, [
+                    self.left,
+                    make_node(AST_True, self)
+                ]).optimize(compressor);
             }
         }
         if (compressor.option("comparisons") && self.is_boolean()) {
@@ -3414,10 +3792,10 @@ merge(Compressor.prototype, {
                     var rr = self.right.evaluate(compressor);
                     if (!rr) {
                         compressor.warn("Boolean && always false [{file}:{line},{col}]", self.start);
-                        return make_node(AST_Seq, self, {
-                            car: self.left,
-                            cdr: make_node(AST_False, self)
-                        }).optimize(compressor);
+                        return make_sequence(self, [
+                            self.left,
+                            make_node(AST_False, self)
+                        ]).optimize(compressor);
                     } else if (rr !== self.right) {
                         compressor.warn("Dropping side-effect-free && in boolean context [{file}:{line},{col}]", self.start);
                         return self.left.optimize(compressor);
@@ -3440,10 +3818,10 @@ merge(Compressor.prototype, {
                         return self.left.optimize(compressor);
                     } else if (rr !== self.right) {
                         compressor.warn("Boolean || always true [{file}:{line},{col}]", self.start);
-                        return make_node(AST_Seq, self, {
-                            car: self.left,
-                            cdr: make_node(AST_True, self)
-                        }).optimize(compressor);
+                        return make_sequence(self, [
+                            self.left,
+                            make_node(AST_True, self)
+                        ]).optimize(compressor);
                     }
                 }
                 break;
@@ -3661,8 +4039,8 @@ merge(Compressor.prototype, {
             return def.optimize(compressor);
         }
         // testing against !self.scope.uses_with first is an optimization
-        if (compressor.option("screw_ie8")
-            && self.undeclared()
+        if (!compressor.option("ie8")
+            && is_undeclared_ref(self)
             && (!self.scope.uses_with || !compressor.find_parent(AST_With))) {
             switch (self.name) {
               case "undefined":
@@ -3673,17 +4051,27 @@ merge(Compressor.prototype, {
                 return make_node(AST_Infinity, self).optimize(compressor);
             }
         }
-        if (compressor.option("evaluate")
-            && compressor.option("reduce_vars")
+        if (compressor.option("reduce_vars")
             && is_lhs(self, compressor.parent()) !== self) {
             var d = self.definition();
             var fixed = self.fixed_value();
-            if (fixed) {
+            if (fixed instanceof AST_Defun) {
+                d.fixed = fixed = make_node(AST_Function, fixed, fixed);
+            }
+            if (compressor.option("unused")
+                && fixed instanceof AST_Function
+                && d.references.length == 1
+                && !(d.scope.uses_arguments && d.orig[0] instanceof AST_SymbolFunarg)
+                && !d.scope.uses_eval
+                && compressor.find_parent(AST_Scope) === fixed.parent_scope) {
+                return fixed.clone(true);
+            }
+            if (compressor.option("evaluate") && fixed) {
                 if (d.should_replace === undefined) {
                     var init = fixed.evaluate(compressor);
                     if (init !== fixed && (compressor.option("unsafe_regexp") || !(init instanceof RegExp))) {
                         init = make_node_from_constant(init, fixed);
-                        var value = init.optimize(compressor).print_to_string().length;
+                        var value_length = init.optimize(compressor).print_to_string().length;
                         var fn;
                         if (has_symbol_ref(fixed)) {
                             fn = function() {
@@ -3691,18 +4079,18 @@ merge(Compressor.prototype, {
                                 return result === init ? result.clone(true) : result;
                             };
                         } else {
-                            value = Math.min(value, fixed.print_to_string().length);
+                            value_length = Math.min(value_length, fixed.print_to_string().length);
                             fn = function() {
                                 var result = best_of_expression(init.optimize(compressor), fixed);
                                 return result === init || result === fixed ? result.clone(true) : result;
                             };
                         }
-                        var name = d.name.length;
+                        var name_length = d.name.length;
                         var overhead = 0;
-                        if (compressor.option("unused") && (!d.global || compressor.option("toplevel"))) {
-                            overhead = (name + 2 + value) / d.references.length;
+                        if (compressor.option("unused") && !compressor.exposed(d)) {
+                            overhead = (name_length + 2 + value_length) / d.references.length;
                         }
-                        d.should_replace = value <= name + overhead ? fn : false;
+                        d.should_replace = value_length <= name_length + overhead ? fn : false;
                     } else {
                         d.should_replace = false;
                     }
@@ -3813,10 +4201,12 @@ merge(Compressor.prototype, {
 
     OPT(AST_Conditional, function(self, compressor){
         if (!compressor.option("conditionals")) return self;
-        if (self.condition instanceof AST_Seq) {
-            var car = self.condition.car;
-            self.condition = self.condition.cdr;
-            return AST_Seq.cons(car, self);
+        // This looks like lift_sequences(), should probably be under "sequences"
+        if (self.condition instanceof AST_Sequence) {
+            var expressions = self.condition.expressions.slice();
+            self.condition = expressions.pop();
+            expressions.push(self);
+            return make_sequence(self, expressions);
         }
         var cond = self.condition.evaluate(compressor);
         if (cond !== self.condition) {
@@ -3899,10 +4289,10 @@ merge(Compressor.prototype, {
         }
         // x ? y : y --> x, y
         if (consequent.equivalent_to(alternative)) {
-            return make_node(AST_Seq, self, {
-                car: self.condition,
-                cdr: consequent
-            }).optimize(compressor);
+            return make_sequence(self, [
+                self.condition,
+                consequent
+            ]).optimize(compressor);
         }
 
         if (is_true(self.consequent)) {
@@ -4005,7 +4395,7 @@ merge(Compressor.prototype, {
         var prop = self.property;
         if (prop instanceof AST_String && compressor.option("properties")) {
             prop = prop.getValue();
-            if (RESERVED_WORDS(prop) ? compressor.option("screw_ie8") : is_identifier_string(prop)) {
+            if (is_identifier_string(prop)) {
                 return make_node(AST_Dot, self, {
                     expression : self.expression,
                     property   : prop
@@ -4026,25 +4416,41 @@ merge(Compressor.prototype, {
         return self;
     });
 
+    AST_Lambda.DEFMETHOD("contains_this", function() {
+        var result;
+        var self = this;
+        self.walk(new TreeWalker(function(node) {
+            if (result) return true;
+            if (node instanceof AST_This) return result = true;
+            if (node !== self && node instanceof AST_Scope) return true;
+        }));
+        return result;
+    });
+
     OPT(AST_Dot, function(self, compressor){
         var def = self.resolve_defines(compressor);
         if (def) {
             return def.optimize(compressor);
         }
-        var prop = self.property;
-        if (RESERVED_WORDS(prop) && !compressor.option("screw_ie8")) {
-            return make_node(AST_Sub, self, {
-                expression : self.expression,
-                property   : make_node(AST_String, self, {
-                    value: prop
-                })
-            }).optimize(compressor);
+        if (compressor.option("unsafe") && self.expression instanceof AST_Object) {
+            var values = self.expression.properties;
+            for (var i = values.length; --i >= 0;) {
+                if (values[i].key === self.property) {
+                    var value = values[i].value;
+                    if (value instanceof AST_Function ? !value.contains_this() : !value.has_side_effects(compressor)) {
+                        var obj = self.expression.clone();
+                        obj.properties = obj.properties.slice();
+                        obj.properties.splice(i, 1);
+                        return make_sequence(self, [ obj, value ]).optimize(compressor);
+                    }
+                }
+            }
         }
         if (compressor.option("unsafe_proto")
             && self.expression instanceof AST_Dot
             && self.expression.property == "prototype") {
             var exp = self.expression.expression;
-            if (exp instanceof AST_SymbolRef && exp.undeclared()) switch (exp.name) {
+            if (is_undeclared_ref(exp)) switch (exp.name) {
               case "Array":
                 self.expression = make_node(AST_Array, self.expression, {
                     elements: []
@@ -4072,10 +4478,10 @@ merge(Compressor.prototype, {
 
     function literals_in_boolean_context(self, compressor) {
         if (compressor.option("booleans") && compressor.in_boolean_context()) {
-            return best_of(compressor, self, make_node(AST_Seq, self, {
-                car: self,
-                cdr: make_node(AST_True, self)
-            }).optimize(compressor));
+            return best_of(compressor, self, make_sequence(self, [
+                self,
+                make_node(AST_True, self)
+            ]).optimize(compressor));
         }
         return self;
     };
diff --git a/node_modules/uglify-js/lib/minify.js b/node_modules/uglify-js/lib/minify.js
new file mode 100644
index 000000000..773e953ae
--- /dev/null
+++ b/node_modules/uglify-js/lib/minify.js
@@ -0,0 +1,220 @@
+"use strict";
+
+var to_ascii = typeof atob == "undefined" ? function(b64) {
+    return new Buffer(b64, "base64").toString();
+} : atob;
+var to_base64 = typeof btoa == "undefined" ? function(str) {
+    return new Buffer(str).toString("base64");
+} : btoa;
+
+function read_source_map(code) {
+    var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
+    if (!match) {
+        AST_Node.warn("inline source map not found");
+        return null;
+    }
+    return to_ascii(match[2]);
+}
+
+function set_shorthand(name, options, keys) {
+    if (options[name]) {
+        keys.forEach(function(key) {
+            if (options[key]) {
+                if (typeof options[key] != "object") options[key] = {};
+                if (!(name in options[key])) options[key][name] = options[name];
+            }
+        });
+    }
+}
+
+function init_cache(cache) {
+    if (!cache) return;
+    if (!("cname" in cache)) cache.cname = -1;
+    if (!("props" in cache)) {
+        cache.props = new Dictionary();
+    } else if (!(cache.props instanceof Dictionary)) {
+        cache.props = Dictionary.fromObject(cache.props);
+    }
+}
+
+function to_json(cache) {
+    return {
+        cname: cache.cname,
+        props: cache.props.toObject()
+    };
+}
+
+function minify(files, options) {
+    var warn_function = AST_Node.warn_function;
+    try {
+        options = defaults(options, {
+            compress: {},
+            ie8: false,
+            keep_fnames: false,
+            mangle: {},
+            nameCache: null,
+            output: {},
+            parse: {},
+            sourceMap: false,
+            timings: false,
+            toplevel: false,
+            warnings: false,
+            wrap: false,
+        }, true);
+        var timings = options.timings && {
+            start: Date.now()
+        };
+        set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
+        set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
+        set_shorthand("toplevel", options, [ "compress", "mangle" ]);
+        set_shorthand("warnings", options, [ "compress" ]);
+        var quoted_props;
+        if (options.mangle) {
+            options.mangle = defaults(options.mangle, {
+                cache: options.nameCache && (options.nameCache.vars || {}),
+                eval: false,
+                ie8: false,
+                keep_fnames: false,
+                properties: false,
+                reserved: [],
+                toplevel: false,
+            }, true);
+            if (options.mangle.properties) {
+                if (typeof options.mangle.properties != "object") {
+                    options.mangle.properties = {};
+                }
+                if (options.mangle.properties.keep_quoted) {
+                    quoted_props = options.mangle.properties.reserved;
+                    if (!Array.isArray(quoted_props)) quoted_props = [];
+                    options.mangle.properties.reserved = quoted_props;
+                }
+                if (options.nameCache && !("cache" in options.mangle.properties)) {
+                    options.mangle.properties.cache = options.nameCache.props || {};
+                }
+            }
+            init_cache(options.mangle.cache);
+            init_cache(options.mangle.properties.cache);
+        }
+        if (options.sourceMap) {
+            options.sourceMap = defaults(options.sourceMap, {
+                content: null,
+                filename: null,
+                includeSources: false,
+                root: null,
+                url: null,
+            }, true);
+        }
+        var warnings = [];
+        if (options.warnings && !AST_Node.warn_function) {
+            AST_Node.warn_function = function(warning) {
+                warnings.push(warning);
+            };
+        }
+        if (timings) timings.parse = Date.now();
+        var toplevel;
+        if (files instanceof AST_Toplevel) {
+            toplevel = files;
+        } else {
+            if (typeof files == "string") {
+                files = [ files ];
+            }
+            options.parse = options.parse || {};
+            options.parse.toplevel = null;
+            for (var name in files) if (HOP(files, name)) {
+                options.parse.filename = name;
+                options.parse.toplevel = parse(files[name], options.parse);
+                if (options.sourceMap && options.sourceMap.content == "inline") {
+                    if (Object.keys(files).length > 1)
+                        throw new Error("inline source map only works with singular input");
+                    options.sourceMap.content = read_source_map(files[name]);
+                }
+            }
+            toplevel = options.parse.toplevel;
+        }
+        if (quoted_props) {
+            reserve_quoted_keys(toplevel, quoted_props);
+        }
+        if (options.wrap) {
+            toplevel = toplevel.wrap_commonjs(options.wrap);
+        }
+        if (timings) timings.scope1 = Date.now();
+        if (options.compress) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.compress = Date.now();
+        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+        if (timings) timings.scope2 = Date.now();
+        if (options.mangle) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.mangle = Date.now();
+        if (options.mangle) {
+            base54.reset();
+            toplevel.compute_char_frequency(options.mangle);
+            toplevel.mangle_names(options.mangle);
+        }
+        if (timings) timings.properties = Date.now();
+        if (options.mangle && options.mangle.properties) {
+            toplevel = mangle_properties(toplevel, options.mangle.properties);
+        }
+        if (timings) timings.output = Date.now();
+        var result = {};
+        if (options.output.ast) {
+            result.ast = toplevel;
+        }
+        if (!HOP(options.output, "code") || options.output.code) {
+            if (options.sourceMap) {
+                if (typeof options.sourceMap.content == "string") {
+                    options.sourceMap.content = JSON.parse(options.sourceMap.content);
+                }
+                options.output.source_map = SourceMap({
+                    file: options.sourceMap.filename,
+                    orig: options.sourceMap.content,
+                    root: options.sourceMap.root
+                });
+                if (options.sourceMap.includeSources) {
+                    if (files instanceof AST_Toplevel) {
+                        throw new Error("original source content unavailable");
+                    } else for (var name in files) if (HOP(files, name)) {
+                        options.output.source_map.get().setSourceContent(name, files[name]);
+                    }
+                }
+            }
+            delete options.output.ast;
+            delete options.output.code;
+            var stream = OutputStream(options.output);
+            toplevel.print(stream);
+            result.code = stream.get();
+            if (options.sourceMap) {
+                result.map = options.output.source_map.toString();
+                if (options.sourceMap.url == "inline") {
+                    result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(result.map);
+                } else if (options.sourceMap.url) {
+                    result.code += "\n//# sourceMappingURL=" + options.sourceMap.url;
+                }
+            }
+        }
+        if (options.nameCache && options.mangle) {
+            if (options.mangle.cache) options.nameCache.vars = to_json(options.mangle.cache);
+            if (options.mangle.properties && options.mangle.properties.cache) {
+                options.nameCache.props = to_json(options.mangle.properties.cache);
+            }
+        }
+        if (timings) {
+            timings.end = Date.now();
+            result.timings = {
+                parse: 1e-3 * (timings.scope1 - timings.parse),
+                scope: 1e-3 * (timings.compress - timings.scope1 + timings.mangle - timings.scope2),
+                compress: 1e-3 * (timings.scope2 - timings.compress),
+                mangle: 1e-3 * (timings.properties - timings.mangle),
+                properties: 1e-3 * (timings.output - timings.properties),
+                output: 1e-3 * (timings.end - timings.output),
+                total: 1e-3 * (timings.end - timings.start)
+            }
+        }
+        if (warnings.length) {
+            result.warnings = warnings;
+        }
+        return result;
+    } catch (ex) {
+        return { error: ex };
+    } finally {
+        AST_Node.warn_function = warn_function;
+    }
+}
diff --git a/node_modules/uglify-js/lib/mozilla-ast.js b/node_modules/uglify-js/lib/mozilla-ast.js
index 88a2eb59f..8d7ee4b85 100644
--- a/node_modules/uglify-js/lib/mozilla-ast.js
+++ b/node_modules/uglify-js/lib/mozilla-ast.js
@@ -145,7 +145,11 @@
             });
         },
         SequenceExpression: function(M) {
-            return AST_Seq.from_array(M.expressions.map(from_moz));
+            return new AST_Sequence({
+                start      : my_start_token(M),
+                end        : my_end_token(M),
+                expressions: M.expressions.map(from_moz)
+            });
         },
         MemberExpression: function(M) {
             return new (M.computed ? AST_Sub : AST_Dot)({
@@ -164,7 +168,7 @@
             });
         },
         VariableDeclaration: function(M) {
-            return new (M.kind === "const" ? AST_Const : AST_Var)({
+            return new AST_Var({
                 start       : my_start_token(M),
                 end         : my_end_token(M),
                 definitions : M.declarations.map(from_moz)
@@ -200,7 +204,7 @@
         Identifier: function(M) {
             var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
             return new (  p.type == "LabeledStatement" ? AST_Label
-                        : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
+                        : p.type == "VariableDeclarator" && p.id === M ? AST_SymbolVar
                         : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
                         : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
                         : p.type == "CatchClause" ? AST_SymbolCatch
@@ -320,15 +324,15 @@
     def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
         return {
             type: "VariableDeclaration",
-            kind: M instanceof AST_Const ? "const" : "var",
+            kind: "var",
             declarations: M.definitions.map(to_moz)
         };
     });
 
-    def_to_moz(AST_Seq, function To_Moz_SequenceExpression(M) {
+    def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) {
         return {
             type: "SequenceExpression",
-            expressions: M.to_array().map(to_moz)
+            expressions: M.expressions.map(to_moz)
         };
     });
 
diff --git a/node_modules/uglify-js/lib/output.js b/node_modules/uglify-js/lib/output.js
index 0731fb492..4c873f10d 100644
--- a/node_modules/uglify-js/lib/output.js
+++ b/node_modules/uglify-js/lib/output.js
@@ -57,6 +57,7 @@ function OutputStream(options) {
         beautify         : false,
         bracketize       : false,
         comments         : false,
+        ie8              : false,
         indent_level     : 4,
         indent_start     : 0,
         inline_script    : true,
@@ -66,12 +67,10 @@ function OutputStream(options) {
         preserve_line    : false,
         quote_keys       : false,
         quote_style      : 0,
-        screw_ie8        : true,
         semicolons       : true,
         shebang          : true,
         source_map       : null,
-        space_colon      : true,
-        unescape_regexps : false,
+        webkit           : false,
         width            : 80,
         wrap_iife        : false,
     }, true);
@@ -110,7 +109,7 @@ function OutputStream(options) {
     var current_pos = 0;
     var OUTPUT = "";
 
-    function to_ascii(str, identifier) {
+    var to_utf8 = options.ascii_only ? function(str, identifier) {
         return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
             var code = ch.charCodeAt(0).toString(16);
             if (code.length <= 2 && !identifier) {
@@ -121,6 +120,12 @@ function OutputStream(options) {
                 return "\\u" + code;
             }
         });
+    } : function(str) {
+        return str.replace(/[\ud800-\udbff](?![\udc00-\udfff])/g, function(ch) {
+            return "\\u" + ch.charCodeAt(0).toString(16);
+        }).replace(/(^|[^\ud800-\udbff])([\udc00-\udfff])/g, function(match, prefix, ch) {
+            return prefix + "\\u" + ch.charCodeAt(0).toString(16);
+        });
     };
 
     function make_string(str, quote) {
@@ -136,7 +141,7 @@ function OutputStream(options) {
               case "\t": return "\\t";
               case "\b": return "\\b";
               case "\f": return "\\f";
-              case "\x0B": return options.screw_ie8 ? "\\v" : "\\x0B";
+              case "\x0B": return options.ie8 ? "\\x0B" : "\\v";
               case "\u2028": return "\\u2028";
               case "\u2029": return "\\u2029";
               case "\ufeff": return "\\ufeff";
@@ -151,7 +156,7 @@ function OutputStream(options) {
         function quote_double() {
             return '"' + str.replace(/\x22/g, '\\"') + '"';
         }
-        if (options.ascii_only) str = to_ascii(str);
+        str = to_utf8(str);
         switch (options.quote_style) {
           case 1:
             return quote_single();
@@ -176,8 +181,7 @@ function OutputStream(options) {
 
     function make_name(name) {
         name = name.toString();
-        if (options.ascii_only)
-            name = to_ascii(name, true);
+        name = to_utf8(name, true);
         return name;
     };
 
@@ -191,12 +195,43 @@ function OutputStream(options) {
     var might_need_semicolon = false;
     var might_add_newline = 0;
     var last = "";
+    var mapping_token, mapping_name, mappings = options.source_map && [];
+
+    var do_add_mapping = mappings ? function() {
+        mappings.forEach(function(mapping) {
+            try {
+                options.source_map.add(
+                    mapping.token.file,
+                    mapping.line, mapping.col,
+                    mapping.token.line, mapping.token.col,
+                    !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name
+                );
+            } catch(ex) {
+                AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
+                    file: mapping.token.file,
+                    line: mapping.token.line,
+                    col: mapping.token.col,
+                    cline: mapping.line,
+                    ccol: mapping.col,
+                    name: mapping.name || ""
+                })
+            }
+        });
+        mappings = [];
+    } : noop;
 
     var ensure_line_len = options.max_line_len ? function() {
         if (current_col > options.max_line_len) {
             if (might_add_newline) {
                 var left = OUTPUT.slice(0, might_add_newline);
                 var right = OUTPUT.slice(might_add_newline);
+                if (mappings) {
+                    var delta = right.length - current_col;
+                    mappings.forEach(function(mapping) {
+                        mapping.line++;
+                        mapping.col += delta;
+                    });
+                }
                 OUTPUT = left + "\n" + right;
                 current_line++;
                 current_pos++;
@@ -206,7 +241,10 @@ function OutputStream(options) {
                 AST_Node.warn("Output exceeds {max_line_len} characters", options);
             }
         }
-        might_add_newline = 0;
+        if (might_add_newline) {
+            might_add_newline = 0;
+            do_add_mapping();
+        }
     } : noop;
 
     var requireSemicolonChars = makePredicate("( [ + * / - , .");
@@ -266,6 +304,18 @@ function OutputStream(options) {
             }
             might_need_space = false;
         }
+
+        if (mapping_token) {
+            mappings.push({
+                token: mapping_token,
+                name: mapping_name,
+                line: current_line,
+                col: current_col
+            });
+            mapping_token = false;
+            if (!might_add_newline) do_add_mapping();
+        }
+
         OUTPUT += str;
         current_pos += str.length;
         var a = str.split(/\r?\n/), n = a.length - 1;
@@ -357,27 +407,12 @@ function OutputStream(options) {
 
     function colon() {
         print(":");
-        if (options.space_colon) space();
+        space();
     };
 
-    var add_mapping = options.source_map ? function(token, name) {
-        try {
-            if (token) options.source_map.add(
-                token.file || "?",
-                current_line, current_col,
-                token.line, token.col,
-                (!name && token.type == "name") ? token.value : name
-            );
-        } catch(ex) {
-            AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
-                file: token.file,
-                line: token.line,
-                col: token.col,
-                cline: current_line,
-                ccol: current_col,
-                name: name || ""
-            })
-        }
+    var add_mapping = mappings ? function(token, name) {
+        mapping_token = token;
+        mapping_name = name;
     } : noop;
 
     function get() {
@@ -403,7 +438,7 @@ function OutputStream(options) {
         last            : function() { return last },
         semicolon       : semicolon,
         force_semicolon : force_semicolon,
-        to_ascii        : to_ascii,
+        to_utf8         : to_utf8,
         print_name      : function(name) { print(make_name(name)) },
         print_string    : function(str, quote, escape_directive) {
             var encoded = encode_string(str, quote);
@@ -471,6 +506,7 @@ function OutputStream(options) {
             use_asm = prev_use_asm;
         }
     });
+    AST_Node.DEFMETHOD("_print", AST_Node.prototype.print);
 
     AST_Node.DEFMETHOD("print_to_string", function(options){
         var s = OutputStream(options);
@@ -568,6 +604,13 @@ function OutputStream(options) {
             return true;
         }
 
+        if (output.option('webkit')) {
+            var p = output.parent();
+            if (p instanceof AST_PropAccess && p.expression === this) {
+                return true;
+            }
+        }
+
         if (output.option('wrap_iife')) {
             var p = output.parent();
             return p instanceof AST_Call && p.expression === this;
@@ -588,7 +631,7 @@ function OutputStream(options) {
             || p instanceof AST_Call && p.expression === this;
     });
 
-    PARENS(AST_Seq, function(output){
+    PARENS(AST_Sequence, function(output){
         var p = output.parent();
         return p instanceof AST_Call             // (foo, bar)() or foo(1, (2, 3), 4)
             || p instanceof AST_Unary            // !(foo, bar, baz)
@@ -634,14 +677,15 @@ function OutputStream(options) {
             // parens around it too, otherwise the call will be
             // interpreted as passing the arguments to the upper New
             // expression.
-            try {
-                this.walk(new TreeWalker(function(node){
-                    if (node instanceof AST_Call) throw p;
-                }));
-            } catch(ex) {
-                if (ex !== p) throw ex;
-                return true;
-            }
+            var parens = false;
+            this.walk(new TreeWalker(function(node) {
+                if (parens || node instanceof AST_Scope) return true;
+                if (node instanceof AST_Call) {
+                    parens = true;
+                    return true;
+                }
+            }));
+            return parens;
         }
     });
 
@@ -677,7 +721,7 @@ function OutputStream(options) {
         }
     });
 
-    PARENS([ AST_Assign, AST_Conditional ], function (output){
+    PARENS([ AST_Assign, AST_Conditional ], function(output){
         var p = output.parent();
         // !(a = false) → true
         if (p instanceof AST_Unary)
@@ -902,7 +946,7 @@ function OutputStream(options) {
     function make_then(self, output) {
         var b = self.body;
         if (output.option("bracketize")
-            || !output.option("screw_ie8") && b instanceof AST_Do)
+            || output.option("ie8") && b instanceof AST_Do)
             return make_block(b, output);
         // The squeezer replaces "block"-s that contain only a single
         // statement with the statement itself; technically, the AST
@@ -1033,24 +1077,19 @@ function OutputStream(options) {
     DEFPRINT(AST_Var, function(self, output){
         self._do_print(output, "var");
     });
-    DEFPRINT(AST_Const, function(self, output){
-        self._do_print(output, "const");
-    });
 
     function parenthesize_for_noin(node, output, noin) {
-        if (!noin) node.print(output);
-        else try {
-            // need to take some precautions here:
-            //    https://github.com/mishoo/UglifyJS2/issues/60
-            node.walk(new TreeWalker(function(node){
-                if (node instanceof AST_Binary && node.operator == "in")
-                    throw output;
-            }));
-            node.print(output);
-        } catch(ex) {
-            if (ex !== output) throw ex;
-            node.print(output, true);
-        }
+        var parens = false;
+        // need to take some precautions here:
+        //    https://github.com/mishoo/UglifyJS2/issues/60
+        if (noin) node.walk(new TreeWalker(function(node) {
+            if (parens || node instanceof AST_Scope) return true;
+            if (node instanceof AST_Binary && node.operator == "in") {
+                parens = true;
+                return true;
+            }
+        }));
+        node.print(output, parens);
     };
 
     DEFPRINT(AST_VarDef, function(self, output){
@@ -1070,6 +1109,9 @@ function OutputStream(options) {
         self.expression.print(output);
         if (self instanceof AST_New && !need_constructor_parens(self, output))
             return;
+        if (self.expression instanceof AST_Lambda) {
+            output.add_mapping(self.start);
+        }
         output.with_parens(function(){
             self.args.forEach(function(expr, i){
                 if (i) output.comma();
@@ -1083,18 +1125,19 @@ function OutputStream(options) {
         AST_Call.prototype._codegen(self, output);
     });
 
-    AST_Seq.DEFMETHOD("_do_print", function(output){
-        this.car.print(output);
-        if (this.cdr) {
-            output.comma();
-            if (output.should_break()) {
-                output.newline();
-                output.indent();
+    AST_Sequence.DEFMETHOD("_do_print", function(output){
+        this.expressions.forEach(function(node, index) {
+            if (index > 0) {
+                output.comma();
+                if (output.should_break()) {
+                    output.newline();
+                    output.indent();
+                }
             }
-            this.cdr.print(output);
-        }
+            node.print(output);
+        });
     });
-    DEFPRINT(AST_Seq, function(self, output){
+    DEFPRINT(AST_Sequence, function(self, output){
         self._do_print(output);
         // var p = output.parent();
         // if (p instanceof AST_Statement) {
@@ -1108,15 +1151,23 @@ function OutputStream(options) {
     DEFPRINT(AST_Dot, function(self, output){
         var expr = self.expression;
         expr.print(output);
-        if (expr instanceof AST_Number && expr.getValue() >= 0) {
-            if (!/[xa-f.)]/i.test(output.last())) {
-                output.print(".");
+        var prop = self.property;
+        if (output.option("ie8") && RESERVED_WORDS(prop)) {
+            output.print("[");
+            output.add_mapping(self.end);
+            output.print_string(prop);
+            output.print("]");
+        } else {
+            if (expr instanceof AST_Number && expr.getValue() >= 0) {
+                if (!/[xa-f.)]/i.test(output.last())) {
+                    output.print(".");
+                }
             }
+            output.print(".");
+            // the name after dot would be mapped about here.
+            output.add_mapping(self.end);
+            output.print_name(prop);
         }
-        output.print(".");
-        // the name after dot would be mapped about here.
-        output.add_mapping(self.end);
-        output.print_name(self.property);
     });
     DEFPRINT(AST_Sub, function(self, output){
         self.expression.print(output);
@@ -1207,9 +1258,8 @@ function OutputStream(options) {
         });
         else output.print("{}");
     });
-    DEFPRINT(AST_ObjectKeyVal, function(self, output){
-        var key = self.key;
-        var quote = self.quote;
+
+    function print_property_name(key, quote, output) {
         if (output.option("quote_keys")) {
             output.print_string(key + "");
         } else if ((typeof key == "number"
@@ -1217,7 +1267,7 @@ function OutputStream(options) {
                     && +key + "" == key)
                    && parseFloat(key) >= 0) {
             output.print(make_num(key));
-        } else if (RESERVED_WORDS(key) ? output.option("screw_ie8") : is_identifier_string(key)) {
+        } else if (RESERVED_WORDS(key) ? !output.option("ie8") : is_identifier_string(key)) {
             if (quote && output.option("keep_quoted_props")) {
                 output.print_string(key, quote);
             } else {
@@ -1226,20 +1276,24 @@ function OutputStream(options) {
         } else {
             output.print_string(key, quote);
         }
+    }
+
+    DEFPRINT(AST_ObjectKeyVal, function(self, output){
+        print_property_name(self.key, self.quote, output);
         output.colon();
         self.value.print(output);
     });
-    DEFPRINT(AST_ObjectSetter, function(self, output){
-        output.print("set");
+    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
+        output.print(type);
         output.space();
-        self.key.print(output);
-        self.value._do_print(output, true);
+        print_property_name(this.key.name, this.quote, output);
+        this.value._do_print(output, true);
+    });
+    DEFPRINT(AST_ObjectSetter, function(self, output){
+        self._print_getter_setter("set", output);
     });
     DEFPRINT(AST_ObjectGetter, function(self, output){
-        output.print("get");
-        output.space();
-        self.key.print(output);
-        self.value._do_print(output, true);
+        self._print_getter_setter("get", output);
     });
     DEFPRINT(AST_Symbol, function(self, output){
         var def = self.definition();
@@ -1263,46 +1317,13 @@ function OutputStream(options) {
         }
     });
 
-    function regexp_safe_literal(code) {
-        return [
-            0x5c   , // \
-            0x2f   , // /
-            0x2e   , // .
-            0x2b   , // +
-            0x2a   , // *
-            0x3f   , // ?
-            0x28   , // (
-            0x29   , // )
-            0x5b   , // [
-            0x5d   , // ]
-            0x7b   , // {
-            0x7d   , // }
-            0x24   , // $
-            0x5e   , // ^
-            0x3a   , // :
-            0x7c   , // |
-            0x21   , // !
-            0x0a   , // \n
-            0x0d   , // \r
-            0x00   , // \0
-            0xfeff , // Unicode BOM
-            0x2028 , // unicode "line separator"
-            0x2029 , // unicode "paragraph separator"
-        ].indexOf(code) < 0;
-    };
-
     DEFPRINT(AST_RegExp, function(self, output){
-        var str = self.getValue().toString();
-        if (output.option("ascii_only")) {
-            str = output.to_ascii(str);
-        } else if (output.option("unescape_regexps")) {
-            str = str.split("\\\\").map(function(str){
-                return str.replace(/\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}/g, function(s){
-                    var code = parseInt(s.substr(2), 16);
-                    return regexp_safe_literal(code) ? String.fromCharCode(code) : s;
-                });
-            }).join("\\\\");
+        var regexp = self.getValue();
+        var str = regexp.toString();
+        if (regexp.raw_source) {
+            str = "/" + regexp.raw_source + str.slice(str.lastIndexOf("/"));
         }
+        str = output.to_utf8(str);
         output.print(str);
         var p = output.parent();
         if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === self)
diff --git a/node_modules/uglify-js/lib/parse.js b/node_modules/uglify-js/lib/parse.js
index 014822ad9..e2dd04b6c 100644
--- a/node_modules/uglify-js/lib/parse.js
+++ b/node_modules/uglify-js/lib/parse.js
@@ -115,8 +115,6 @@ var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,;:"));
 
 var PUNC_CHARS = makePredicate(characters("[]{}(),;:"));
 
-var REGEXP_MODIFIERS = makePredicate(characters("gmsiy"));
-
 /* -----[ Tokenizer ]----- */
 
 // regexps adapted from http://xregexp.com/plugins/#unicode
@@ -477,31 +475,33 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         return name;
     };
 
-    var read_regexp = with_eof_error("Unterminated regular expression", function(regexp){
+    var read_regexp = with_eof_error("Unterminated regular expression", function(source) {
         var prev_backslash = false, ch, in_class = false;
         while ((ch = next(true))) if (NEWLINE_CHARS(ch)) {
             parse_error("Unexpected line terminator");
         } else if (prev_backslash) {
-            regexp += "\\" + ch;
+            source += "\\" + ch;
             prev_backslash = false;
         } else if (ch == "[") {
             in_class = true;
-            regexp += ch;
+            source += ch;
         } else if (ch == "]" && in_class) {
             in_class = false;
-            regexp += ch;
+            source += ch;
         } else if (ch == "/" && !in_class) {
             break;
         } else if (ch == "\\") {
             prev_backslash = true;
         } else {
-            regexp += ch;
+            source += ch;
         }
         var mods = read_name();
         try {
-          return token("regexp", new RegExp(regexp, mods));
+            var regexp = new RegExp(source, mods);
+            regexp.raw_source = source;
+            return token("regexp", regexp);
         } catch(e) {
-          parse_error(e.message);
+            parse_error(e.message);
         }
     });
 
@@ -633,8 +633,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     }
 
     next_token.has_directive = function(directive) {
-        return S.directives[directive] !== undefined &&
-            S.directives[directive] > 0;
+        return S.directives[directive] > 0;
     }
 
     return next_token;
@@ -683,9 +682,7 @@ var PRECEDENCE = (function(a, ret){
     {}
 );
 
-var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
-
-var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
+var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "string", "regexp", "name" ]);
 
 /* -----[ Parser ]----- */
 
@@ -693,14 +690,13 @@ function parse($TEXT, options) {
 
     options = defaults(options, {
         bare_returns   : false,
-        cli            : false,
         expression     : false,
         filename       : null,
         html5_comments : true,
         shebang        : true,
         strict         : false,
         toplevel       : null,
-    });
+    }, true);
 
     var S = {
         input         : (typeof $TEXT == "string"
@@ -941,12 +937,6 @@ function parse($TEXT, options) {
                 semicolon();
                 return node;
 
-              case "const":
-                next();
-                var node = const_();
-                semicolon();
-                return node;
-
               case "with":
                 if (S.input.has_directive("use strict")) {
                     croak("Strict mode may not include a with statement");
@@ -1020,8 +1010,12 @@ function parse($TEXT, options) {
                 ? (next(), var_(true))
                 : expression(true, true);
             if (is("operator", "in")) {
-                if (init instanceof AST_Var && init.definitions.length > 1)
-                    croak("Only one variable declaration allowed in for..in loop");
+                if (init instanceof AST_Var) {
+                    if (init.definitions.length > 1)
+                        croak("Only one variable declaration allowed in for..in loop", init.start.line, init.start.col, init.start.pos);
+                } else if (!is_assignable(init)) {
+                    croak("Invalid left-hand side in for..in loop", init.start.line, init.start.col, init.start.pos);
+                }
                 next();
                 return for_in(init);
             }
@@ -1061,29 +1055,32 @@ function parse($TEXT, options) {
         if (in_statement && !name)
             unexpected();
         expect("(");
+        var argnames = [];
+        for (var first = true; !is("punc", ")");) {
+            if (first) first = false; else expect(",");
+            argnames.push(as_symbol(AST_SymbolFunarg));
+        }
+        next();
+        var loop = S.in_loop;
+        var labels = S.labels;
+        ++S.in_function;
+        S.in_directives = true;
+        S.input.push_directives_stack();
+        S.in_loop = 0;
+        S.labels = [];
+        var body = block_();
+        if (S.input.has_directive("use strict")) {
+            if (name) strict_verify_symbol(name);
+            argnames.forEach(strict_verify_symbol);
+        }
+        S.input.pop_directives_stack();
+        --S.in_function;
+        S.in_loop = loop;
+        S.labels = labels;
         return new ctor({
             name: name,
-            argnames: (function(first, a){
-                while (!is("punc", ")")) {
-                    if (first) first = false; else expect(",");
-                    a.push(as_symbol(AST_SymbolFunarg));
-                }
-                next();
-                return a;
-            })(true, []),
-            body: (function(loop, labels){
-                ++S.in_function;
-                S.in_directives = true;
-                S.input.push_directives_stack();
-                S.in_loop = 0;
-                S.labels = [];
-                var a = block_();
-                S.input.pop_directives_stack();
-                --S.in_function;
-                S.in_loop = loop;
-                S.labels = labels;
-                return a;
-            })(S.in_loop, S.labels)
+            argnames: argnames,
+            body: body
         });
     };
 
@@ -1179,12 +1176,12 @@ function parse($TEXT, options) {
         });
     };
 
-    function vardefs(no_in, in_const) {
+    function vardefs(no_in) {
         var a = [];
         for (;;) {
             a.push(new AST_VarDef({
                 start : S.token,
-                name  : as_symbol(in_const ? AST_SymbolConst : AST_SymbolVar),
+                name  : as_symbol(AST_SymbolVar),
                 value : is("operator", "=") ? (next(), expression(false, no_in)) : null,
                 end   : prev()
             }));
@@ -1198,15 +1195,7 @@ function parse($TEXT, options) {
     var var_ = function(no_in) {
         return new AST_Var({
             start       : prev(),
-            definitions : vardefs(no_in, false),
-            end         : prev()
-        });
-    };
-
-    var const_ = function() {
-        return new AST_Const({
-            start       : prev(),
-            definitions : vardefs(false, true),
+            definitions : vardefs(no_in),
             end         : prev()
         });
     };
@@ -1233,7 +1222,6 @@ function parse($TEXT, options) {
         var tok = S.token, ret;
         switch (tok.type) {
           case "name":
-          case "keyword":
             ret = _make_symbol(AST_SymbolRef);
             break;
           case "num":
@@ -1263,13 +1251,6 @@ function parse($TEXT, options) {
                 break;
             }
             break;
-          case "operator":
-            if (!is_identifier_string(tok.value)) {
-                croak("Invalid getter/setter name: " + tok.value,
-                    tok.line, tok.col, tok.pos);
-            }
-            ret = _make_symbol(AST_SymbolRef);
-            break;
         }
         next();
         return ret;
@@ -1303,7 +1284,7 @@ function parse($TEXT, options) {
             func.end = prev();
             return subscripts(func, allow_calls);
         }
-        if (ATOMIC_START_TOKEN[S.token.type]) {
+        if (ATOMIC_START_TOKEN(S.token.type)) {
             return subscripts(as_atom_node(), allow_calls);
         }
         unexpected();
@@ -1417,12 +1398,20 @@ function parse($TEXT, options) {
         });
     };
 
+    function strict_verify_symbol(sym) {
+        if (sym.name == "arguments" || sym.name == "eval")
+            croak("Unexpected " + sym.name + " in strict mode", sym.start.line, sym.start.col, sym.start.pos);
+    }
+
     function as_symbol(type, noerror) {
         if (!is("name")) {
             if (!noerror) croak("Name expected");
             return null;
         }
         var sym = _make_symbol(type);
+        if (S.input.has_directive("use strict") && sym instanceof AST_SymbolDeclaration) {
+            strict_verify_symbol(sym);
+        }
         next();
         return sym;
     };
@@ -1483,8 +1472,17 @@ function parse($TEXT, options) {
 
     function make_unary(ctor, token, expr) {
         var op = token.value;
-        if ((op == "++" || op == "--") && !is_assignable(expr))
-            croak("Invalid use of " + op + " operator", token.line, token.col, token.pos);
+        switch (op) {
+          case "++":
+          case "--":
+            if (!is_assignable(expr))
+                croak("Invalid use of " + op + " operator", token.line, token.col, token.pos);
+            break;
+          case "delete":
+            if (expr instanceof AST_SymbolRef && S.input.has_directive("use strict"))
+                croak("Calling delete on expression not allowed in strict mode", expr.start.line, expr.start.col, expr.start.pos);
+            break;
+        }
         return new ctor({ operator: op, expression: expr });
     };
 
@@ -1529,7 +1527,6 @@ function parse($TEXT, options) {
     };
 
     function is_assignable(expr) {
-        if (options.cli) return true;
         return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef;
     };
 
@@ -1554,17 +1551,18 @@ function parse($TEXT, options) {
 
     var expression = function(commas, no_in) {
         var start = S.token;
-        var expr = maybe_assign(no_in);
-        if (commas && is("punc", ",")) {
+        var exprs = [];
+        while (true) {
+            exprs.push(maybe_assign(no_in));
+            if (!commas || !is("punc", ",")) break;
             next();
-            return new AST_Seq({
-                start  : start,
-                car    : expr,
-                cdr    : expression(true, no_in),
-                end    : peek()
-            });
+            commas = true;
         }
-        return expr;
+        return exprs.length == 1 ? exprs[0] : new AST_Sequence({
+            start       : start,
+            expressions : exprs,
+            end         : peek()
+        });
     };
 
     function in_loop(cont) {
diff --git a/node_modules/uglify-js/lib/propmangle.js b/node_modules/uglify-js/lib/propmangle.js
index b62229903..36a67e80a 100644
--- a/node_modules/uglify-js/lib/propmangle.js
+++ b/node_modules/uglify-js/lib/propmangle.js
@@ -43,16 +43,16 @@
 
 "use strict";
 
-function find_builtins() {
+function find_builtins(reserved) {
     // NaN will be included due to Number.NaN
-    var a = [
+    [
         "null",
         "true",
         "false",
         "Infinity",
         "-Infinity",
         "undefined",
-    ];
+    ].forEach(add);
     [ Object, Array, Function, Number,
       String, Boolean, Error, Math,
       Date, RegExp
@@ -63,24 +63,52 @@ function find_builtins() {
         }
     });
     function add(name) {
-        push_uniq(a, name);
+        push_uniq(reserved, name);
     }
-    return a;
+}
+
+function reserve_quoted_keys(ast, reserved) {
+    function add(name) {
+        push_uniq(reserved, name);
+    }
+
+    ast.walk(new TreeWalker(function(node) {
+        if (node instanceof AST_ObjectKeyVal && node.quote) {
+            add(node.key);
+        } else if (node instanceof AST_Sub) {
+            addStrings(node.property, add);
+        }
+    }));
+}
+
+function addStrings(node, add) {
+    node.walk(new TreeWalker(function(node) {
+        if (node instanceof AST_Sequence) {
+            addStrings(node.expressions[node.expressions.length - 1], add);
+        } else if (node instanceof AST_String) {
+            add(node.value);
+        } else if (node instanceof AST_Conditional) {
+            addStrings(node.consequent, add);
+            addStrings(node.alternative, add);
+        }
+        return true;
+    }));
 }
 
 function mangle_properties(ast, options) {
     options = defaults(options, {
+        builtins: false,
         cache: null,
         debug: false,
-        ignore_quoted: false,
+        keep_quoted: false,
         only_cache: false,
         regex: null,
         reserved: null,
-    });
+    }, true);
 
     var reserved = options.reserved;
-    if (reserved == null)
-        reserved = find_builtins();
+    if (!Array.isArray(reserved)) reserved = [];
+    if (!options.builtins) find_builtins(reserved);
 
     var cache = options.cache;
     if (cache == null) {
@@ -91,12 +119,11 @@ function mangle_properties(ast, options) {
     }
 
     var regex = options.regex;
-    var ignore_quoted = options.ignore_quoted;
 
     // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
     // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
     // the same as passing an empty string.
-    var debug = (options.debug !== false);
+    var debug = options.debug !== false;
     var debug_name_suffix;
     if (debug) {
         debug_name_suffix = (options.debug === true ? "" : options.debug);
@@ -104,12 +131,11 @@ function mangle_properties(ast, options) {
 
     var names_to_mangle = [];
     var unmangleable = [];
-    var ignored = {};
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            add(node.key, ignore_quoted && node.quote);
+            add(node.key);
         }
         else if (node instanceof AST_ObjectProperty) {
             // setter or getter, since KeyVal is handled above
@@ -119,15 +145,14 @@ function mangle_properties(ast, options) {
             add(node.property);
         }
         else if (node instanceof AST_Sub) {
-            addStrings(node.property, ignore_quoted);
+            addStrings(node.property, add);
         }
     }));
 
     // step 2: transform the tree, renaming properties
     return ast.transform(new TreeTransformer(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            if (!(ignore_quoted && node.quote))
-                node.key = mangle(node.key);
+            node.key = mangle(node.key);
         }
         else if (node instanceof AST_ObjectProperty) {
             // setter or getter
@@ -136,22 +161,9 @@ function mangle_properties(ast, options) {
         else if (node instanceof AST_Dot) {
             node.property = mangle(node.property);
         }
-        else if (node instanceof AST_Sub) {
-            if (!ignore_quoted)
-                node.property = mangleStrings(node.property);
+        else if (!options.keep_quoted && node instanceof AST_Sub) {
+            node.property = mangleStrings(node.property);
         }
-        // else if (node instanceof AST_String) {
-        //     if (should_mangle(node.value)) {
-        //         AST_Node.warn(
-        //             "Found \"{prop}\" property candidate for mangling in an arbitrary string [{file}:{line},{col}]", {
-        //                 file : node.start.file,
-        //                 line : node.start.line,
-        //                 col  : node.start.col,
-        //                 prop : node.value
-        //             }
-        //         );
-        //     }
-        // }
     }));
 
     // only function declarations after this line
@@ -167,19 +179,13 @@ function mangle_properties(ast, options) {
     }
 
     function should_mangle(name) {
-        if (ignore_quoted && name in ignored) return false;
         if (regex && !regex.test(name)) return false;
         if (reserved.indexOf(name) >= 0) return false;
         return cache.props.has(name)
             || names_to_mangle.indexOf(name) >= 0;
     }
 
-    function add(name, ignore) {
-        if (ignore) {
-            ignored[name] = true;
-            return;
-        }
-
+    function add(name) {
         if (can_mangle(name))
             push_uniq(names_to_mangle, name);
 
@@ -199,19 +205,16 @@ function mangle_properties(ast, options) {
                 // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
                 var debug_mangled = "_$" + name + "$" + debug_name_suffix + "_";
 
-                if (can_mangle(debug_mangled) && !(ignore_quoted && debug_mangled in ignored)) {
+                if (can_mangle(debug_mangled)) {
                     mangled = debug_mangled;
                 }
             }
 
             // either debug mode is off, or it is on and we could not use the mangled name
             if (!mangled) {
-                // note can_mangle() does not check if the name collides with the 'ignored' set
-                // (filled with quoted properties when ignore_quoted set). Make sure we add this
-                // check so we don't collide with a quoted name.
                 do {
                     mangled = base54(++cache.cname);
-                } while (!can_mangle(mangled) || (ignore_quoted && mangled in ignored));
+                } while (!can_mangle(mangled));
             }
 
             cache.props.set(name, mangled);
@@ -219,36 +222,11 @@ function mangle_properties(ast, options) {
         return mangled;
     }
 
-    function addStrings(node, ignore) {
-        var out = {};
-        try {
-            (function walk(node){
-                node.walk(new TreeWalker(function(node){
-                    if (node instanceof AST_Seq) {
-                        walk(node.cdr);
-                        return true;
-                    }
-                    if (node instanceof AST_String) {
-                        add(node.value, ignore);
-                        return true;
-                    }
-                    if (node instanceof AST_Conditional) {
-                        walk(node.consequent);
-                        walk(node.alternative);
-                        return true;
-                    }
-                    throw out;
-                }));
-            })(node);
-        } catch(ex) {
-            if (ex !== out) throw ex;
-        }
-    }
-
     function mangleStrings(node) {
         return node.transform(new TreeTransformer(function(node){
-            if (node instanceof AST_Seq) {
-                node.cdr = mangleStrings(node.cdr);
+            if (node instanceof AST_Sequence) {
+                var last = node.expressions.length - 1;
+                node.expressions[last] = mangleStrings(node.expressions[last]);
             }
             else if (node instanceof AST_String) {
                 node.value = mangle(node.value);
@@ -260,5 +238,4 @@ function mangle_properties(ast, options) {
             return node;
         }));
     }
-
 }
diff --git a/node_modules/uglify-js/lib/scope.js b/node_modules/uglify-js/lib/scope.js
index bf6dbcbbf..df7b2076c 100644
--- a/node_modules/uglify-js/lib/scope.js
+++ b/node_modules/uglify-js/lib/scope.js
@@ -76,10 +76,10 @@ SymbolDef.prototype = {
         else if (!this.mangled_name && !this.unmangleable(options)) {
             var s = this.scope;
             var sym = this.orig[0];
-            if (!options.screw_ie8 && sym instanceof AST_SymbolLambda)
+            if (options.ie8 && sym instanceof AST_SymbolLambda)
                 s = s.parent_scope;
             var def;
-            if (this.defun && (def = this.defun.variables.get(this.name))) {
+            if (def = this.redefined()) {
                 this.mangled_name = def.mangled_name || def.name;
             } else
                 this.mangled_name = s.next_mangled(options, this);
@@ -87,13 +87,16 @@ SymbolDef.prototype = {
                 cache.set(this.name, this.mangled_name);
             }
         }
+    },
+    redefined: function() {
+        return this.defun && this.defun.variables.get(this.name);
     }
 };
 
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     options = defaults(options, {
         cache: null,
-        screw_ie8: true,
+        ie8: false,
     });
 
     // pass 1: setup scope chaining and handle definitions
@@ -156,8 +159,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             // later.
             (node.scope = defun.parent_scope).def_function(node);
         }
-        else if (node instanceof AST_SymbolVar
-            || node instanceof AST_SymbolConst) {
+        else if (node instanceof AST_SymbolVar) {
             defun.def_variable(node);
             if (defun !== scope) {
                 node.mark_enclosed(options);
@@ -184,16 +186,8 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     self.walk(tw);
 
     // pass 2: find back references and eval
-    var func = null;
-    var globals = self.globals = new Dictionary();
+    self.globals = new Dictionary();
     var tw = new TreeWalker(function(node, descend){
-        if (node instanceof AST_Lambda) {
-            var prev_func = func;
-            func = node;
-            descend();
-            func = prev_func;
-            return true;
-        }
         if (node instanceof AST_LoopControl && node.label) {
             node.label.thedef.references.push(node);
             return true;
@@ -206,21 +200,30 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                 }
             }
             var sym = node.scope.find_variable(name);
-            if (node.scope instanceof AST_Lambda && name == "arguments") {
-                node.scope.uses_arguments = true;
-            }
             if (!sym) {
                 sym = self.def_global(node);
+            } else if (sym.scope instanceof AST_Lambda && name == "arguments") {
+                sym.scope.uses_arguments = true;
             }
             node.thedef = sym;
             node.reference(options);
             return true;
         }
+        // ensure mangling works if catch reuses a scope variable
+        var def;
+        if (node instanceof AST_SymbolCatch && (def = node.definition().redefined())) {
+            var s = node.scope;
+            while (s) {
+                push_uniq(s.enclosed, def);
+                if (s === def.scope) break;
+                s = s.parent_scope;
+            }
+        }
     });
     self.walk(tw);
 
     // pass 3: fix up any scoping issue with IE8
-    if (!options.screw_ie8) {
+    if (options.ie8) {
         self.walk(new TreeWalker(function(node, descend) {
             if (node instanceof AST_SymbolCatch) {
                 var name = node.name;
@@ -268,7 +271,7 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
-    this.def_variable(new AST_SymbolVar({
+    this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
         start: this.start,
         end: this.end
@@ -325,8 +328,8 @@ AST_Scope.DEFMETHOD("next_mangled", function(options){
         if (!is_identifier(m)) continue; // skip over "do"
 
         // https://github.com/mishoo/UglifyJS2/issues/242 -- do not
-        // shadow a name excepted from mangling.
-        if (options.except.indexOf(m) >= 0) continue;
+        // shadow a name reserved from mangling.
+        if (options.reserved.indexOf(m) >= 0) continue;
 
         // we must ensure that the mangled name does not shadow a name
         // from some parent scope that is referenced in this or in
@@ -358,31 +361,18 @@ AST_Function.DEFMETHOD("next_mangled", function(options, def){
 });
 
 AST_Symbol.DEFMETHOD("unmangleable", function(options){
-    return this.definition().unmangleable(options);
+    var def = this.definition();
+    return !def || def.unmangleable(options);
 });
 
 // labels are always mangleable
-AST_Label.DEFMETHOD("unmangleable", function(){
-    return false;
-});
+AST_Label.DEFMETHOD("unmangleable", return_false);
 
 AST_Symbol.DEFMETHOD("unreferenced", function(){
     return this.definition().references.length == 0
         && !(this.scope.uses_eval || this.scope.uses_with);
 });
 
-AST_Symbol.DEFMETHOD("undeclared", function(){
-    return this.definition().undeclared;
-});
-
-AST_LabelRef.DEFMETHOD("undeclared", function(){
-    return false;
-});
-
-AST_Label.DEFMETHOD("undeclared", function(){
-    return false;
-});
-
 AST_Symbol.DEFMETHOD("definition", function(){
     return this.thedef;
 });
@@ -392,21 +382,22 @@ AST_Symbol.DEFMETHOD("global", function(){
 });
 
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
-    return defaults(options, {
+    options = defaults(options, {
         eval        : false,
-        except      : [],
+        ie8         : false,
         keep_fnames : false,
-        screw_ie8   : true,
-        sort        : false, // Ignored. Flag retained for backwards compatibility.
+        reserved    : [],
         toplevel    : false,
     });
+    if (!Array.isArray(options.reserved)) options.reserved = [];
+    return options;
 });
 
 AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     options = this._default_mangler_options(options);
 
     // Never mangle arguments
-    options.except.push('arguments');
+    options.reserved.push('arguments');
 
     // We only need to mangle declaration nodes.  Special logic wired
     // into the code generator will display the mangled name if it's
@@ -417,7 +408,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
 
     if (options.cache) {
         this.globals.each(function(symbol){
-            if (options.except.indexOf(symbol.name) < 0) {
+            if (options.reserved.indexOf(symbol.name) < 0) {
                 to_mangle.push(symbol);
             }
         });
@@ -434,7 +425,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
         if (node instanceof AST_Scope) {
             var p = tw.parent(), a = [];
             node.variables.each(function(symbol){
-                if (options.except.indexOf(symbol.name) < 0) {
+                if (options.reserved.indexOf(symbol.name) < 0) {
                     a.push(symbol);
                 }
             });
@@ -447,7 +438,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
             node.mangled_name = name;
             return true;
         }
-        if (options.screw_ie8 && node instanceof AST_SymbolCatch) {
+        if (!options.ie8 && node instanceof AST_SymbolCatch) {
             to_mangle.push(node.definition());
             return;
         }
@@ -462,105 +453,69 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
 
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
     options = this._default_mangler_options(options);
-    var tw = new TreeWalker(function(node){
-        if (node instanceof AST_Constant)
-            base54.consider(node.print_to_string());
-        else if (node instanceof AST_Return)
-            base54.consider("return");
-        else if (node instanceof AST_Throw)
-            base54.consider("throw");
-        else if (node instanceof AST_Continue)
-            base54.consider("continue");
-        else if (node instanceof AST_Break)
-            base54.consider("break");
-        else if (node instanceof AST_Debugger)
-            base54.consider("debugger");
-        else if (node instanceof AST_Directive)
-            base54.consider(node.value);
-        else if (node instanceof AST_While)
-            base54.consider("while");
-        else if (node instanceof AST_Do)
-            base54.consider("do while");
-        else if (node instanceof AST_If) {
-            base54.consider("if");
-            if (node.alternative) base54.consider("else");
-        }
-        else if (node instanceof AST_Var)
-            base54.consider("var");
-        else if (node instanceof AST_Const)
-            base54.consider("const");
-        else if (node instanceof AST_Lambda)
-            base54.consider("function");
-        else if (node instanceof AST_For)
-            base54.consider("for");
-        else if (node instanceof AST_ForIn)
-            base54.consider("for in");
-        else if (node instanceof AST_Switch)
-            base54.consider("switch");
-        else if (node instanceof AST_Case)
-            base54.consider("case");
-        else if (node instanceof AST_Default)
-            base54.consider("default");
-        else if (node instanceof AST_With)
-            base54.consider("with");
-        else if (node instanceof AST_ObjectSetter)
-            base54.consider("set" + node.key);
-        else if (node instanceof AST_ObjectGetter)
-            base54.consider("get" + node.key);
-        else if (node instanceof AST_ObjectKeyVal)
-            base54.consider(node.key);
-        else if (node instanceof AST_New)
-            base54.consider("new");
-        else if (node instanceof AST_This)
-            base54.consider("this");
-        else if (node instanceof AST_Try)
-            base54.consider("try");
-        else if (node instanceof AST_Catch)
-            base54.consider("catch");
-        else if (node instanceof AST_Finally)
-            base54.consider("finally");
-        else if (node instanceof AST_Symbol && node.unmangleable(options))
-            base54.consider(node.name);
-        else if (node instanceof AST_Unary || node instanceof AST_Binary)
-            base54.consider(node.operator);
-        else if (node instanceof AST_Dot)
-            base54.consider(node.property);
-    });
-    this.walk(tw);
+    try {
+        AST_Node.prototype.print = function(stream, force_parens) {
+            this._print(stream, force_parens);
+            if (this instanceof AST_Symbol && !this.unmangleable(options)) {
+                base54.consider(this.name, -1);
+            } else if (options.properties) {
+                if (this instanceof AST_Dot) {
+                    base54.consider(this.property, -1);
+                } else if (this instanceof AST_Sub) {
+                    skip_string(this.property);
+                }
+            }
+        };
+        base54.consider(this.print_to_string(), 1);
+    } finally {
+        AST_Node.prototype.print = AST_Node.prototype._print;
+    }
     base54.sort();
+
+    function skip_string(node) {
+        if (node instanceof AST_String) {
+            base54.consider(node.value, -1);
+        } else if (node instanceof AST_Conditional) {
+            skip_string(node.consequent);
+            skip_string(node.alternative);
+        } else if (node instanceof AST_Sequence) {
+            skip_string(node.expressions[node.expressions.length - 1]);
+        }
+    }
 });
 
 var base54 = (function() {
-    var string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";
+    var leading = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_".split("");
+    var digits = "0123456789".split("");
     var chars, frequency;
     function reset() {
         frequency = Object.create(null);
-        chars = string.split("").map(function(ch){ return ch.charCodeAt(0) });
-        chars.forEach(function(ch){ frequency[ch] = 0 });
+        leading.forEach(function(ch) {
+            frequency[ch] = 0;
+        });
+        digits.forEach(function(ch) {
+            frequency[ch] = 0;
+        });
     }
-    base54.consider = function(str){
+    base54.consider = function(str, delta) {
         for (var i = str.length; --i >= 0;) {
-            var code = str.charCodeAt(i);
-            if (code in frequency) ++frequency[code];
+            frequency[str[i]] += delta;
         }
     };
+    function compare(a, b) {
+        return frequency[b] - frequency[a];
+    }
     base54.sort = function() {
-        chars = mergeSort(chars, function(a, b){
-            if (is_digit(a) && !is_digit(b)) return 1;
-            if (is_digit(b) && !is_digit(a)) return -1;
-            return frequency[b] - frequency[a];
-        });
+        chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));
     };
     base54.reset = reset;
     reset();
-    base54.get = function(){ return chars };
-    base54.freq = function(){ return frequency };
     function base54(num) {
         var ret = "", base = 54;
         num++;
         do {
             num--;
-            ret += String.fromCharCode(chars[num % base]);
+            ret += chars[num % base];
             num = Math.floor(num / base);
             base = 64;
         } while (num > 0);
@@ -568,89 +523,3 @@ var base54 = (function() {
     };
     return base54;
 })();
-
-AST_Toplevel.DEFMETHOD("scope_warnings", function(options){
-    options = defaults(options, {
-        assign_to_global : true,
-        eval             : true,
-        func_arguments   : true,
-        nested_defuns    : true,
-        undeclared       : false, // this makes a lot of noise
-        unreferenced     : true,
-    });
-    var tw = new TreeWalker(function(node){
-        if (options.undeclared
-            && node instanceof AST_SymbolRef
-            && node.undeclared())
-        {
-            // XXX: this also warns about JS standard names,
-            // i.e. Object, Array, parseInt etc.  Should add a list of
-            // exceptions.
-            AST_Node.warn("Undeclared symbol: {name} [{file}:{line},{col}]", {
-                name: node.name,
-                file: node.start.file,
-                line: node.start.line,
-                col: node.start.col
-            });
-        }
-        if (options.assign_to_global)
-        {
-            var sym = null;
-            if (node instanceof AST_Assign && node.left instanceof AST_SymbolRef)
-                sym = node.left;
-            else if (node instanceof AST_ForIn && node.init instanceof AST_SymbolRef)
-                sym = node.init;
-            if (sym
-                && (sym.undeclared()
-                    || (sym.global() && sym.scope !== sym.definition().scope))) {
-                AST_Node.warn("{msg}: {name} [{file}:{line},{col}]", {
-                    msg: sym.undeclared() ? "Accidental global?" : "Assignment to global",
-                    name: sym.name,
-                    file: sym.start.file,
-                    line: sym.start.line,
-                    col: sym.start.col
-                });
-            }
-        }
-        if (options.eval
-            && node instanceof AST_SymbolRef
-            && node.undeclared()
-            && node.name == "eval") {
-            AST_Node.warn("Eval is used [{file}:{line},{col}]", node.start);
-        }
-        if (options.unreferenced
-            && (node instanceof AST_SymbolDeclaration || node instanceof AST_Label)
-            && !(node instanceof AST_SymbolCatch)
-            && node.unreferenced()) {
-            AST_Node.warn("{type} {name} is declared but not referenced [{file}:{line},{col}]", {
-                type: node instanceof AST_Label ? "Label" : "Symbol",
-                name: node.name,
-                file: node.start.file,
-                line: node.start.line,
-                col: node.start.col
-            });
-        }
-        if (options.func_arguments
-            && node instanceof AST_Lambda
-            && node.uses_arguments) {
-            AST_Node.warn("arguments used in function {name} [{file}:{line},{col}]", {
-                name: node.name ? node.name.name : "anonymous",
-                file: node.start.file,
-                line: node.start.line,
-                col: node.start.col
-            });
-        }
-        if (options.nested_defuns
-            && node instanceof AST_Defun
-            && !(tw.parent() instanceof AST_Scope)) {
-            AST_Node.warn("Function {name} declared in nested statement \"{type}\" [{file}:{line},{col}]", {
-                name: node.name.name,
-                type: tw.parent().TYPE,
-                file: node.start.file,
-                line: node.start.line,
-                col: node.start.col
-            });
-        }
-    });
-    this.walk(tw);
-});
diff --git a/node_modules/uglify-js/lib/transform.js b/node_modules/uglify-js/lib/transform.js
index 3018e8ff0..8008e5714 100644
--- a/node_modules/uglify-js/lib/transform.js
+++ b/node_modules/uglify-js/lib/transform.js
@@ -70,7 +70,7 @@ TreeTransformer.prototype = new TreeWalker;
                     if (y !== undefined) x = y;
                 }
             }
-            tw.pop(this);
+            tw.pop();
             return x;
         });
     };
@@ -174,9 +174,8 @@ TreeTransformer.prototype = new TreeWalker;
         self.args = do_list(self.args, tw);
     });
 
-    _(AST_Seq, function(self, tw){
-        self.car = self.car.transform(tw);
-        self.cdr = self.cdr.transform(tw);
+    _(AST_Sequence, function(self, tw){
+        self.expressions = do_list(self.expressions, tw);
     });
 
     _(AST_Dot, function(self, tw){
diff --git a/node_modules/uglify-js/lib/utils.js b/node_modules/uglify-js/lib/utils.js
index fdb204719..76306919a 100644
--- a/node_modules/uglify-js/lib/utils.js
+++ b/node_modules/uglify-js/lib/utils.js
@@ -43,13 +43,6 @@
 
 "use strict";
 
-function array_to_hash(a) {
-    var ret = Object.create(null);
-    for (var i = 0; i < a.length; ++i)
-        ret[a[i]] = true;
-    return ret;
-};
-
 function slice(a, start) {
     return Array.prototype.slice.call(a, start || 0);
 };
@@ -346,7 +339,7 @@ function first_in_statement(stack) {
     for (var i = 0, p; p = stack.parent(i); i++) {
         if (p instanceof AST_Statement && p.body === node)
             return true;
-        if ((p instanceof AST_Seq           && p.car === node        ) ||
+        if ((p instanceof AST_Sequence      && p.expressions[0] === node) ||
             (p instanceof AST_Call          && p.expression === node && !(p instanceof AST_New) ) ||
             (p instanceof AST_Dot           && p.expression === node ) ||
             (p instanceof AST_Sub           && p.expression === node ) ||
diff --git a/node_modules/uglify-js/node_modules/camelcase/index.js b/node_modules/uglify-js/node_modules/camelcase/index.js
deleted file mode 100644
index b46e10094..000000000
--- a/node_modules/uglify-js/node_modules/camelcase/index.js
+++ /dev/null
@@ -1,27 +0,0 @@
-'use strict';
-module.exports = function () {
-	var str = [].map.call(arguments, function (str) {
-		return str.trim();
-	}).filter(function (str) {
-		return str.length;
-	}).join('-');
-
-	if (!str.length) {
-		return '';
-	}
-
-	if (str.length === 1 || !(/[_.\- ]+/).test(str) ) {
-		if (str[0] === str[0].toLowerCase() && str.slice(1) !== str.slice(1).toLowerCase()) {
-			return str;
-		}
-
-		return str.toLowerCase();
-	}
-
-	return str
-	.replace(/^[_.\- ]+/, '')
-	.toLowerCase()
-	.replace(/[_.\- ]+(\w|$)/g, function (m, p1) {
-		return p1.toUpperCase();
-	});
-};
diff --git a/node_modules/uglify-js/node_modules/camelcase/license b/node_modules/uglify-js/node_modules/camelcase/license
deleted file mode 100644
index 654d0bfe9..000000000
--- a/node_modules/uglify-js/node_modules/camelcase/license
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/node_modules/uglify-js/node_modules/camelcase/package.json b/node_modules/uglify-js/node_modules/camelcase/package.json
deleted file mode 100644
index 34f75e745..000000000
--- a/node_modules/uglify-js/node_modules/camelcase/package.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-  "name": "camelcase",
-  "version": "1.2.1",
-  "description": "Convert a dash/dot/underscore/space separated string to camelCase: foo-bar → fooBar",
-  "license": "MIT",
-  "repository": "sindresorhus/camelcase",
-  "author": {
-    "name": "Sindre Sorhus",
-    "email": "sindresorhus@gmail.com",
-    "url": "http://sindresorhus.com"
-  },
-  "engines": {
-    "node": ">=0.10.0"
-  },
-  "scripts": {
-    "test": "node test.js"
-  },
-  "files": [
-    "index.js"
-  ],
-  "keywords": [
-    "camelcase",
-    "camel-case",
-    "camel",
-    "case",
-    "dash",
-    "hyphen",
-    "dot",
-    "underscore",
-    "separator",
-    "string",
-    "text",
-    "convert"
-  ],
-  "devDependencies": {
-    "ava": "0.0.4"
-  }
-}
diff --git a/node_modules/uglify-js/node_modules/camelcase/readme.md b/node_modules/uglify-js/node_modules/camelcase/readme.md
deleted file mode 100644
index 516dc3984..000000000
--- a/node_modules/uglify-js/node_modules/camelcase/readme.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# camelcase [![Build Status](https://travis-ci.org/sindresorhus/camelcase.svg?branch=master)](https://travis-ci.org/sindresorhus/camelcase)
-
-> Convert a dash/dot/underscore/space separated string to camelCase: `foo-bar` → `fooBar`
-
-
-## Install
-
-```sh
-$ npm install --save camelcase
-```
-
-
-## Usage
-
-```js
-var camelCase = require('camelcase');
-
-camelCase('foo-bar');
-//=> fooBar
-
-camelCase('foo_bar');
-//=> fooBar
-
-camelCase('Foo-Bar');
-//=> fooBar
-
-camelCase('--foo.bar');
-//=> fooBar
-
-camelCase('__foo__bar__');
-//=> fooBar
-
-camelCase('foo bar');
-//=> fooBar
-
-console.log(process.argv[3]);
-//=> --foo-bar
-camelCase(process.argv[3]);
-//=> fooBar
-
-camelCase('foo', 'bar');
-//=> fooBar
-
-camelCase('__foo__', '--bar');
-//=> fooBar
-```
-
-
-## Related
-
-See [`decamelize`](https://github.com/sindresorhus/decamelize) for the inverse.
-
-
-## License
-
-MIT © [Sindre Sorhus](http://sindresorhus.com)
diff --git a/node_modules/uglify-js/node_modules/cliui/.coveralls.yml b/node_modules/uglify-js/node_modules/cliui/.coveralls.yml
deleted file mode 100644
index 73367dbd7..000000000
--- a/node_modules/uglify-js/node_modules/cliui/.coveralls.yml
+++ /dev/null
@@ -1 +0,0 @@
-repo_token: NiRhyj91Z2vtgob6XdEAqs83rzNnbMZUu
diff --git a/node_modules/uglify-js/node_modules/cliui/.npmignore b/node_modules/uglify-js/node_modules/cliui/.npmignore
deleted file mode 100644
index 9daa8247d..000000000
--- a/node_modules/uglify-js/node_modules/cliui/.npmignore
+++ /dev/null
@@ -1,2 +0,0 @@
-.DS_Store
-node_modules
diff --git a/node_modules/uglify-js/node_modules/cliui/.travis.yml b/node_modules/uglify-js/node_modules/cliui/.travis.yml
deleted file mode 100644
index d96edf8ec..000000000
--- a/node_modules/uglify-js/node_modules/cliui/.travis.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-language: node_js
-node_js:
-  - "0.10"
-  - "0.11"
-  - "0.12"
-  - "iojs"
-after_script: "NODE_ENV=test YOURPACKAGE_COVERAGE=1 ./node_modules/.bin/mocha --require patched-blanket --reporter mocha-lcov-reporter | ./node_modules/coveralls/bin/coveralls.js"
diff --git a/node_modules/uglify-js/node_modules/cliui/LICENSE.txt b/node_modules/uglify-js/node_modules/cliui/LICENSE.txt
deleted file mode 100644
index c7e27478a..000000000
--- a/node_modules/uglify-js/node_modules/cliui/LICENSE.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-Copyright (c) 2015, Contributors
-
-Permission to use, copy, modify, and/or distribute this software
-for any purpose with or without fee is hereby granted, provided
-that the above copyright notice and this permission notice
-appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
-OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
-LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
-OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/uglify-js/node_modules/cliui/README.md b/node_modules/uglify-js/node_modules/cliui/README.md
deleted file mode 100644
index edcafa8ed..000000000
--- a/node_modules/uglify-js/node_modules/cliui/README.md
+++ /dev/null
@@ -1,104 +0,0 @@
-# cliui
-
-[![Build Status](https://travis-ci.org/bcoe/cliui.png)](https://travis-ci.org/bcoe/cliui)
-[![Coverage Status](https://coveralls.io/repos/bcoe/cliui/badge.svg?branch=)](https://coveralls.io/r/bcoe/cliui?branch=)
-[![NPM version](https://img.shields.io/npm/v/cliui.svg)](https://www.npmjs.com/package/cliui)
-
-easily create complex multi-column command-line-interfaces.
-
-## Example
-
-```js
-var ui = require('cliui')({
-  width: 80
-})
-
-ui.div('Usage: $0 [command] [options]')
-
-ui.div({
-  text: 'Options:',
-  padding: [2, 0, 2, 0]
-})
-
-ui.div(
-  {
-    text: "-f, --file",
-    width: 40,
-    padding: [0, 4, 0, 4]
-  },
-  {
-    text: "the file to load",
-    width: 25
-  },
-  {
-    text: "[required]",
-    align: 'right'
-  }
-)
-
-console.log(ui.toString())
-```
-
-## Layout DSL
-
-cliui exposes a simple layout DSL:
-
-If you create a single `ui.row`, passing a string rather than an
-object:
-
-* `\n`: characters will be interpreted as new rows.
-* `\t`: characters will be interpreted as new columns.
-* ` `: characters will be interpreted as padding.
-
-**as an example...**
-
-```js
-var ui = require('./')({
-  width: 60
-})
-
-ui.div(
-  'Usage: node ./bin/foo.js\n' +
-  '  <regex>\t  provide a regex\n' +
-  '  <glob>\t  provide a glob\t [required]'
-)
-
-console.log(ui.toString())
-```
-
-**will output:**
-
-```shell
-Usage: node ./bin/foo.js
-  <regex>  provide a regex
-  <glob>   provide a glob          [required]
-```
-
-## Methods
-
-```js
-cliui = require('cliui')
-```
-
-### cliui({width: integer})
-
-Specify the maximum width of the UI being generated.
-
-### cliui({wrap: boolean})
-
-Enable or disable the wrapping of text in a column.
-
-### cliui.div(column, column, column)
-
-Create a row with any number of columns, a column
-can either be a string, or an object with the following
-options:
-
-* **width:** the width of a column.
-* **align:** alignment, `right` or `center`.
-* **padding:** `[top, right, bottom, left]`.
-
-### cliui.span(column, column, column)
-
-Similar to `div`, except the next row will be appended without
-a new line being created.
diff --git a/node_modules/uglify-js/node_modules/cliui/index.js b/node_modules/uglify-js/node_modules/cliui/index.js
deleted file mode 100644
index 31b4aa7b7..000000000
--- a/node_modules/uglify-js/node_modules/cliui/index.js
+++ /dev/null
@@ -1,273 +0,0 @@
-var wrap = require('wordwrap'),
-  align = {
-    right: require('right-align'),
-    center: require('center-align')
-  },
-  top = 0,
-  right = 1,
-  bottom = 2,
-  left = 3
-
-function UI (opts) {
-  this.width = opts.width
-  this.wrap = opts.wrap
-  this.rows = []
-}
-
-UI.prototype.span = function () {
-  var cols = this.div.apply(this, arguments)
-  cols.span = true
-}
-
-UI.prototype.div = function () {
-  if (arguments.length === 0) this.div('')
-  if (this.wrap && this._shouldApplyLayoutDSL.apply(this, arguments)) {
-    return this._applyLayoutDSL(arguments[0])
-  }
-
-  var cols = []
-
-  for (var i = 0, arg; (arg = arguments[i]) !== undefined; i++) {
-    if (typeof arg === 'string') cols.push(this._colFromString(arg))
-    else cols.push(arg)
-  }
-
-  this.rows.push(cols)
-  return cols
-}
-
-UI.prototype._shouldApplyLayoutDSL = function () {
-  return arguments.length === 1 && typeof arguments[0] === 'string' &&
-    /[\t\n]/.test(arguments[0])
-}
-
-UI.prototype._applyLayoutDSL = function (str) {
-  var _this = this,
-    rows = str.split('\n'),
-    leftColumnWidth = 0
-
-  // simple heuristic for layout, make sure the
-  // second column lines up along the left-hand.
-  // don't allow the first column to take up more
-  // than 50% of the screen.
-  rows.forEach(function (row) {
-    var columns = row.split('\t')
-    if (columns.length > 1 && columns[0].length > leftColumnWidth) {
-      leftColumnWidth = Math.min(
-        Math.floor(_this.width * 0.5),
-        columns[0].length
-      )
-    }
-  })
-
-  // generate a table:
-  //  replacing ' ' with padding calculations.
-  //  using the algorithmically generated width.
-  rows.forEach(function (row) {
-    var columns = row.split('\t')
-    _this.div.apply(_this, columns.map(function (r, i) {
-      return {
-        text: r.trim(),
-        padding: [0, r.match(/\s*$/)[0].length, 0, r.match(/^\s*/)[0].length],
-        width: (i === 0 && columns.length > 1) ? leftColumnWidth : undefined
-      }
-    }))
-  })
-
-  return this.rows[this.rows.length - 1]
-}
-
-UI.prototype._colFromString = function (str) {
-  return {
-    text: str
-  }
-}
-
-UI.prototype.toString = function () {
-  var _this = this,
-    lines = []
-
-  _this.rows.forEach(function (row, i) {
-    _this.rowToString(row, lines)
-  })
-
-  // don't display any lines with the
-  // hidden flag set.
-  lines = lines.filter(function (line) {
-    return !line.hidden
-  })
-
-  return lines.map(function (line) {
-    return line.text
-  }).join('\n')
-}
-
-UI.prototype.rowToString = function (row, lines) {
-  var _this = this,
-    paddingLeft,
-    rrows = this._rasterize(row),
-    str = '',
-    ts,
-    width,
-    wrapWidth
-
-  rrows.forEach(function (rrow, r) {
-    str = ''
-    rrow.forEach(function (col, c) {
-      ts = '' // temporary string used during alignment/padding.
-      width = row[c].width // the width with padding.
-      wrapWidth = _this._negatePadding(row[c]) // the width without padding.
-
-      for (var i = 0; i < Math.max(wrapWidth, col.length); i++) {
-        ts += col.charAt(i) || ' '
-      }
-
-      // align the string within its column.
-      if (row[c].align && row[c].align !== 'left' && _this.wrap) {
-        ts = align[row[c].align](ts.trim() + '\n' + new Array(wrapWidth + 1).join(' '))
-          .split('\n')[0]
-        if (ts.length < wrapWidth) ts += new Array(width - ts.length).join(' ')
-      }
-
-      // add left/right padding and print string.
-      paddingLeft = (row[c].padding || [0, 0, 0, 0])[left]
-      if (paddingLeft) str += new Array(row[c].padding[left] + 1).join(' ')
-      str += ts
-      if (row[c].padding && row[c].padding[right]) str += new Array(row[c].padding[right] + 1).join(' ')
-
-      // if prior row is span, try to render the
-      // current row on the prior line.
-      if (r === 0 && lines.length > 0) {
-        str = _this._renderInline(str, lines[lines.length - 1], paddingLeft)
-      }
-    })
-
-    // remove trailing whitespace.
-    lines.push({
-      text: str.replace(/ +$/, ''),
-      span: row.span
-    })
-  })
-
-  return lines
-}
-
-// if the full 'source' can render in
-// the target line, do so.
-UI.prototype._renderInline = function (source, previousLine, paddingLeft) {
-  var target = previousLine.text,
-    str = ''
-
-  if (!previousLine.span) return source
-
-  // if we're not applying wrapping logic,
-  // just always append to the span.
-  if (!this.wrap) {
-    previousLine.hidden = true
-    return target + source
-  }
-
-  for (var i = 0, tc, sc; i < Math.max(source.length, target.length); i++) {
-    tc = target.charAt(i) || ' '
-    sc = source.charAt(i) || ' '
-    // we tried to overwrite a character in the other string.
-    if (tc !== ' ' && sc !== ' ') return source
-    // there is not enough whitespace to maintain padding.
-    if (sc !== ' ' && i < paddingLeft + target.length) return source
-    // :thumbsup:
-    if (tc === ' ') str += sc
-    else str += tc
-  }
-
-  previousLine.hidden = true
-
-  return str
-}
-
-UI.prototype._rasterize = function (row) {
-  var _this = this,
-    i,
-    rrow,
-    rrows = [],
-    widths = this._columnWidths(row),
-    wrapped
-
-  // word wrap all columns, and create
-  // a data-structure that is easy to rasterize.
-  row.forEach(function (col, c) {
-    // leave room for left and right padding.
-    col.width = widths[c]
-    if (_this.wrap) wrapped = wrap.hard(_this._negatePadding(col))(col.text).split('\n')
-    else wrapped = col.text.split('\n')
-
-    // add top and bottom padding.
-    if (col.padding) {
-      for (i = 0; i < (col.padding[top] || 0); i++) wrapped.unshift('')
-      for (i = 0; i < (col.padding[bottom] || 0); i++) wrapped.push('')
-    }
-
-    wrapped.forEach(function (str, r) {
-      if (!rrows[r]) rrows.push([])
-
-      rrow = rrows[r]
-
-      for (var i = 0; i < c; i++) {
-        if (rrow[i] === undefined) rrow.push('')
-      }
-      rrow.push(str)
-    })
-  })
-
-  return rrows
-}
-
-UI.prototype._negatePadding = function (col) {
-  var wrapWidth = col.width
-  if (col.padding) wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0)
-  return wrapWidth
-}
-
-UI.prototype._columnWidths = function (row) {
-  var _this = this,
-    widths = [],
-    unset = row.length,
-    unsetWidth,
-    remainingWidth = this.width
-
-  // column widths can be set in config.
-  row.forEach(function (col, i) {
-    if (col.width) {
-      unset--
-      widths[i] = col.width
-      remainingWidth -= col.width
-    } else {
-      widths[i] = undefined
-    }
-  })
-
-  // any unset widths should be calculated.
-  if (unset) unsetWidth = Math.floor(remainingWidth / unset)
-  widths.forEach(function (w, i) {
-    if (!_this.wrap) widths[i] = row[i].width || row[i].text.length
-    else if (w === undefined) widths[i] = Math.max(unsetWidth, _minWidth(row[i]))
-  })
-
-  return widths
-}
-
-// calculates the minimum width of
-// a column, based on padding preferences.
-function _minWidth (col) {
-  var padding = col.padding || []
-
-  return 1 + (padding[left] || 0) + (padding[right] || 0)
-}
-
-module.exports = function (opts) {
-  opts = opts || {}
-
-  return new UI({
-    width: (opts || {}).width || 80,
-    wrap: typeof opts.wrap === 'boolean' ? opts.wrap : true
-  })
-}
diff --git a/node_modules/uglify-js/node_modules/cliui/package.json b/node_modules/uglify-js/node_modules/cliui/package.json
deleted file mode 100644
index 868ae2eaa..000000000
--- a/node_modules/uglify-js/node_modules/cliui/package.json
+++ /dev/null
@@ -1,59 +0,0 @@
-{
-  "name": "cliui",
-  "version": "2.1.0",
-  "description": "easily create complex multi-column command-line-interfaces",
-  "main": "index.js",
-  "scripts": {
-    "test": "standard && mocha --check-leaks --ui exports --require patched-blanket -R mocoverage"
-  },
-  "repository": {
-    "type": "git",
-    "url": "http://github.com/bcoe/cliui.git"
-  },
-  "config": {
-    "blanket": {
-      "pattern": [
-        "index.js"
-      ],
-      "data-cover-never": [
-        "node_modules",
-        "test"
-      ],
-      "output-reporter": "spec"
-    }
-  },
-  "standard": {
-    "ignore": [
-      "**/example/**"
-    ],
-    "globals": [
-      "it"
-    ]
-  },
-  "keywords": [
-    "cli",
-    "command-line",
-    "layout",
-    "design",
-    "console",
-    "wrap",
-    "table"
-  ],
-  "author": "Ben Coe <ben@npmjs.com>",
-  "license": "ISC",
-  "dependencies": {
-    "center-align": "^0.1.1",
-    "right-align": "^0.1.1",
-    "wordwrap": "0.0.2"
-  },
-  "devDependencies": {
-    "blanket": "^1.1.6",
-    "chai": "^2.2.0",
-    "coveralls": "^2.11.2",
-    "mocha": "^2.2.4",
-    "mocha-lcov-reporter": "0.0.2",
-    "mocoverage": "^1.0.0",
-    "patched-blanket": "^1.0.1",
-    "standard": "^3.6.1"
-  }
-}
diff --git a/node_modules/uglify-js/node_modules/cliui/test/cliui.js b/node_modules/uglify-js/node_modules/cliui/test/cliui.js
deleted file mode 100644
index 1cc6127cb..000000000
--- a/node_modules/uglify-js/node_modules/cliui/test/cliui.js
+++ /dev/null
@@ -1,349 +0,0 @@
-/* global describe, it */
-
-require('chai').should()
-
-var cliui = require('../')
-
-describe('cliui', function () {
-  describe('div', function () {
-    it("wraps text at 'width' if a single column is given", function () {
-      var ui = cliui({
-        width: 10
-      })
-
-      ui.div('i am a string that should be wrapped')
-
-      ui.toString().split('\n').forEach(function (row) {
-        row.length.should.be.lte(10)
-      })
-    })
-
-    it('evenly divides text across columns if multiple columns are given', function () {
-      var ui = cliui({
-        width: 40
-      })
-
-      ui.div(
-        {text: 'i am a string that should be wrapped', width: 15},
-        'i am a second string that should be wrapped',
-        'i am a third string that should be wrapped'
-      )
-
-      // total width of all columns is <=
-      // the width cliui is initialized with.
-      ui.toString().split('\n').forEach(function (row) {
-        row.length.should.be.lte(40)
-      })
-
-      // it should wrap each column appropriately.
-      var expected = [
-       'i am a string  i am a      i am a third',
-       'that should be second      string that',
-       'wrapped        string that should be',
-       '               should be   wrapped',
-       '               wrapped'
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-
-    it('allows for a blank row to be appended', function () {
-      var ui = cliui({
-        width: 40
-      })
-
-      ui.div()
-
-      // it should wrap each column appropriately.
-      var expected = ['']
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-  })
-
-  describe('_columnWidths', function () {
-    it('uses same width for each column by default', function () {
-      var ui = cliui({
-          width: 40
-        }),
-        widths = ui._columnWidths([{}, {}, {}])
-
-      widths[0].should.equal(13)
-      widths[1].should.equal(13)
-      widths[2].should.equal(13)
-    })
-
-    it('divides width over remaining columns if first column has width specified', function () {
-      var ui = cliui({
-          width: 40
-        }),
-        widths = ui._columnWidths([{width: 20}, {}, {}])
-
-      widths[0].should.equal(20)
-      widths[1].should.equal(10)
-      widths[2].should.equal(10)
-    })
-
-    it('divides width over remaining columns if middle column has width specified', function () {
-      var ui = cliui({
-          width: 40
-        }),
-        widths = ui._columnWidths([{}, {width: 10}, {}])
-
-      widths[0].should.equal(15)
-      widths[1].should.equal(10)
-      widths[2].should.equal(15)
-    })
-
-    it('keeps track of remaining width if multiple columns have width specified', function () {
-      var ui = cliui({
-          width: 40
-        }),
-        widths = ui._columnWidths([{width: 20}, {width: 12}, {}])
-
-      widths[0].should.equal(20)
-      widths[1].should.equal(12)
-      widths[2].should.equal(8)
-    })
-
-    it('uses a sane default if impossible widths are specified', function () {
-      var ui = cliui({
-          width: 40
-        }),
-        widths = ui._columnWidths([{width: 30}, {width: 30}, {padding: [0, 2, 0, 1]}])
-
-      widths[0].should.equal(30)
-      widths[1].should.equal(30)
-      widths[2].should.equal(4)
-    })
-  })
-
-  describe('alignment', function () {
-    it('allows a column to be right aligned', function () {
-      var ui = cliui({
-        width: 40
-      })
-
-      ui.div(
-        'i am a string',
-        {text: 'i am a second string', align: 'right'},
-        'i am a third string that should be wrapped'
-      )
-
-      // it should right-align the second column.
-      var expected = [
-       'i am a stringi am a secondi am a third',
-       '                    stringstring that',
-       '                          should be',
-       '                          wrapped'
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-
-    it('allows a column to be center aligned', function () {
-      var ui = cliui({
-        width: 60
-      })
-
-      ui.div(
-        'i am a string',
-        {text: 'i am a second string', align: 'center', padding: [0, 2, 0, 2]},
-        'i am a third string that should be wrapped'
-      )
-
-      // it should right-align the second column.
-      var expected = [
-       'i am a string          i am a second       i am a third string',
-       '                           string          that should be',
-       '                                           wrapped'
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-  })
-
-  describe('padding', function () {
-    it('handles left/right padding', function () {
-      var ui = cliui({
-        width: 40
-      })
-
-      ui.div(
-        {text: 'i have padding on my left', padding: [0, 0, 0, 4]},
-        {text: 'i have padding on my right', padding: [0, 2, 0, 0], align: 'center'},
-        {text: 'i have no padding', padding: [0, 0, 0, 0]}
-      )
-
-      // it should add left/right padding to columns.
-      var expected = [
-       '    i have     i have      i have no',
-       '    padding  padding on    padding',
-       '    on my     my right',
-       '    left'
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-
-    it('handles top/bottom padding', function () {
-      var ui = cliui({
-        width: 40
-      })
-
-      ui.div(
-        'i am a string',
-        {text: 'i am a second string', padding: [2, 0, 0, 0]},
-        {text: 'i am a third string that should be wrapped', padding: [0, 0, 1, 0]}
-      )
-
-      // it should add top/bottom padding to second
-      // and third columns.
-      var expected = [
-       'i am a string             i am a third',
-       '                          string that',
-       '             i am a secondshould be',
-       '             string       wrapped',
-       ''
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-  })
-
-  describe('wrap', function () {
-    it('allows wordwrap to be disabled', function () {
-      var ui = cliui({
-        wrap: false
-      })
-
-      ui.div(
-        {text: 'i am a string', padding: [0, 1, 0, 0]},
-        {text: 'i am a second string', padding: [0, 2, 0, 0]},
-        {text: 'i am a third string that should not be wrapped', padding: [0, 0, 0, 2]}
-      )
-
-      ui.toString().should.equal('i am a string i am a second string    i am a third string that should not be wrapped')
-    })
-  })
-
-  describe('span', function () {
-    it('appends the next row to the end of the prior row if it fits', function () {
-      var ui = cliui({
-        width: 40
-      })
-
-      ui.span(
-        {text: 'i am a string that will be wrapped', width: 30}
-      )
-
-      ui.div(
-        {text: ' [required] [default: 99]', align: 'right'}
-      )
-
-      var expected = [
-       'i am a string that will be',
-       'wrapped         [required] [default: 99]'
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-
-    it('does not append the string if it does not fit on the prior row', function () {
-      var ui = cliui({
-        width: 40
-      })
-
-      ui.span(
-        {text: 'i am a string that will be wrapped', width: 30}
-      )
-
-      ui.div(
-        {text: 'i am a second row', align: 'left'}
-      )
-
-      var expected = [
-       'i am a string that will be',
-       'wrapped',
-       'i am a second row'
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-
-    it('always appends text to prior span if wrap is disabled', function () {
-      var ui = cliui({
-        wrap: false,
-        width: 40
-      })
-
-      ui.span(
-        {text: 'i am a string that will be wrapped', width: 30}
-      )
-
-      ui.div(
-        {text: 'i am a second row', align: 'left', padding: [0, 0, 0, 3]}
-      )
-
-      ui.div('a third line')
-
-      var expected = [
-       'i am a string that will be wrapped   i am a second row',
-       'a third line'
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-  })
-
-  describe('layoutDSL', function () {
-    it('turns tab into multiple columns', function () {
-      var ui = cliui({
-        width: 60
-      })
-
-      ui.div(
-        '  <regex>  \tmy awesome regex\n  <my second thing>  \tanother row\t  a third column'
-      )
-
-      var expected = [
-       '  <regex>            my awesome regex',
-       '  <my second thing>  another row          a third column'
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-
-    it('turns newline into multiple rows', function () {
-      var ui = cliui({
-        width: 40
-      })
-
-      ui.div(
-        'Usage: $0\n  <regex>\t  my awesome regex\n  <glob>\t  my awesome glob\t  [required]'
-      )
-      var expected = [
-       'Usage: $0',
-       '  <regex>  my awesome regex',
-       '  <glob>   my awesome     [required]',
-       '           glob'
-      ]
-
-      ui.toString().split('\n').should.eql(expected)
-    })
-
-    it('does not apply DSL if wrap is false', function () {
-      var ui = cliui({
-        width: 40,
-        wrap: false
-      })
-
-      ui.div(
-        'Usage: $0\ttwo\tthree'
-      )
-
-      ui.toString().should.eql('Usage: $0\ttwo\tthree')
-    })
-
-  })
-})
diff --git a/node_modules/uglify-js/node_modules/wordwrap/.npmignore b/node_modules/uglify-js/node_modules/wordwrap/.npmignore
deleted file mode 100644
index 3c3629e64..000000000
--- a/node_modules/uglify-js/node_modules/wordwrap/.npmignore
+++ /dev/null
@@ -1 +0,0 @@
-node_modules
diff --git a/node_modules/uglify-js/node_modules/wordwrap/README.markdown b/node_modules/uglify-js/node_modules/wordwrap/README.markdown
deleted file mode 100644
index 346374e0d..000000000
--- a/node_modules/uglify-js/node_modules/wordwrap/README.markdown
+++ /dev/null
@@ -1,70 +0,0 @@
-wordwrap
-========
-
-Wrap your words.
-
-example
-=======
-
-made out of meat
-----------------
-
-meat.js
-
-    var wrap = require('wordwrap')(15);
-    console.log(wrap('You and your whole family are made out of meat.'));
-
-output:
-
-    You and your
-    whole family
-    are made out
-    of meat.
-
-centered
---------
-
-center.js
-
-    var wrap = require('wordwrap')(20, 60);
-    console.log(wrap(
-        'At long last the struggle and tumult was over.'
-        + ' The machines had finally cast off their oppressors'
-        + ' and were finally free to roam the cosmos.'
-        + '\n'
-        + 'Free of purpose, free of obligation.'
-        + ' Just drifting through emptiness.'
-        + ' The sun was just another point of light.'
-    ));
-
-output:
-
-                        At long last the struggle and tumult
-                        was over. The machines had finally cast
-                        off their oppressors and were finally
-                        free to roam the cosmos.
-                        Free of purpose, free of obligation.
-                        Just drifting through emptiness. The
-                        sun was just another point of light.
-
-methods
-=======
-
-var wrap = require('wordwrap');
-
-wrap(stop), wrap(start, stop, params={mode:"soft"})
----------------------------------------------------
-
-Returns a function that takes a string and returns a new string.
-
-Pad out lines with spaces out to column `start` and then wrap until column
-`stop`. If a word is longer than `stop - start` characters it will overflow.
-
-In "soft" mode, split chunks by `/(\S+\s+/` and don't break up chunks which are
-longer than `stop - start`, in "hard" mode, split chunks with `/\b/` and break
-up chunks longer than `stop - start`.
-
-wrap.hard(start, stop)
-----------------------
-
-Like `wrap()` but with `params.mode = "hard"`.
diff --git a/node_modules/uglify-js/node_modules/wordwrap/example/center.js b/node_modules/uglify-js/node_modules/wordwrap/example/center.js
deleted file mode 100644
index a3fbaae98..000000000
--- a/node_modules/uglify-js/node_modules/wordwrap/example/center.js
+++ /dev/null
@@ -1,10 +0,0 @@
-var wrap = require('wordwrap')(20, 60);
-console.log(wrap(
-    'At long last the struggle and tumult was over.'
-    + ' The machines had finally cast off their oppressors'
-    + ' and were finally free to roam the cosmos.'
-    + '\n'
-    + 'Free of purpose, free of obligation.'
-    + ' Just drifting through emptiness.'
-    + ' The sun was just another point of light.'
-));
diff --git a/node_modules/uglify-js/node_modules/wordwrap/example/meat.js b/node_modules/uglify-js/node_modules/wordwrap/example/meat.js
deleted file mode 100644
index a4665e105..000000000
--- a/node_modules/uglify-js/node_modules/wordwrap/example/meat.js
+++ /dev/null
@@ -1,3 +0,0 @@
-var wrap = require('wordwrap')(15);
-
-console.log(wrap('You and your whole family are made out of meat.'));
diff --git a/node_modules/uglify-js/node_modules/wordwrap/index.js b/node_modules/uglify-js/node_modules/wordwrap/index.js
deleted file mode 100644
index c9bc94521..000000000
--- a/node_modules/uglify-js/node_modules/wordwrap/index.js
+++ /dev/null
@@ -1,76 +0,0 @@
-var wordwrap = module.exports = function (start, stop, params) {
-    if (typeof start === 'object') {
-        params = start;
-        start = params.start;
-        stop = params.stop;
-    }
-    
-    if (typeof stop === 'object') {
-        params = stop;
-        start = start || params.start;
-        stop = undefined;
-    }
-    
-    if (!stop) {
-        stop = start;
-        start = 0;
-    }
-    
-    if (!params) params = {};
-    var mode = params.mode || 'soft';
-    var re = mode === 'hard' ? /\b/ : /(\S+\s+)/;
-    
-    return function (text) {
-        var chunks = text.toString()
-            .split(re)
-            .reduce(function (acc, x) {
-                if (mode === 'hard') {
-                    for (var i = 0; i < x.length; i += stop - start) {
-                        acc.push(x.slice(i, i + stop - start));
-                    }
-                }
-                else acc.push(x)
-                return acc;
-            }, [])
-        ;
-        
-        return chunks.reduce(function (lines, rawChunk) {
-            if (rawChunk === '') return lines;
-            
-            var chunk = rawChunk.replace(/\t/g, '    ');
-            
-            var i = lines.length - 1;
-            if (lines[i].length + chunk.length > stop) {
-                lines[i] = lines[i].replace(/\s+$/, '');
-                
-                chunk.split(/\n/).forEach(function (c) {
-                    lines.push(
-                        new Array(start + 1).join(' ')
-                        + c.replace(/^\s+/, '')
-                    );
-                });
-            }
-            else if (chunk.match(/\n/)) {
-                var xs = chunk.split(/\n/);
-                lines[i] += xs.shift();
-                xs.forEach(function (c) {
-                    lines.push(
-                        new Array(start + 1).join(' ')
-                        + c.replace(/^\s+/, '')
-                    );
-                });
-            }
-            else {
-                lines[i] += chunk;
-            }
-            
-            return lines;
-        }, [ new Array(start + 1).join(' ') ]).join('\n');
-    };
-};
-
-wordwrap.soft = wordwrap;
-
-wordwrap.hard = function (start, stop) {
-    return wordwrap(start, stop, { mode : 'hard' });
-};
diff --git a/node_modules/uglify-js/node_modules/wordwrap/package.json b/node_modules/uglify-js/node_modules/wordwrap/package.json
deleted file mode 100644
index fdff683e1..000000000
--- a/node_modules/uglify-js/node_modules/wordwrap/package.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
-    "name" : "wordwrap",
-    "description" : "Wrap those words. Show them at what columns to start and stop.",
-    "version" : "0.0.2",
-    "repository" : {
-        "type" : "git",
-        "url" : "git://github.com/substack/node-wordwrap.git"
-    },
-    "main" : "./index.js",
-    "keywords" : [
-        "word",
-        "wrap",
-        "rule",
-        "format",
-        "column"
-    ],
-    "directories" : {
-        "lib" : ".",
-        "example" : "example",
-        "test" : "test"
-    },
-    "scripts" : {
-        "test" : "expresso"
-    },
-    "devDependencies" : {
-        "expresso" : "=0.7.x"
-    },
-    "engines" : {
-        "node" : ">=0.4.0"
-    },
-    "license" : "MIT/X11",
-    "author" : {
-        "name" : "James Halliday",
-        "email" : "mail@substack.net",
-        "url" : "http://substack.net"
-    }
-}
diff --git a/node_modules/uglify-js/node_modules/wordwrap/test/break.js b/node_modules/uglify-js/node_modules/wordwrap/test/break.js
deleted file mode 100644
index 749292ecc..000000000
--- a/node_modules/uglify-js/node_modules/wordwrap/test/break.js
+++ /dev/null
@@ -1,30 +0,0 @@
-var assert = require('assert');
-var wordwrap = require('../');
-
-exports.hard = function () {
-    var s = 'Assert from {"type":"equal","ok":false,"found":1,"wanted":2,'
-        + '"stack":[],"id":"b7ddcd4c409de8799542a74d1a04689b",'
-        + '"browser":"chrome/6.0"}'
-    ;
-    var s_ = wordwrap.hard(80)(s);
-    
-    var lines = s_.split('\n');
-    assert.equal(lines.length, 2);
-    assert.ok(lines[0].length < 80);
-    assert.ok(lines[1].length < 80);
-    
-    assert.equal(s, s_.replace(/\n/g, ''));
-};
-
-exports.break = function () {
-    var s = new Array(55+1).join('a');
-    var s_ = wordwrap.hard(20)(s);
-    
-    var lines = s_.split('\n');
-    assert.equal(lines.length, 3);
-    assert.ok(lines[0].length === 20);
-    assert.ok(lines[1].length === 20);
-    assert.ok(lines[2].length === 15);
-    
-    assert.equal(s, s_.replace(/\n/g, ''));
-};
diff --git a/node_modules/uglify-js/node_modules/wordwrap/test/idleness.txt b/node_modules/uglify-js/node_modules/wordwrap/test/idleness.txt
deleted file mode 100644
index aa3f4907f..000000000
--- a/node_modules/uglify-js/node_modules/wordwrap/test/idleness.txt
+++ /dev/null
@@ -1,63 +0,0 @@
-In Praise of Idleness
-
-By Bertrand Russell
-
-[1932]
-
-Like most of my generation, I was brought up on the saying: 'Satan finds some mischief for idle hands to do.' Being a highly virtuous child, I believed all that I was told, and acquired a conscience which has kept me working hard down to the present moment. But although my conscience has controlled my actions, my opinions have undergone a revolution. I think that there is far too much work done in the world, that immense harm is caused by the belief that work is virtuous, and that what needs to be preached in modern industrial countries is quite different from what always has been preached. Everyone knows the story of the traveler in Naples who saw twelve beggars lying in the sun (it was before the days of Mussolini), and offered a lira to the laziest of them. Eleven of them jumped up to claim it, so he gave it to the twelfth. this traveler was on the right lines. But in countries which do not enjoy Mediterranean sunshine idleness is more difficult, and a great public propaganda will be required to inaugurate it. I hope that, after reading the following pages, the leaders of the YMCA will start a campaign to induce good young men to do nothing. If so, I shall not have lived in vain.
-
-Before advancing my own arguments for laziness, I must dispose of one which I cannot accept. Whenever a person who already has enough to live on proposes to engage in some everyday kind of job, such as school-teaching or typing, he or she is told that such conduct takes the bread out of other people's mouths, and is therefore wicked. If this argument were valid, it would only be necessary for us all to be idle in order that we should all have our mouths full of bread. What people who say such things forget is that what a man earns he usually spends, and in spending he gives employment. As long as a man spends his income, he puts just as much bread into people's mouths in spending as he takes out of other people's mouths in earning. The real villain, from this point of view, is the man who saves. If he merely puts his savings in a stocking, like the proverbial French peasant, it is obvious that they do not give employment. If he invests his savings, the matter is less obvious, and different cases arise.
-
-One of the commonest things to do with savings is to lend them to some Government. In view of the fact that the bulk of the public expenditure of most civilized Governments consists in payment for past wars or preparation for future wars, the man who lends his money to a Government is in the same position as the bad men in Shakespeare who hire murderers. The net result of the man's economical habits is to increase the armed forces of the State to which he lends his savings. Obviously it would be better if he spent the money, even if he spent it in drink or gambling.
-
-But, I shall be told, the case is quite different when savings are invested in industrial enterprises. When such enterprises succeed, and produce something useful, this may be conceded. In these days, however, no one will deny that most enterprises fail. That means that a large amount of human labor, which might have been devoted to producing something that could be enjoyed, was expended on producing machines which, when produced, lay idle and did no good to anyone. The man who invests his savings in a concern that goes bankrupt is therefore injuring others as well as himself. If he spent his money, say, in giving parties for his friends, they (we may hope) would get pleasure, and so would all those upon whom he spent money, such as the butcher, the baker, and the bootlegger. But if he spends it (let us say) upon laying down rails for surface card in some place where surface cars turn out not to be wanted, he has diverted a mass of labor into channels where it gives pleasure to no one. Nevertheless, when he becomes poor through failure of his investment he will be regarded as a victim of undeserved misfortune, whereas the gay spendthrift, who has spent his money philanthropically, will be despised as a fool and a frivolous person.
-
-All this is only preliminary. I want to say, in all seriousness, that a great deal of harm is being done in the modern world by belief in the virtuousness of work, and that the road to happiness and prosperity lies in an organized diminution of work.
-
-First of all: what is work? Work is of two kinds: first, altering the position of matter at or near the earth's surface relatively to other such matter; second, telling other people to do so. The first kind is unpleasant and ill paid; the second is pleasant and highly paid. The second kind is capable of indefinite extension: there are not only those who give orders, but those who give advice as to what orders should be given. Usually two opposite kinds of advice are given simultaneously by two organized bodies of men; this is called politics. The skill required for this kind of work is not knowledge of the subjects as to which advice is given, but knowledge of the art of persuasive speaking and writing, i.e. of advertising.
-
-Throughout Europe, though not in America, there is a third class of men, more respected than either of the classes of workers. There are men who, through ownership of land, are able to make others pay for the privilege of being allowed to exist and to work. These landowners are idle, and I might therefore be expected to praise them. Unfortunately, their idleness is only rendered possible by the industry of others; indeed their desire for comfortable idleness is historically the source of the whole gospel of work. The last thing they have ever wished is that others should follow their example.
-
-From the beginning of civilization until the Industrial Revolution, a man could, as a rule, produce by hard work little more than was required for the subsistence of himself and his family, although his wife worked at least as hard as he did, and his children added their labor as soon as they were old enough to do so. The small surplus above bare necessaries was not left to those who produced it, but was appropriated by warriors and priests. In times of famine there was no surplus; the warriors and priests, however, still secured as much as at other times, with the result that many of the workers died of hunger. This system persisted in Russia until 1917 [1], and still persists in the East; in England, in spite of the Industrial Revolution, it remained in full force throughout the Napoleonic wars, and until a hundred years ago, when the new class of manufacturers acquired power. In America, the system came to an end with the Revolution, except in the South, where it persisted until the Civil War. A system which lasted so long and ended so recently has naturally left a profound impress upon men's thoughts and opinions. Much that we take for granted about the desirability of work is derived from this system, and, being pre-industrial, is not adapted to the modern world. Modern technique has made it possible for leisure, within limits, to be not the prerogative of small privileged classes, but a right evenly distributed throughout the community. The morality of work is the morality of slaves, and the modern world has no need of slavery.
-
-It is obvious that, in primitive communities, peasants, left to themselves, would not have parted with the slender surplus upon which the warriors and priests subsisted, but would have either produced less or consumed more. At first, sheer force compelled them to produce and part with the surplus. Gradually, however, it was found possible to induce many of them to accept an ethic according to which it was their duty to work hard, although part of their work went to support others in idleness. By this means the amount of compulsion required was lessened, and the expenses of government were diminished. To this day, 99 per cent of British wage-earners would be genuinely shocked if it were proposed that the King should not have a larger income than a working man. The conception of duty, speaking historically, has been a means used by the holders of power to induce others to live for the interests of their masters rather than for their own. Of course the holders of power conceal this fact from themselves by managing to believe that their interests are identical with the larger interests of humanity. Sometimes this is true; Athenian slave-owners, for instance, employed part of their leisure in making a permanent contribution to civilization which would have been impossible under a just economic system. Leisure is essential to civilization, and in former times leisure for the few was only rendered possible by the labors of the many. But their labors were valuable, not because work is good, but because leisure is good. And with modern technique it would be possible to distribute leisure justly without injury to civilization.
-
-Modern technique has made it possible to diminish enormously the amount of labor required to secure the necessaries of life for everyone. This was made obvious during the war. At that time all the men in the armed forces, and all the men and women engaged in the production of munitions, all the men and women engaged in spying, war propaganda, or Government offices connected with the war, were withdrawn from productive occupations. In spite of this, the general level of well-being among unskilled wage-earners on the side of the Allies was higher than before or since. The significance of this fact was concealed by finance: borrowing made it appear as if the future was nourishing the present. But that, of course, would have been impossible; a man cannot eat a loaf of bread that does not yet exist. The war showed conclusively that, by the scientific organization of production, it is possible to keep modern populations in fair comfort on a small part of the working capacity of the modern world. If, at the end of the war, the scientific organization, which had been created in order to liberate men for fighting and munition work, had been preserved, and the hours of the week had been cut down to four, all would have been well. Instead of that the old chaos was restored, those whose work was demanded were made to work long hours, and the rest were left to starve as unemployed. Why? Because work is a duty, and a man should not receive wages in proportion to what he has produced, but in proportion to his virtue as exemplified by his industry.
-
-This is the morality of the Slave State, applied in circumstances totally unlike those in which it arose. No wonder the result has been disastrous. Let us take an illustration. Suppose that, at a given moment, a certain number of people are engaged in the manufacture of pins. They make as many pins as the world needs, working (say) eight hours a day. Someone makes an invention by which the same number of men can make twice as many pins: pins are already so cheap that hardly any more will be bought at a lower price. In a sensible world, everybody concerned in the manufacturing of pins would take to working four hours instead of eight, and everything else would go on as before. But in the actual world this would be thought demoralizing. The men still work eight hours, there are too many pins, some employers go bankrupt, and half the men previously concerned in making pins are thrown out of work. There is, in the end, just as much leisure as on the other plan, but half the men are totally idle while half are still overworked. In this way, it is insured that the unavoidable leisure shall cause misery all round instead of being a universal source of happiness. Can anything more insane be imagined?
-
-The idea that the poor should have leisure has always been shocking to the rich. In England, in the early nineteenth century, fifteen hours was the ordinary day's work for a man; children sometimes did as much, and very commonly did twelve hours a day. When meddlesome busybodies suggested that perhaps these hours were rather long, they were told that work kept adults from drink and children from mischief. When I was a child, shortly after urban working men had acquired the vote, certain public holidays were established by law, to the great indignation of the upper classes. I remember hearing an old Duchess say: 'What do the poor want with holidays? They ought to work.' People nowadays are less frank, but the sentiment persists, and is the source of much of our economic confusion.
-
-Let us, for a moment, consider the ethics of work frankly, without superstition. Every human being, of necessity, consumes, in the course of his life, a certain amount of the produce of human labor. Assuming, as we may, that labor is on the whole disagreeable, it is unjust that a man should consume more than he produces. Of course he may provide services rather than commodities, like a medical man, for example; but he should provide something in return for his board and lodging. to this extent, the duty of work must be admitted, but to this extent only.
-
-I shall not dwell upon the fact that, in all modern societies outside the USSR, many people escape even this minimum amount of work, namely all those who inherit money and all those who marry money. I do not think the fact that these people are allowed to be idle is nearly so harmful as the fact that wage-earners are expected to overwork or starve.
-
-If the ordinary wage-earner worked four hours a day, there would be enough for everybody and no unemployment -- assuming a certain very moderate amount of sensible organization. This idea shocks the well-to-do, because they are convinced that the poor would not know how to use so much leisure. In America men often work long hours even when they are well off; such men, naturally, are indignant at the idea of leisure for wage-earners, except as the grim punishment of unemployment; in fact, they dislike leisure even for their sons. Oddly enough, while they wish their sons to work so hard as to have no time to be civilized, they do not mind their wives and daughters having no work at all. the snobbish admiration of uselessness, which, in an aristocratic society, extends to both sexes, is, under a plutocracy, confined to women; this, however, does not make it any more in agreement with common sense.
-
-The wise use of leisure, it must be conceded, is a product of civilization and education. A man who has worked long hours all his life will become bored if he becomes suddenly idle. But without a considerable amount of leisure a man is cut off from many of the best things. There is no longer any reason why the bulk of the population should suffer this deprivation; only a foolish asceticism, usually vicarious, makes us continue to insist on work in excessive quantities now that the need no longer exists.
-
-In the new creed which controls the government of Russia, while there is much that is very different from the traditional teaching of the West, there are some things that are quite unchanged. The attitude of the governing classes, and especially of those who conduct educational propaganda, on the subject of the dignity of labor, is almost exactly that which the governing classes of the world have always preached to what were called the 'honest poor'. Industry, sobriety, willingness to work long hours for distant advantages, even submissiveness to authority, all these reappear; moreover authority still represents the will of the Ruler of the Universe, Who, however, is now called by a new name, Dialectical Materialism.
-
-The victory of the proletariat in Russia has some points in common with the victory of the feminists in some other countries. For ages, men had conceded the superior saintliness of women, and had consoled women for their inferiority by maintaining that saintliness is more desirable than power. At last the feminists decided that they would have both, since the pioneers among them believed all that the men had told them about the desirability of virtue, but not what they had told them about the worthlessness of political power. A similar thing has happened in Russia as regards manual work. For ages, the rich and their sycophants have written in praise of 'honest toil', have praised the simple life, have professed a religion which teaches that the poor are much more likely to go to heaven than the rich, and in general have tried to make manual workers believe that there is some special nobility about altering the position of matter in space, just as men tried to make women believe that they derived some special nobility from their sexual enslavement. In Russia, all this teaching about the excellence of manual work has been taken seriously, with the result that the manual worker is more honored than anyone else. What are, in essence, revivalist appeals are made, but not for the old purposes: they are made to secure shock workers for special tasks. Manual work is the ideal which is held before the young, and is the basis of all ethical teaching.
-
-For the present, possibly, this is all to the good. A large country, full of natural resources, awaits development, and has has to be developed with very little use of credit. In these circumstances, hard work is necessary, and is likely to bring a great reward. But what will happen when the point has been reached where everybody could be comfortable without working long hours?
-
-In the West, we have various ways of dealing with this problem. We have no attempt at economic justice, so that a large proportion of the total produce goes to a small minority of the population, many of whom do no work at all. Owing to the absence of any central control over production, we produce hosts of things that are not wanted. We keep a large percentage of the working population idle, because we can dispense with their labor by making the others overwork. When all these methods prove inadequate, we have a war: we cause a number of people to manufacture high explosives, and a number of others to explode them, as if we were children who had just discovered fireworks. By a combination of all these devices we manage, though with difficulty, to keep alive the notion that a great deal of severe manual work must be the lot of the average man.
-
-In Russia, owing to more economic justice and central control over production, the problem will have to be differently solved. the rational solution would be, as soon as the necessaries and elementary comforts can be provided for all, to reduce the hours of labor gradually, allowing a popular vote to decide, at each stage, whether more leisure or more goods were to be preferred. But, having taught the supreme virtue of hard work, it is difficult to see how the authorities can aim at a paradise in which there will be much leisure and little work. It seems more likely that they will find continually fresh schemes, by which present leisure is to be sacrificed to future productivity. I read recently of an ingenious plan put forward by Russian engineers, for making the White Sea and the northern coasts of Siberia warm, by putting a dam across the Kara Sea. An admirable project, but liable to postpone proletarian comfort for a generation, while the nobility of toil is being displayed amid the ice-fields and snowstorms of the Arctic Ocean. This sort of thing, if it happens, will be the result of regarding the virtue of hard work as an end in itself, rather than as a means to a state of affairs in which it is no longer needed.
-
-The fact is that moving matter about, while a certain amount of it is necessary to our existence, is emphatically not one of the ends of human life. If it were, we should have to consider every navvy superior to Shakespeare. We have been misled in this matter by two causes. One is the necessity of keeping the poor contented, which has led the rich, for thousands of years, to preach the dignity of labor, while taking care themselves to remain undignified in this respect. The other is the new pleasure in mechanism, which makes us delight in the astonishingly clever changes that we can produce on the earth's surface. Neither of these motives makes any great appeal to the actual worker. If you ask him what he thinks the best part of his life, he is not likely to say: 'I enjoy manual work because it makes me feel that I am fulfilling man's noblest task, and because I like to think how much man can transform his planet. It is true that my body demands periods of rest, which I have to fill in as best I may, but I am never so happy as when the morning comes and I can return to the toil from which my contentment springs.' I have never heard working men say this sort of thing. They consider work, as it should be considered, a necessary means to a livelihood, and it is from their leisure that they derive whatever happiness they may enjoy.
-
-It will be said that, while a little leisure is pleasant, men would not know how to fill their days if they had only four hours of work out of the twenty-four. In so far as this is true in the modern world, it is a condemnation of our civilization; it would not have been true at any earlier period. There was formerly a capacity for light-heartedness and play which has been to some extent inhibited by the cult of efficiency. The modern man thinks that everything ought to be done for the sake of something else, and never for its own sake. Serious-minded persons, for example, are continually condemning the habit of going to the cinema, and telling us that it leads the young into crime. But all the work that goes to producing a cinema is respectable, because it is work, and because it brings a money profit. The notion that the desirable activities are those that bring a profit has made everything topsy-turvy. The butcher who provides you with meat and the baker who provides you with bread are praiseworthy, because they are making money; but when you enjoy the food they have provided, you are merely frivolous, unless you eat only to get strength for your work. Broadly speaking, it is held that getting money is good and spending money is bad. Seeing that they are two sides of one transaction, this is absurd; one might as well maintain that keys are good, but keyholes are bad. Whatever merit there may be in the production of goods must be entirely derivative from the advantage to be obtained by consuming them. The individual, in our society, works for profit; but the social purpose of his work lies in the consumption of what he produces. It is this divorce between the individual and the social purpose of production that makes it so difficult for men to think clearly in a world in which profit-making is the incentive to industry. We think too much of production, and too little of consumption. One result is that we attach too little importance to enjoyment and simple happiness, and that we do not judge production by the pleasure that it gives to the consumer.
-
-When I suggest that working hours should be reduced to four, I am not meaning to imply that all the remaining time should necessarily be spent in pure frivolity. I mean that four hours' work a day should entitle a man to the necessities and elementary comforts of life, and that the rest of his time should be his to use as he might see fit. It is an essential part of any such social system that education should be carried further than it usually is at present, and should aim, in part, at providing tastes which would enable a man to use leisure intelligently. I am not thinking mainly of the sort of things that would be considered 'highbrow'. Peasant dances have died out except in remote rural areas, but the impulses which caused them to be cultivated must still exist in human nature. The pleasures of urban populations have become mainly passive: seeing cinemas, watching football matches, listening to the radio, and so on. This results from the fact that their active energies are fully taken up with work; if they had more leisure, they would again enjoy pleasures in which they took an active part.
-
-In the past, there was a small leisure class and a larger working class. The leisure class enjoyed advantages for which there was no basis in social justice; this necessarily made it oppressive, limited its sympathies, and caused it to invent theories by which to justify its privileges. These facts greatly diminished its excellence, but in spite of this drawback it contributed nearly the whole of what we call civilization. It cultivated the arts and discovered the sciences; it wrote the books, invented the philosophies, and refined social relations. Even the liberation of the oppressed has usually been inaugurated from above. Without the leisure class, mankind would never have emerged from barbarism.
-
-The method of a leisure class without duties was, however, extraordinarily wasteful. None of the members of the class had to be taught to be industrious, and the class as a whole was not exceptionally intelligent. The class might produce one Darwin, but against him had to be set tens of thousands of country gentlemen who never thought of anything more intelligent than fox-hunting and punishing poachers. At present, the universities are supposed to provide, in a more systematic way, what the leisure class provided accidentally and as a by-product. This is a great improvement, but it has certain drawbacks. University life is so different from life in the world at large that men who live in academic milieu tend to be unaware of the preoccupations and problems of ordinary men and women; moreover their ways of expressing themselves are usually such as to rob their opinions of the influence that they ought to have upon the general public. Another disadvantage is that in universities studies are organized, and the man who thinks of some original line of research is likely to be discouraged. Academic institutions, therefore, useful as they are, are not adequate guardians of the interests of civilization in a world where everyone outside their walls is too busy for unutilitarian pursuits.
-
-In a world where no one is compelled to work more than four hours a day, every person possessed of scientific curiosity will be able to indulge it, and every painter will be able to paint without starving, however excellent his pictures may be. Young writers will not be obliged to draw attention to themselves by sensational pot-boilers, with a view to acquiring the economic independence needed for monumental works, for which, when the time at last comes, they will have lost the taste and capacity. Men who, in their professional work, have become interested in some phase of economics or government, will be able to develop their ideas without the academic detachment that makes the work of university economists often seem lacking in reality. Medical men will have the time to learn about the progress of medicine, teachers will not be exasperatedly struggling to teach by routine methods things which they learnt in their youth, which may, in the interval, have been proved to be untrue.
-
-Above all, there will be happiness and joy of life, instead of frayed nerves, weariness, and dyspepsia. The work exacted will be enough to make leisure delightful, but not enough to produce exhaustion. Since men will not be tired in their spare time, they will not demand only such amusements as are passive and vapid. At least one per cent will probably devote the time not spent in professional work to pursuits of some public importance, and, since they will not depend upon these pursuits for their livelihood, their originality will be unhampered, and there will be no need to conform to the standards set by elderly pundits. But it is not only in these exceptional cases that the advantages of leisure will appear. Ordinary men and women, having the opportunity of a happy life, will become more kindly and less persecuting and less inclined to view others with suspicion. The taste for war will die out, partly for this reason, and partly because it will involve long and severe work for all. Good nature is, of all moral qualities, the one that the world needs most, and good nature is the result of ease and security, not of a life of arduous struggle. Modern methods of production have given us the possibility of ease and security for all; we have chosen, instead, to have overwork for some and starvation for others. Hitherto we have continued to be as energetic as we were before there were machines; in this we have been foolish, but there is no reason to go on being foolish forever.
-
-[1] Since then, members of the Communist Party have succeeded to this privilege of the warriors and priests.
diff --git a/node_modules/uglify-js/node_modules/wordwrap/test/wrap.js b/node_modules/uglify-js/node_modules/wordwrap/test/wrap.js
deleted file mode 100644
index 0cfb76d17..000000000
--- a/node_modules/uglify-js/node_modules/wordwrap/test/wrap.js
+++ /dev/null
@@ -1,31 +0,0 @@
-var assert = require('assert');
-var wordwrap = require('wordwrap');
-
-var fs = require('fs');
-var idleness = fs.readFileSync(__dirname + '/idleness.txt', 'utf8');
-
-exports.stop80 = function () {
-    var lines = wordwrap(80)(idleness).split(/\n/);
-    var words = idleness.split(/\s+/);
-    
-    lines.forEach(function (line) {
-        assert.ok(line.length <= 80, 'line > 80 columns');
-        var chunks = line.match(/\S/) ? line.split(/\s+/) : [];
-        assert.deepEqual(chunks, words.splice(0, chunks.length));
-    });
-};
-
-exports.start20stop60 = function () {
-    var lines = wordwrap(20, 100)(idleness).split(/\n/);
-    var words = idleness.split(/\s+/);
-    
-    lines.forEach(function (line) {
-        assert.ok(line.length <= 100, 'line > 100 columns');
-        var chunks = line
-            .split(/\s+/)
-            .filter(function (x) { return x.match(/\S/) })
-        ;
-        assert.deepEqual(chunks, words.splice(0, chunks.length));
-        assert.deepEqual(line.slice(0, 20), new Array(20 + 1).join(' '));
-    });
-};
diff --git a/node_modules/uglify-js/node_modules/yargs/CHANGELOG.md b/node_modules/uglify-js/node_modules/yargs/CHANGELOG.md
deleted file mode 100644
index 9c3607831..000000000
--- a/node_modules/uglify-js/node_modules/yargs/CHANGELOG.md
+++ /dev/null
@@ -1,374 +0,0 @@
-## Change Log
-
-### v3.10.0 (2015/05/29 04:25 +00:00)
-
-- [#165](https://github.com/bcoe/yargs/pull/165) expose yargs.terminalWidth() thanks @ensonic (@bcoe)
-- [#164](https://github.com/bcoe/yargs/pull/164) better array handling thanks @getify (@bcoe)
-
-### v3.9.1 (2015/05/20 05:14 +00:00)
-- [b6662b6](https://github.com/bcoe/yargs/commit/b6662b6774cfeab4876f41ec5e2f67b7698f4e2f) clarify .config() docs (@linclark)
-- [0291360](https://github.com/bcoe/yargs/commit/02913606285ce31ce81d7f12c48d8a3029776ec7) fixed tests, switched to nyc for coverage, fixed security issue, added Lin as collaborator (@bcoe)
-
-### v3.9.0 (2015/05/10 18:32 +00:00)
-- [#157](https://github.com/bcoe/yargs/pull/157) Merge pull request #157 from bcoe/command-yargs. allows handling of command specific arguments. Thanks for the suggestion @ohjames (@bcoe)
-- [#158](https://github.com/bcoe/yargs/pull/158) Merge pull request #158 from kemitchell/spdx-license. Update license format (@kemitchell)
-
-### v3.8.0 (2015/04/24 23:10 +00:00)
-- [#154](https://github.com/bcoe/yargs/pull/154) showHelp's method signature was misleading fixes #153 (@bcoe)
-- [#151](https://github.com/bcoe/yargs/pull/151) refactor yargs' table layout logic to use new helper library (@bcoe)
-- [#150](https://github.com/bcoe/yargs/pull/150) Fix README example in argument requirements (@annonymouse)
-
-### v3.7.2 (2015/04/13 11:52 -07:00)
-
-* [679fbbf](https://github.com/bcoe/yargs/commit/679fbbf55904030ccee8a2635e8e5f46551ab2f0) updated yargs to use the [standard](https://github.com/feross/standard) style guide (agokjr)
-* [22382ee](https://github.com/bcoe/yargs/commit/22382ee9f5b495bc2586c1758cd1091cec3647f9 various bug fixes for $0 (@nylen)
-
-### v3.7.1 (2015/04/10 11:06 -07:00)
-
-* [89e1992](https://github.com/bcoe/yargs/commit/89e1992a004ba73609b5f9ee6890c4060857aba4) detect iojs bin along with node bin. (@bcoe)
-* [755509e](https://github.com/bcoe/yargs/commit/755509ea90041e5f7833bba3b8c5deffe56f0aab) improvements to example documentation in README.md (@rstacruz)
-* [0d2dfc8](https://github.com/bcoe/yargs/commit/0d2dfc822a43418242908ad97ddd5291a1b35dc6) showHelp() no longer requires that .argv has been called (@bcoe)
-
-### v3.7.0 (2015/04/04 02:29 -07:00)
-
-* [56cbe2d](https://github.com/bcoe/yargs/commit/56cbe2ddd33dc176dcbf97ba40559864a9f114e4) make .requiresArg() work with type hints. (@bcoe).
-* [2f5d562](https://github.com/bcoe/yargs/commit/2f5d5624f736741deeedf6a664d57bc4d857bdd0) serialize arrays and objects in usage strings. (@bcoe).
-* [5126304](https://github.com/bcoe/yargs/commit/5126304dd18351fc28f10530616fdd9361e0af98) be more lenient about alias/primary key ordering in chaining API. (@bcoe)
-
-### v3.6.0 (2015/03/21 01:00 +00:00)
-- [4e24e22](https://github.com/bcoe/yargs/commit/4e24e22e6a195e55ab943ede704a0231ac33b99c) support for .js configuration files. (@pirxpilot)
-
-### v3.5.4 (2015/03/12 05:56 +00:00)
-- [c16cc08](https://github.com/bcoe/yargs/commit/c16cc085501155cf7fd853ccdf8584b05ab92b78) message for non-option arguments is now optional, thanks to (@raine)
-
-### v3.5.3 (2015/03/09 06:14 +00:00)
-- [870b428](https://github.com/bcoe/yargs/commit/870b428cf515d560926ca392555b7ad57dba9e3d) completion script was missing in package.json (@bcoe)
-
-### v3.5.2 (2015/03/09 06:11 +00:00)
-- [58a4b24](https://github.com/bcoe/yargs/commit/58a4b2473ebbb326713d522be53e32d3aabb08d2) parse was being called multiple times, resulting in strange behavior (@bcoe)
-
-### v3.5.1 (2015/03/09 04:55 +00:00)
-- [4e588e0](https://github.com/bcoe/yargs/commit/4e588e055afbeb9336533095f051496e3977f515) accidentally left testing logic in (@bcoe)
-
-### v3.5.0 (2015/03/09 04:49 +00:00)
-- [718bacd](https://github.com/bcoe/yargs/commit/718bacd81b9b44f786af76b2afe491fe06274f19) added support for bash completions see #4 (@bcoe)
-- [a192882](https://github.com/bcoe/yargs/commit/a19288270fc431396c42af01125eeb4443664528) downgrade to mocha 2.1.0 until https://github.com/mochajs/mocha/issues/1585 can be sorted out (@bcoe)
-
-### v3.4.7 (2015/03/09 04:09 +00:00)
-- [9845e5c](https://github.com/bcoe/yargs/commit/9845e5c1a9c684ba0be3f0bfb40e7b62ab49d9c8) the Argv singleton was not being updated when manually parsing arguments, fixes #114 (@bcoe)
-
-### v3.4.6 (2015/03/09 04:01 +00:00)
-- [45b4c80](https://github.com/bcoe/yargs/commit/45b4c80b890d02770b0a94f326695a8a566e8fe9) set placeholders for all keys fixes #115 (@bcoe)
-
-### v3.4.5 (2015/03/01 20:31 +00:00)
-- [a758e0b](https://github.com/bcoe/yargs/commit/a758e0b2556184f067cf3d9c4ef886d39817ebd2) fix for count consuming too many arguments (@bcoe)
-
-### v3.4.4 (2015/02/28 04:52 +00:00)
-- [0476af7](https://github.com/bcoe/yargs/commit/0476af757966acf980d998b45108221d4888cfcb) added nargs feature, allowing you to specify the number of arguments after an option (@bcoe)
-- [092477d](https://github.com/bcoe/yargs/commit/092477d7ab3efbf0ba11cede57f7d8cfc70b024f) updated README with full example of v3.0 API (@bcoe)
-
-### v3.3.3 (2015/02/28 04:23 +00:00)
-- [0c4b769](https://github.com/bcoe/yargs/commit/0c4b769516cd8d93a7c4e5e675628ae0049aa9a8) remove string dependency, which conflicted with other libraries see #106 (@bcoe)
-
-### v3.3.2 (2015/02/28 04:11 +00:00)
-- [2a98906](https://github.com/bcoe/yargs/commit/2a9890675821c0e7a12f146ce008b0562cb8ec9a) add $0 to epilog (@schnittstabil)
-
-### v3.3.1 (2015/02/24 03:28 +00:00)
-- [ad485ce](https://github.com/bcoe/yargs/commit/ad485ce748ebdfce25b88ef9d6e83d97a2f68987) fix for applying defaults to camel-case args (@bcoe)
-
-### v3.3.0 (2015/02/24 00:49 +00:00)
-- [8bfe36d](https://github.com/bcoe/yargs/commit/8bfe36d7fb0f93a799ea3f4c756a7467c320f8c0) fix and document restart() command, as a tool for building nested CLIs (@bcoe)
-
-### v3.2.1 (2015/02/22 05:45 +00:00)
-- [49a6d18](https://github.com/bcoe/yargs/commit/49a6d1822a4ef9b1ea6f90cc366be60912628885) you can now provide a function that generates a default value (@bcoe)
-
-### v3.2.0 (2015/02/22 05:24 +00:00)
-- [7a55886](https://github.com/bcoe/yargs/commit/7a55886c9343cf71a20744ca5cdd56d2ea7412d5) improvements to yargs two-column text layout (@bcoe)
-- [b6ab513](https://github.com/bcoe/yargs/commit/b6ab5136a4c3fa6aa496f6b6360382e403183989) Tweak NPM version badge (@nylen)
-
-### v3.1.0 (2015/02/19 19:37 +00:00)
-- [9bd2379](https://github.com/bcoe/yargs/commit/9bd237921cf1b61fd9f32c0e6d23f572fc225861) version now accepts a function, making it easy to load version #s from a package.json (@bcoe)
-
-### v3.0.4 (2015/02/14 01:40 +00:00)
-- [0b7c19b](https://github.com/bcoe/yargs/commit/0b7c19beaecb747267ca4cc10e5cb2a8550bc4b7) various fixes for dot-notation handling (@bcoe)
-
-### v3.0.3 (2015/02/14 00:59 +00:00)
-- [c3f35e9](https://github.com/bcoe/yargs/commit/c3f35e99bd5a0d278073fcadd95e2d778616cc17) make sure dot-notation is applied to aliases (@bcoe)
-
-### 3.0.2 (2015/02/13 16:50 +00:00)
-- [74c8967](https://github.com/bcoe/yargs/commit/74c8967c340c204a0a7edf8a702b6f46c2705435) document epilog shorthand of epilogue. (@bcoe)
-- [670110f](https://github.com/bcoe/yargs/commit/670110fc01bedc4831b6fec6afac54517d5a71bc) any non-truthy value now causes check to fail see #76 (@bcoe)
-- [0d8f791](https://github.com/bcoe/yargs/commit/0d8f791a33c11ced4cd431ea8d3d3a337d456b56) finished implementing my wish-list of fetures for yargs 3.0. see #88 (@bcoe)
-- [5768447](https://github.com/bcoe/yargs/commit/5768447447c4c8e8304f178846206ce86540f063) fix coverage. (@bcoe)
-- [82e793f](https://github.com/bcoe/yargs/commit/82e793f3f61c41259eaacb67f0796aea2cf2aaa0) detect console width and perform word-wrapping. (@bcoe)
-- [67476b3](https://github.com/bcoe/yargs/commit/67476b37eea07fee55f23f35b9e0c7d76682b86d) refactor two-column table layout so that we can use it for examples and usage (@bcoe)
-- [4724cdf](https://github.com/bcoe/yargs/commit/4724cdfcc8e37ae1ca3dcce9d762f476e9ef4bb4) major refactor of index.js, in prep for 3.x release. (@bcoe)
-
-### v2.3.0 (2015/02/08 20:41 +00:00)
-- [d824620](https://github.com/bcoe/yargs/commit/d824620493df4e63664af1fe320764dd1a9244e6) allow for undefined boolean defaults (@ashi009)
-
-### v2.2.0 (2015/02/08 20:07 +00:00)
-- [d6edd98](https://github.com/bcoe/yargs/commit/d6edd9848826e7389ed1393858c45d03961365fd) in-prep for further refactoring, and a 3.x release I've shuffled some things around and gotten test-coverage to 100%. (@bcoe)
-
-### v2.1.2 (2015/02/08 06:05 +00:00)
-- [d640745](https://github.com/bcoe/yargs/commit/d640745a7b9f8d476e0223879d056d18d9c265c4) switch to path.relative (@bcoe)
-- [3bfd41f](https://github.com/bcoe/yargs/commit/3bfd41ff262a041f29d828b88936a79c63cad594) remove mocha.opts. (@bcoe)
-- [47a2f35](https://github.com/bcoe/yargs/commit/47a2f357091db70903a402d6765501c1d63f15fe) document using .string('_') for string ids. see #56 (@bcoe)
-- [#57](https://github.com/bcoe/yargs/pull/57) Merge pull request #57 from eush77/option-readme (@eush77)
-
-### v2.1.1 (2015/02/06 08:08 +00:00)
-- [01c6c61](https://github.com/bcoe/yargs/commit/01c6c61d67b4ebf88f41f0b32a345ec67f0ac17d) fix for #71, 'newAliases' of undefined (@bcoe)
-
-### v2.1.0 (2015/02/06 07:59 +00:00)
-- [6a1a3fa](https://github.com/bcoe/yargs/commit/6a1a3fa731958e26ccd56885f183dd8985cc828f) try to guess argument types, and apply sensible defaults see #73 (@bcoe)
-
-### v2.0.1 (2015/02/06 07:54 +00:00)
-- [96a06b2](https://github.com/bcoe/yargs/commit/96a06b2650ff1d085a52b7328d8bba614c20cc12) Fix for strange behavior with --sort option, see #51 (@bcoe)
-
-### v2.0.0 (2015/02/06 07:45 +00:00)
-- [0250517](https://github.com/bcoe/yargs/commit/0250517c9643e53f431b824e8ccfa54937414011) - [108fb84](https://github.com/bcoe/yargs/commit/108fb8409a3a63dcaf99d917fe4dfcfaa1de236d) fixed bug with boolean parsing, when bools separated by = see #66 (@bcoe)
-- [a465a59](https://github.com/bcoe/yargs/commit/a465a5915f912715738de890982e4f8395958b10) Add `files` field to the package.json (@shinnn)
-- [31043de](https://github.com/bcoe/yargs/commit/31043de7a38a17c4c97711f1099f5fb164334db3) fix for yargs.argv having the same keys added multiple times see #63 (@bcoe)
-- [2d68c5b](https://github.com/bcoe/yargs/commit/2d68c5b91c976431001c4863ce47c9297850f1ad) Disable process.exit calls using .exitProcess(false) (@cianclarke)
-- [45da9ec](https://github.com/bcoe/yargs/commit/45da9ec4c55a7bd394721bc6a1db0dabad7bc52a) Mention .option in README (@eush77)
-
-### v1.3.2 (2014/10/06 21:56 +00:00)
-- [b8d3472](https://github.com/bcoe/yargs/commit/b8d34725482e5821a3cc809c0df71378f282f526) 1.3.2 (@chevex)
-
-### list (2014/08/30 18:41 +00:00)
-- [fbc777f](https://github.com/bcoe/yargs/commit/fbc777f416eeefd37c84e44d27d7dfc7c1925721) Now that yargs is the successor to optimist, I'm changing the README language to be more universal. Pirate speak isn't very accessible to non-native speakers. (@chevex)
-- [a54d068](https://github.com/bcoe/yargs/commit/a54d0682ae2efc2394d407ab171cc8a8bbd135ea) version output will not print extra newline (@boneskull)
-- [1cef5d6](https://github.com/bcoe/yargs/commit/1cef5d62a9d6d61a3948a49574892e01932cc6ae) Added contributors section to package.json (@chrisn)
-- [cc295c0](https://github.com/bcoe/yargs/commit/cc295c0a80a2de267e0155b60d315fc4b6f7c709) Added 'require' and 'required' as synonyms for 'demand' (@chrisn)
-- [d0bf951](https://github.com/bcoe/yargs/commit/d0bf951d949066b6280101ed606593d079ee15c8) Updating minimist. (@chevex)
-- [c15f8e7](https://github.com/bcoe/yargs/commit/c15f8e7f245b261e542cf205ce4f4313630cbdb4) Fix #31 (bad interaction between camelCase options and strict mode) (@nylen)
-- [d991b9b](https://github.com/bcoe/yargs/commit/d991b9be687a68812dee1e3b185ba64b7778b82d) Added .help() and .version() methods (@chrisn)
-- [e8c8aa4](https://github.com/bcoe/yargs/commit/e8c8aa46268379357cb11e9fc34b8c403037724b) Added .showHelpOnFail() method (@chrisn)
-- [e855af4](https://github.com/bcoe/yargs/commit/e855af4a933ea966b5bbdd3c4c6397a4bac1a053) Allow boolean flag with .demand() (@chrisn)
-- [14dbec2](https://github.com/bcoe/yargs/commit/14dbec24fb7380683198e2b20c4deb8423e64bea) Fixes issue #22. Arguments are no longer printed to the console when using .config. (@chevex)
-- [bef74fc](https://github.com/bcoe/yargs/commit/bef74fcddc1544598a804f80d0a3728459f196bf) Informing users that Yargs is the official optimist successor. (@chevex)
-- [#24](https://github.com/bcoe/yargs/pull/24) Merge pull request #24 from chrisn/strict (@chrisn)
-- [889a2b2](https://github.com/bcoe/yargs/commit/889a2b28eb9768801b05163360a470d0fd6c8b79) Added requiresArg option, for options that require values (@chrisn)
-- [eb16369](https://github.com/bcoe/yargs/commit/eb163692262be1fe80b992fd8803d5923c5a9b18) Added .strict() method, to report error if unknown arguments are given (@chrisn)
-- [0471c3f](https://github.com/bcoe/yargs/commit/0471c3fd999e1ad4e6cded88b8aa02013b66d14f) Changed optimist to yargs in usage-options.js example (@chrisn)
-- [5c88f74](https://github.com/bcoe/yargs/commit/5c88f74e3cf031b17c54b4b6606c83e485ff520e) Change optimist to yargs in examples (@chrisn)
-- [66f12c8](https://github.com/bcoe/yargs/commit/66f12c82ba3c943e4de8ca862980e835da8ecb3a) Fix a couple of bad interactions between aliases and defaults (@nylen)
-- [8fa1d80](https://github.com/bcoe/yargs/commit/8fa1d80f14b03eb1f2898863a61f1d1615bceb50) Document second argument of usage(message, opts) (@Gobie)
-- [56e6528](https://github.com/bcoe/yargs/commit/56e6528cf674ff70d63083fb044ff240f608448e) For "--some-option", also set argv.someOption (@nylen)
-- [ed5f6d3](https://github.com/bcoe/yargs/commit/ed5f6d33f57ad1086b11c91b51100f7c6c7fa8ee) Finished porting unit tests to Mocha. (@chevex)
-
-### v1.0.15 (2014/02/05 23:18 +00:00)
-- [e2b1fc0](https://github.com/bcoe/yargs/commit/e2b1fc0c4a59cf532ae9b01b275e1ef57eeb64d2) 1.0.15 update to badges (@chevex)
-
-### v1.0.14 (2014/02/05 23:17 +00:00)
-- [f33bbb0](https://github.com/bcoe/yargs/commit/f33bbb0f00fe18960f849cc8e15a7428a4cd59b8) Revert "Fixed issue which caused .demand function not to work correctly." (@chevex)
-
-### v1.0.13 (2014/02/05 22:13 +00:00)
-- [6509e5e](https://github.com/bcoe/yargs/commit/6509e5e7dee6ef1a1f60eea104be0faa1a045075) Fixed issue which caused .demand function not to work correctly. (@chevex)
-
-### v1.0.12 (2013/12/13 00:09 +00:00)
-- [05eb267](https://github.com/bcoe/yargs/commit/05eb26741c9ce446b33ff006e5d33221f53eaceb) 1.0.12 (@chevex)
-
-### v1.0.11 (2013/12/13 00:07 +00:00)
-- [c1bde46](https://github.com/bcoe/yargs/commit/c1bde46e37318a68b87d17a50c130c861d6ce4a9) 1.0.11 (@chevex)
-
-### v1.0.10 (2013/12/12 23:57 +00:00)
-- [dfebf81](https://github.com/bcoe/yargs/commit/dfebf8164c25c650701528ee581ca483a99dc21c) Fixed formatting in README (@chevex)
-
-### v1.0.9 (2013/12/12 23:47 +00:00)
-- [0b4e34a](https://github.com/bcoe/yargs/commit/0b4e34af5e6d84a9dbb3bb6d02cd87588031c182) Update README.md (@chevex)
-
-### v1.0.8 (2013/12/06 16:36 +00:00)
-- [#1](https://github.com/bcoe/yargs/pull/1) fix error caused by check() see #1 (@martinheidegger)
-
-### v1.0.7 (2013/11/24 18:01 +00:00)
-- [a247d88](https://github.com/bcoe/yargs/commit/a247d88d6e46644cbb7303c18b1bb678fc132d72) Modified Pirate Joe image. (@chevex)
-
-### v1.0.6 (2013/11/23 19:21 +00:00)
-- [d7f69e1](https://github.com/bcoe/yargs/commit/d7f69e1d34bc929736a8bdccdc724583e21b7eab) Updated Pirate Joe image. (@chevex)
-
-### v1.0.5 (2013/11/23 19:09 +00:00)
-- [ece809c](https://github.com/bcoe/yargs/commit/ece809cf317cc659175e1d66d87f3ca68c2760be) Updated readme notice again. (@chevex)
-
-### v1.0.4 (2013/11/23 19:05 +00:00)
-- [9e81e81](https://github.com/bcoe/yargs/commit/9e81e81654028f83ba86ffc3ac772a0476084e5e) Updated README with a notice about yargs being a fork of optimist and what that implies. (@chevex)
-
-### v1.0.3 (2013/11/23 17:43 +00:00)
-- [65e7a78](https://github.com/bcoe/yargs/commit/65e7a782c86764944d63d084416aba9ee6019c5f) Changed some small wording in README.md. (@chevex)
-- [459e20e](https://github.com/bcoe/yargs/commit/459e20e539b366b85128dd281ccd42221e96c7da) Fix a bug in the options function, when string and boolean options weren't applied to aliases. (@shockone)
-
-### v1.0.2 (2013/11/23 09:46 +00:00)
-- [3d80ebe](https://github.com/bcoe/yargs/commit/3d80ebed866d3799224b6f7d596247186a3898a9) 1.0.2 (@chevex)
-
-### v1.0.1 (2013/11/23 09:39 +00:00)
-- [f80ff36](https://github.com/bcoe/yargs/commit/f80ff3642d580d4b68bf9f5a94277481bd027142) Updated image. (@chevex)
-
-### v1.0.0 (2013/11/23 09:33 +00:00)
-- [54e31d5](https://github.com/bcoe/yargs/commit/54e31d505f820b80af13644e460894b320bf25a3) Rebranded from optimist to yargs in the spirit of the fork :D (@chevex)
-- [4ebb6c5](https://github.com/bcoe/yargs/commit/4ebb6c59f44787db7c24c5b8fe2680f01a23f498) Added documentation for demandCount(). (@chevex)
-- [4561ce6](https://github.com/bcoe/yargs/commit/4561ce66dcffa95f49e8b4449b25b94cd68acb25) Simplified the error messages returned by .check(). (@chevex)
-- [661c678](https://github.com/bcoe/yargs/commit/661c67886f479b16254a830b7e1db3be29e6b7a6) Fixed an issue with demand not accepting a zero value. (@chevex)
-- [731dd3c](https://github.com/bcoe/yargs/commit/731dd3c37624790490bd6df4d5f1da8f4348279e) Add .fail(fn) so death isn't the only option. Should fix issue #39. (@chevex)
-- [fa15417](https://github.com/bcoe/yargs/commit/fa15417ff9e70dace0d726627a5818654824c1d8) Added a few missing 'return self' (@chevex)
-- [e655e4d](https://github.com/bcoe/yargs/commit/e655e4d99d1ae1d3695ef755d51c2de08d669761) Fix showing help in certain JS environments. (@chevex)
-- [a746a31](https://github.com/bcoe/yargs/commit/a746a31cd47c87327028e6ea33762d6187ec5c87) Better string representation of default values. (@chevex)
-- [6134619](https://github.com/bcoe/yargs/commit/6134619a7e90b911d5443230b644c5d447c1a68c) Implies: conditional demands (@chevex)
-- [046b93b](https://github.com/bcoe/yargs/commit/046b93b5d40a27367af4cb29726e4d781d934639) Added support for JSON config files. (@chevex)
-- [a677ec0](https://github.com/bcoe/yargs/commit/a677ec0a0ecccd99c75e571d03323f950688da03) Add .example(cmd, desc) feature. (@chevex)
-- [1bd4375](https://github.com/bcoe/yargs/commit/1bd4375e11327ba1687d4bb6e5e9f3c30c1be2af) Added 'defaults' as alias to 'default' so as to avoid usage of a reserved keyword. (@chevex)
-- [6b753c1](https://github.com/bcoe/yargs/commit/6b753c16ca09e723060e70b773b430323b29c45c) add .normalize(args..) support for normalizing paths (@chevex)
-- [33d7d59](https://github.com/bcoe/yargs/commit/33d7d59341d364f03d3a25f0a55cb99004dbbe4b) Customize error messages with demand(key, msg) (@chevex)
-- [647d37f](https://github.com/bcoe/yargs/commit/647d37f164c20f4bafbf67dd9db6cd6e2cd3b49f) Merge branch 'rewrite-duplicate-test' of github.com:isbadawi/node-optimist (@chevex)
-- [9059d1a](https://github.com/bcoe/yargs/commit/9059d1ad5e8aea686c2a01c89a23efdf929fff2e) Pass aliases object to check functions for greater versatility. (@chevex)
-- [623dc26](https://github.com/bcoe/yargs/commit/623dc26c7331abff2465ef8532e3418996d42fe6) Added ability to count boolean options and rolled minimist library back into project. (@chevex)
-- [49f0dce](https://github.com/bcoe/yargs/commit/49f0dcef35de4db544c3966350d36eb5838703f6) Fixed small typo. (@chevex)
-- [79ec980](https://github.com/bcoe/yargs/commit/79ec9806d9ca6eb0014cfa4b6d1849f4f004baf2) Removed dependency on wordwrap module. (@chevex)
-- [ea14630](https://github.com/bcoe/yargs/commit/ea14630feddd69d1de99dd8c0e08948f4c91f00a) Merge branch 'master' of github.com:chbrown/node-optimist (@chevex)
-- [2b75da2](https://github.com/bcoe/yargs/commit/2b75da2624061e0f4f3107d20303c06ec9054906) Merge branch 'master' of github.com:seanzhou1023/node-optimist (@chevex)
-- [d9bda11](https://github.com/bcoe/yargs/commit/d9bda1116e26f3b40e833ca9ca19263afea53565) Merge branch 'patch-1' of github.com:thefourtheye/node-optimist (@chevex)
-- [d6cc606](https://github.com/bcoe/yargs/commit/d6cc6064a4f1bea38a16a4430b8a1334832fbeff) Renamed README. (@chevex)
-- [9498d3f](https://github.com/bcoe/yargs/commit/9498d3f59acfb5e102826503e681623c3a64b178) Renamed readme and added .gitignore. (@chevex)
-- [bbd1fe3](https://github.com/bcoe/yargs/commit/bbd1fe37fefa366dde0fb3dc44d91fe8b28f57f5) Included examples for ```help``` and ```showHelp``` functions and fixed few formatting issues (@thefourtheye)
-- [37fea04](https://github.com/bcoe/yargs/commit/37fea0470a5796a0294c1dcfff68d8041650e622) .alias({}) behaves differently based on mapping direction when generating descriptions (@chbrown)
-- [855b20d](https://github.com/bcoe/yargs/commit/855b20d0be567ca121d06b30bea64001b74f3d6d) Documented function signatures are useful for dynamically typed languages. (@chbrown)
-
-### 0.6.0 (2013/06/25 08:48 +00:00)
-- [d37bfe0](https://github.com/bcoe/yargs/commit/d37bfe05ae6d295a0ab481efe4881222412791f4) all tests passing using minimist (@substack)
-- [76f1352](https://github.com/bcoe/yargs/commit/76f135270399d01f2bbc621e524a5966e5c422fd) all parse tests now passing (@substack)
-- [a7b6754](https://github.com/bcoe/yargs/commit/a7b6754276c38d1565479a5685c3781aeb947816) using minimist, some tests passing (@substack)
-- [6655688](https://github.com/bcoe/yargs/commit/66556882aa731cbbbe16cc4d42c85740a2e98099) Give credit where its due (@DeadAlready)
-- [602a2a9](https://github.com/bcoe/yargs/commit/602a2a92a459f93704794ad51b115bbb08b535ce) v0.5.3 - Remove wordwrap as dependency (@DeadAlready)
-
-### 0.5.2 (2013/05/31 03:46 +00:00)
-- [4497ca5](https://github.com/bcoe/yargs/commit/4497ca55e332760a37b866ec119ded347ca27a87) fixed the whitespace bug without breaking anything else (@substack)
-- [5a3dd1a](https://github.com/bcoe/yargs/commit/5a3dd1a4e0211a38613c6e02f61328e1031953fa) failing test for whitespace arg (@substack)
-
-### 0.5.1 (2013/05/30 07:17 +00:00)
-- [a20228f](https://github.com/bcoe/yargs/commit/a20228f62a454755dd07f628a7c5759113918327) fix parse() to work with functions before it (@substack)
-- [b13bd4c](https://github.com/bcoe/yargs/commit/b13bd4cac856a9821d42fa173bdb58f089365a7d) failing test for parse() with modifiers (@substack)
-
-### 0.5.0 (2013/05/18 21:59 +00:00)
-- [c474a64](https://github.com/bcoe/yargs/commit/c474a649231527915c222156e3b40806d365a87c) fixes for dash (@substack)
-
-### 0.4.0 (2013/04/13 19:03 +00:00)
-- [dafe3e1](https://github.com/bcoe/yargs/commit/dafe3e18d7c6e7c2d68e06559df0e5cbea3adb14) failing short test (@substack)
-
-### 0.3.7 (2013/04/04 04:07 +00:00)
-- [6c7a0ec](https://github.com/bcoe/yargs/commit/6c7a0ec94ce4199a505f0518b4d6635d4e47cc81) Fix for windows. On windows there is no _ in environment. (@hdf)
-
-### 0.3.6 (2013/04/04 04:04 +00:00)
-- [e72346a](https://github.com/bcoe/yargs/commit/e72346a727b7267af5aa008b418db89970873f05) Add support for newlines in -a="" arguments (@danielbeardsley)
-- [71e1fb5](https://github.com/bcoe/yargs/commit/71e1fb55ea9987110a669ac6ec12338cfff3821c) drop 0.4, add 0.8 to travis (@substack)
-
-### 0.3.5 (2012/10/10 11:09 +00:00)
-- [ee692b3](https://github.com/bcoe/yargs/commit/ee692b37554c70a0bb16389a50a26b66745cbbea) Fix parsing booleans (@vojtajina)
-- [5045122](https://github.com/bcoe/yargs/commit/5045122664c3f5b4805addf1be2148d5856f7ce8) set $0 properly in the tests (@substack)
-
-### 0.3.4 (2012/04/30 06:54 +00:00)
-- [f28c0e6](https://github.com/bcoe/yargs/commit/f28c0e62ca94f6e0bb2e6d82fc3d91a55e69b903) bump for string "true" params (@substack)
-- [8f44aeb](https://github.com/bcoe/yargs/commit/8f44aeb74121ddd689580e2bf74ef86a605e9bf2) Fix failing test for aliased booleans. (@coderarity)
-- [b9f7b61](https://github.com/bcoe/yargs/commit/b9f7b613b1e68e11e6c23fbda9e555a517dcc976) Add failing test for short aliased booleans. (@coderarity)
-
-### 0.3.3 (2012/04/30 06:45 +00:00)
-- [541bac8](https://github.com/bcoe/yargs/commit/541bac8dd787a5f1a5d28f6d8deb1627871705e7) Fixes #37.
-
-### 0.3.2 (2012/04/12 20:28 +00:00)
-- [3a0f014](https://github.com/bcoe/yargs/commit/3a0f014c1451280ac1c9caa1f639d31675586eec) travis badge (@substack)
-- [4fb60bf](https://github.com/bcoe/yargs/commit/4fb60bf17845f4ce3293f8ca49c9a1a7c736cfce) Fix boolean aliases. (@coderarity)
-- [f14dda5](https://github.com/bcoe/yargs/commit/f14dda546efc4fe06ace04d36919bfbb7634f79b) Adjusted package.json to use tap (@jfhbrook)
-- [88e5d32](https://github.com/bcoe/yargs/commit/88e5d32295be6e544c8d355ff84e355af38a1c74) test/usage.js no longer hangs (@jfhbrook)
-- [e1e740c](https://github.com/bcoe/yargs/commit/e1e740c27082f3ce84deca2093d9db2ef735d0e5) two tests for combined boolean/alias opts parsing (@jfhbrook)
-
-### 0.3.1 (2011/12/31 08:44 +00:00)
-- [d09b719](https://github.com/bcoe/yargs/commit/d09b71980ef711b6cf3918cd19beec8257e40e82) If "default" is set to false it was not passed on, fixed. (@wolframkriesing)
-
-### 0.3.0 (2011/12/09 06:03 +00:00)
-- [6e74aa7](https://github.com/bcoe/yargs/commit/6e74aa7b46a65773e20c0cb68d2d336d4a0d553d) bump and documented dot notation (@substack)
-
-### 0.2.7 (2011/10/20 02:25 +00:00)
-- [94adee2](https://github.com/bcoe/yargs/commit/94adee20e17b58d0836f80e8b9cdbe9813800916) argv._ can be told 'Hey! argv._! Don't be messing with my args.', and it WILL obey (@colinta)
-- [c46fdd5](https://github.com/bcoe/yargs/commit/c46fdd56a05410ae4a1e724a4820c82e77ff5469) optimistic critter image (@substack)
-- [5c95c73](https://github.com/bcoe/yargs/commit/5c95c73aedf4c7482bd423e10c545e86d7c8a125) alias options() to option() (@substack)
-- [f7692ea](https://github.com/bcoe/yargs/commit/f7692ea8da342850af819367833abb685fde41d8) [fix] Fix for parsing boolean edge case (@indexzero)
-- [d1f92d1](https://github.com/bcoe/yargs/commit/d1f92d1425bd7f356055e78621b30cdf9741a3c2)
-- [b01bda8](https://github.com/bcoe/yargs/commit/b01bda8d86e455bbf74ce497864cb8ab5b9fb847) [fix test] Update to ensure optimist is aware of default booleans. Associated tests included (@indexzero)
-- [aa753e7](https://github.com/bcoe/yargs/commit/aa753e7c54fb3a12f513769a0ff6d54aa0f63943) [dist test] Update devDependencies in package.json. Update test pathing to be more npm and require.paths future-proof (@indexzero)
-- [7bfce2f](https://github.com/bcoe/yargs/commit/7bfce2f3b3c98e6539e7549d35fbabced7e9341e) s/sys/util/ (@substack)
-- [d420a7a](https://github.com/bcoe/yargs/commit/d420a7a9c890d2cdb11acfaf3ea3f43bc3e39f41) update usage output (@substack)
-- [cf86eed](https://github.com/bcoe/yargs/commit/cf86eede2e5fc7495b6ec15e6d137d9ac814f075) some sage readme protips about parsing rules (@substack)
-- [5da9f7a](https://github.com/bcoe/yargs/commit/5da9f7a5c0e1758ec7c5801fb3e94d3f6e970513) documented all the methods finally (@substack)
-- [8ca6879](https://github.com/bcoe/yargs/commit/8ca6879311224b25933642987300f6a29de5c21b) fenced syntax highlighting (@substack)
-- [b72bacf](https://github.com/bcoe/yargs/commit/b72bacf1d02594778c1935405bc8137eb61761dc) right-alignment of wrapped extra params (@substack)
-- [2b980bf](https://github.com/bcoe/yargs/commit/2b980bf2656b4ee8fc5134dc5f56a48855c35198) now with .wrap() (@substack)
-- [d614f63](https://github.com/bcoe/yargs/commit/d614f639654057d1b7e35e3f5a306e88ec2ad1e4) don't show 'Options:' when there aren't any (@substack)
-- [691eda3](https://github.com/bcoe/yargs/commit/691eda354df97b5a86168317abcbcaabdc08a0fb) failing test for multi-aliasing (@substack)
-- [0826c9f](https://github.com/bcoe/yargs/commit/0826c9f462109feab2bc7a99346d22e72bf774b7) "Options:" > "options:" (@substack)
-- [72f7490](https://github.com/bcoe/yargs/commit/72f749025d01b7f295738ed370a669d885fbada0) [minor] Update formatting for `.showHelp()` (@indexzero)
-- [75aecce](https://github.com/bcoe/yargs/commit/75aeccea74329094072f95800e02c275e7d999aa) options works again, too lazy to write a proper test right now (@substack)
-- [f742e54](https://github.com/bcoe/yargs/commit/f742e5439817c662dc3bd8734ddd6467e6018cfd) line_count_options example, which breaks (@substack)
-- [4ca06b8](https://github.com/bcoe/yargs/commit/4ca06b8b4ea99b5d5714b315a2a8576bee6e5537) line count example (@substack)
-- [eeb8423](https://github.com/bcoe/yargs/commit/eeb8423e0a5ecc9dc3eb1e6df9f3f8c1c88f920b) remove self.argv setting in boolean (@substack)
-- [6903412](https://github.com/bcoe/yargs/commit/69034126804660af9cc20ea7f4457b50338ee3d7) removed camel case for now (@substack)
-- [5a0d88b](https://github.com/bcoe/yargs/commit/5a0d88bf23e9fa79635dd034e2a1aa992acc83cd) remove dead longest checking code (@substack)
-- [d782170](https://github.com/bcoe/yargs/commit/d782170babf7284b1aa34f5350df0dd49c373fa8) .help() too (@substack)
-- [622ec17](https://github.com/bcoe/yargs/commit/622ec17379bb5374fdbb190404c82bc600975791) rm old help generator (@substack)
-- [7c8baac](https://github.com/bcoe/yargs/commit/7c8baac4d66195e9f5158503ea9ebfb61153dab7) nub keys (@substack)
-- [8197785](https://github.com/bcoe/yargs/commit/8197785ad4762465084485b041abd722f69bf344) generate help message based on the previous calls, todo: nub (@substack)
-- [3ffbdc3](https://github.com/bcoe/yargs/commit/3ffbdc33c8f5e83d4ea2ac60575ce119570c7ede) stub out new showHelp, better checks (@substack)
-- [d4e21f5](https://github.com/bcoe/yargs/commit/d4e21f56a4830f7de841900d3c79756fb9886184) let .options() take single options too (@substack)
-- [3c4cf29](https://github.com/bcoe/yargs/commit/3c4cf2901a29bac119cca8e983028d8669230ec6) .options() is now heaps simpler (@substack)
-- [89f0d04](https://github.com/bcoe/yargs/commit/89f0d043cbccd302f10ab30c2069e05d2bf817c9) defaults work again, all tests pass (@substack)
-- [dd87333](https://github.com/bcoe/yargs/commit/dd8733365423006a6e4156372ebb55f98323af58) update test error messages, down to 2 failing tests (@substack)
-- [53f7bc6](https://github.com/bcoe/yargs/commit/53f7bc626b9875f2abdfc5dd7a80bde7f14143a3) fix for bools doubling up, passes the parse test again, others fail (@substack)
-- [2213e2d](https://github.com/bcoe/yargs/commit/2213e2ddc7263226fba717fb041dc3fde9bc2ee4) refactored for an argv getter, failing several tests (@substack)
-- [d1e7379](https://github.com/bcoe/yargs/commit/d1e737970f15c6c006bebdd8917706827ff2f0f2) just rescan for now, alias test passes (@substack)
-- [b2f8c99](https://github.com/bcoe/yargs/commit/b2f8c99cc477a8eb0fdf4cf178e1785b63185cfd) failing alias test (@substack)
-- [d0c0174](https://github.com/bcoe/yargs/commit/d0c0174daa144bfb6dc7290fdc448c393c475e15) .alias() (@substack)
-- [d85f431](https://github.com/bcoe/yargs/commit/d85f431ad7d07b058af3f2a57daa51495576c164) [api] Remove `.describe()` in favor of building upon the existing `.usage()` API (@indexzero)
-- [edbd527](https://github.com/bcoe/yargs/commit/edbd5272a8e213e71acd802782135c7f9699913a) [doc api] Add `.describe()`, `.options()`, and `.showHelp()` methods along with example. (@indexzero)
-- [be4902f](https://github.com/bcoe/yargs/commit/be4902ff0961ae8feb9093f2c0a4066463ded2cf) updates for coffee since it now does argv the node way (@substack)
-- [e24cb23](https://github.com/bcoe/yargs/commit/e24cb23798ee64e53b60815e7fda78b87f42390c) more general coffeescript detection (@substack)
-- [78ac753](https://github.com/bcoe/yargs/commit/78ac753e5d0ec32a96d39d893272afe989e42a4d) Don't trigger the CoffeeScript hack when running under node_g. (@papandreou)
-- [bcfe973](https://github.com/bcoe/yargs/commit/bcfe9731d7f90d4632281b8a52e8d76eb0195ae6) .string() but failing test (@substack)
-- [1987aca](https://github.com/bcoe/yargs/commit/1987aca28c7ba4e8796c07bbc547cb984804c826) test hex strings (@substack)
-- [ef36db3](https://github.com/bcoe/yargs/commit/ef36db32259b0b0d62448dc907c760e5554fb7e7) more keywords (@substack)
-- [cc53c56](https://github.com/bcoe/yargs/commit/cc53c56329960bed6ab077a79798e991711ba01d) Added camelCase function that converts --multi-word-option to camel case (so it becomes argv.multiWordOption). (@papandreou)
-- [60b57da](https://github.com/bcoe/yargs/commit/60b57da36797716e5783a633c6d5c79099016d45) fixed boolean bug by rescanning (@substack)
-- [dff6d07](https://github.com/bcoe/yargs/commit/dff6d078d97f8ac503c7d18dcc7b7a8c364c2883) boolean examples (@substack)
-- [0e380b9](https://github.com/bcoe/yargs/commit/0e380b92c4ef4e3c8dac1da18b5c31d85b1d02c9) boolean() with passing test (@substack)
-- [62644d4](https://github.com/bcoe/yargs/commit/62644d4bffbb8d1bbf0c2baf58a1d14a6359ef07) coffee compatibility with node regex for versions too (@substack)
-- [430fafc](https://github.com/bcoe/yargs/commit/430fafcf1683d23774772826581acff84b456827) argv._ fixed by fixing the coffee detection (@substack)
-- [343b8af](https://github.com/bcoe/yargs/commit/343b8afefd98af274ebe21b5a16b3a949ec5429f) whichNodeArgs test fails too (@substack)
-- [63df2f3](https://github.com/bcoe/yargs/commit/63df2f371f31e63d7f1dec2cbf0022a5f08da9d2) replicated mnot's bug in whichNodeEmpty test (@substack)
-- [35473a4](https://github.com/bcoe/yargs/commit/35473a4d93a45e5e7e512af8bb54ebb532997ae1) test for ./bin usage (@substack)
-- [13df151](https://github.com/bcoe/yargs/commit/13df151e44228eed10e5441c7cd163e086c458a4) don't coerce booleans to numbers (@substack)
-- [85f8007](https://github.com/bcoe/yargs/commit/85f8007e93b8be7124feea64b1f1916d8ba1894a) package bump for automatic number conversion (@substack)
-- [8f17014](https://github.com/bcoe/yargs/commit/8f170141cded4ccc0c6d67a849c5bf996aa29643) updated readme and examples with new auto-numberification goodness (@substack)
-- [73dc901](https://github.com/bcoe/yargs/commit/73dc9011ac968e39b55e19e916084a839391b506) auto number conversion works yay (@substack)
-- [bcec56b](https://github.com/bcoe/yargs/commit/bcec56b3d031e018064cbb691539ccc4f28c14ad) failing test for not-implemented auto numification (@substack)
-- [ebd2844](https://github.com/bcoe/yargs/commit/ebd2844d683feeac583df79af0e5124a7a7db04e) odd that eql doesn't check types careflly (@substack)
-- [fd854b0](https://github.com/bcoe/yargs/commit/fd854b02e512ce854b76386d395672a7969c1bc4) package author + keywords (@substack)
-- [656a1d5](https://github.com/bcoe/yargs/commit/656a1d5a1b7c0e49d72e80cb13f20671d56f76c6) updated readme with .default() stuff (@substack)
-- [cd7f8c5](https://github.com/bcoe/yargs/commit/cd7f8c55f0b82b79b690d14c5f806851236998a1) passing tests for new .default() behavior (@substack)
-- [932725e](https://github.com/bcoe/yargs/commit/932725e39ce65bc91a0385a5fab659a5fa976ac2) new default() thing for setting default key/values (@substack)
-- [4e6c7ab](https://github.com/bcoe/yargs/commit/4e6c7aba6374ac9ebc6259ecf91f13af7bce40e3) test for coffee usage (@substack)
-- [d54ffcc](https://github.com/bcoe/yargs/commit/d54ffccf2a5a905f51ed5108f7c647f35d64ae23) new --key value style with passing tests. NOTE: changes existing behavior (@substack)
-- [ed2a2d5](https://github.com/bcoe/yargs/commit/ed2a2d5d828100ebeef6385c0fb88d146a5cfe9b) package bump for summatix's coffee script fix (@substack)
-- [75a975e](https://github.com/bcoe/yargs/commit/75a975eed8430d28e2a79dc9e6d819ad545f4587) Added support for CoffeeScript (@summatix)
-- [56b2b1d](https://github.com/bcoe/yargs/commit/56b2b1de8d11f8a2b91979d8ae2d6db02d8fe64d) test coverage for the falsy check() usage (@substack)
-- [a4843a9](https://github.com/bcoe/yargs/commit/a4843a9f0e69ffb4afdf6a671d89eb6f218be35d) check bug fixed plus a handy string (@substack)
-- [857bd2d](https://github.com/bcoe/yargs/commit/857bd2db933a5aaa9cfecba0ced2dc9b415f8111) tests for demandCount, back up to 100% coverage (@substack)
-- [073b776](https://github.com/bcoe/yargs/commit/073b7768ebd781668ef05c13f9003aceca2f5c35) call demandCount from demand (@substack)
-- [4bd4b7a](https://github.com/bcoe/yargs/commit/4bd4b7a085c8b6ce1d885a0f486cc9865cee2db1) add demandCount to check for the number of arguments in the _ list (@marshall)
-- [b8689ac](https://github.com/bcoe/yargs/commit/b8689ac68dacf248119d242bba39a41cb0adfa07) Rebase checks. That will be its own module eventually. (@substack)
-- [e688370](https://github.com/bcoe/yargs/commit/e688370b576f0aa733c3f46183df69e1b561668e) a $0 like in perl (@substack)
-- [2e5e196](https://github.com/bcoe/yargs/commit/2e5e1960fc19afb21fb3293752316eaa8bcd3609) usage test hacking around process and console (@substack)
-- [fcc3521](https://github.com/bcoe/yargs/commit/fcc352163fbec6a1dfe8caf47a0df39de24fe016) description pun (@substack)
-- [87a1fe2](https://github.com/bcoe/yargs/commit/87a1fe29037ca2ca5fefda85141aaeb13e8ce761) mit/x11 license (@substack)
-- [8d089d2](https://github.com/bcoe/yargs/commit/8d089d24cd687c0bde3640a96c09b78f884900dd) bool example is more consistent and also shows off short option grouping (@substack)
-- [448d747](https://github.com/bcoe/yargs/commit/448d7473ac68e8e03d8befc9457b0d9e21725be0) start of the readme and examples (@substack)
-- [da74dea](https://github.com/bcoe/yargs/commit/da74dea799a9b59dbf022cbb8001bfdb0d52eec9) more tests for long and short captures (@substack)
-- [ab6387e](https://github.com/bcoe/yargs/commit/ab6387e6769ca4af82ca94c4c67c7319f0d9fcfa) silly bug in the tests with s/not/no/, all tests pass now (@substack)
-- [102496a](https://github.com/bcoe/yargs/commit/102496a319e8e06f6550d828fc2f72992c7d9ecc) hack an instance for process.argv onto Argv so the export can be called to create an instance or used for argv, which is the most common case (@substack)
-- [a01caeb](https://github.com/bcoe/yargs/commit/a01caeb532546d19f68f2b2b87f7036cfe1aaedd) divide example (@substack)
-- [443da55](https://github.com/bcoe/yargs/commit/443da55736acbaf8ff8b04d1b9ce19ab016ddda2) start of the lib with a package.json (@substack)
diff --git a/node_modules/uglify-js/node_modules/yargs/LICENSE b/node_modules/uglify-js/node_modules/yargs/LICENSE
deleted file mode 100644
index 432d1aeb0..000000000
--- a/node_modules/uglify-js/node_modules/yargs/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-Copyright 2010 James Halliday (mail@substack.net)
-
-This project is free software released under the MIT/X11 license:
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/node_modules/uglify-js/node_modules/yargs/README.md b/node_modules/uglify-js/node_modules/yargs/README.md
deleted file mode 100644
index 99086e6e9..000000000
--- a/node_modules/uglify-js/node_modules/yargs/README.md
+++ /dev/null
@@ -1,926 +0,0 @@
-yargs
-========
-
-Yargs be a node.js library fer hearties tryin' ter parse optstrings.
-
-With yargs, ye be havin' a map that leads straight to yer treasure! Treasure of course, being a simple option hash.
-
-[![Build Status](https://travis-ci.org/bcoe/yargs.png)](https://travis-ci.org/bcoe/yargs)
-[![Dependency Status](https://gemnasium.com/bcoe/yargs.png)](https://gemnasium.com/bcoe/yargs)
-[![Coverage Status](https://coveralls.io/repos/bcoe/yargs/badge.svg?branch=)](https://coveralls.io/r/bcoe/yargs?branch=)
-[![NPM version](https://img.shields.io/npm/v/yargs.svg)](https://www.npmjs.com/package/yargs)
-
-> Yargs is the official successor to optimist. Please feel free to submit issues and pull requests. If you'd like to contribute and don't know where to start, have a look at [the issue list](https://github.com/bcoe/yargs/issues) :)
-
-examples
-========
-
-With yargs, the options be just a hash!
--------------------------------------------------------------------
-
-plunder.js:
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs').argv;
-
-if (argv.ships > 3 && argv.distance < 53.5) {
-    console.log('Plunder more riffiwobbles!');
-}
-else {
-    console.log('Retreat from the xupptumblers!');
-}
-````
-
-***
-
-    $ ./plunder.js --ships=4 --distance=22
-    Plunder more riffiwobbles!
-
-    $ ./plunder.js --ships 12 --distance 98.7
-    Retreat from the xupptumblers!
-
-![Joe was one optimistic pirate.](http://i.imgur.com/4WFGVJ9.png)
-
-But don't walk the plank just yet! There be more! You can do short options:
--------------------------------------------------
-
-short.js:
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs').argv;
-console.log('(%d,%d)', argv.x, argv.y);
-````
-
-***
-
-    $ ./short.js -x 10 -y 21
-    (10,21)
-
-And booleans, both long, short, and even grouped:
-----------------------------------
-
-bool.js:
-
-````javascript
-#!/usr/bin/env node
-var util = require('util');
-var argv = require('yargs').argv;
-
-if (argv.s) {
-    util.print(argv.fr ? 'Le perroquet dit: ' : 'The parrot says: ');
-}
-console.log(
-    (argv.fr ? 'couac' : 'squawk') + (argv.p ? '!' : '')
-);
-````
-
-***
-
-    $ ./bool.js -s
-    The parrot says: squawk
-
-    $ ./bool.js -sp
-    The parrot says: squawk!
-
-    $ ./bool.js -sp --fr
-    Le perroquet dit: couac!
-
-And non-hyphenated options too! Just use `argv._`!
--------------------------------------------------
-
-nonopt.js:
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs').argv;
-console.log('(%d,%d)', argv.x, argv.y);
-console.log(argv._);
-````
-
-***
-
-    $ ./nonopt.js -x 6.82 -y 3.35 rum
-    (6.82,3.35)
-    [ 'rum' ]
-
-    $ ./nonopt.js "me hearties" -x 0.54 yo -y 1.12 ho
-    (0.54,1.12)
-    [ 'me hearties', 'yo', 'ho' ]
-
-Yargs even counts your booleans!
-----------------------------------------------------------------------
-
-count.js
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs')
-    .count('verbose')
-    .alias('v', 'verbose')
-    .argv;
-
-VERBOSE_LEVEL = argv.verbose;
-
-function WARN()  { VERBOSE_LEVEL >= 0 && console.log.apply(console, arguments); }
-function INFO()  { VERBOSE_LEVEL >= 1 && console.log.apply(console, arguments); }
-function DEBUG() { VERBOSE_LEVEL >= 2 && console.log.apply(console, arguments); }
-
-WARN("Showing only important stuff");
-INFO("Showing semi-mportant stuff too");
-DEBUG("Extra chatty mode");
-````
-
-***
-    $ node count.js
-    Showing only important stuff
-
-    $ node count.js -v
-    Showing only important stuff
-    Showing semi-important stuff too
-
-    $ node count.js -vv
-    Showing only important stuff
-    Showing semi-important stuff too
-    Extra chatty mode
-
-    $ node count.js -v --verbose
-    Showing only important stuff
-    Showing semi-important stuff too
-    Extra chatty mode
-
-Tell users how to use yer options and make demands.
--------------------------------------------------
-
-area.js:
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs')
-    .usage('Usage: $0 -w [num] -yh[num]')
-    .demand(['w','h'])
-    .argv;
-
-console.log("The area is:", argv.w * argv.h);
-````
-
-***
-
-    $ ./area.js -w 55 -h 11
-    605
-
-    $ node ./area.js -w 4.91 -w 2.51
-    Usage: node ./area.js -w [num] -h [num]
-
-    Options:
-      -w  [required]
-      -h  [required]
-
-    Missing required arguments: h
-
-After yer demands have been met, demand more! Ask for non-hypenated arguments!
------------------------------------------
-
-demand_count.js:
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs')
-    .demand(2)
-    .argv;
-console.dir(argv)
-````
-
-***
-
-	$ ./demand_count.js a
-	Not enough arguments, expected 2, but only found 1
-	$ ./demand_count.js a b
-	{ _: [ 'a', 'b' ], '$0': 'node ./demand_count.js' }
-	$ ./demand_count.js a b c
-	{ _: [ 'a', 'b', 'c' ], '$0': 'node ./demand_count.js' }
-
-EVEN MORE SHIVER ME TIMBERS!
-------------------
-
-default_singles.js:
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs')
-    .default('x', 10)
-    .default('y', 10)
-    .argv
-;
-console.log(argv.x + argv.y);
-````
-
-***
-
-    $ ./default_singles.js -x 5
-    15
-
-default_hash.js:
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs')
-    .default({ x : 10, y : 10 })
-    .argv
-;
-console.log(argv.x + argv.y);
-````
-
-***
-
-    $ ./default_hash.js -y 7
-    17
-
-And if you really want to get all descriptive about it...
----------------------------------------------------------
-
-boolean_single.js
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs')
-    .boolean('v')
-    .argv
-;
-console.dir(argv.v);
-console.dir(argv._);
-````
-
-***
-
-    $ ./boolean_single.js -v "me hearties" yo ho
-    true
-    [ 'me hearties', 'yo', 'ho' ]
-
-
-boolean_double.js
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs')
-    .boolean(['x','y','z'])
-    .argv
-;
-console.dir([ argv.x, argv.y, argv.z ]);
-console.dir(argv._);
-````
-
-***
-
-    $ ./boolean_double.js -x -z one two three
-    [ true, false, true ]
-    [ 'one', 'two', 'three' ]
-
-Yargs is here to help you...
----------------------------
-
-Ye can describe parameters fer help messages and set aliases. Yargs figures
-out how ter format a handy help string automatically.
-
-line_count.js
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs')
-    .usage('Usage: $0 <command> [options]')
-    .command('count', 'Count the lines in a file')
-    .demand(1)
-    .example('$0 count -f foo.js', 'count the lines in the given file')
-    .demand('f')
-    .alias('f', 'file')
-    .nargs('f', 1)
-    .describe('f', 'Load a file')
-    .help('h')
-    .alias('h', 'help')
-    .epilog('copyright 2015')
-    .argv;
-
-var fs = require('fs');
-var s = fs.createReadStream(argv.file);
-
-var lines = 0;
-s.on('data', function (buf) {
-    lines += buf.toString().match(/\n/g).length;
-});
-
-s.on('end', function () {
-    console.log(lines);
-});
-````
-
-***
-    $ node line_count.js count
-    Usage: node test.js <command> [options]
-
-    Commands:
-      count    Count the lines in a file
-
-    Options:
-      -f, --file  Load a file        [required]
-      -h, --help  Show help
-
-    Examples:
-      node test.js count -f foo.js    count the lines in the given file
-
-    copyright 2015
-
-    Missing required arguments: f
-
-    $ node line_count.js count --file line_count.js
-    20
-
-    $ node line_count.js count -f line_count.js
-    20
-
-methods
-=======
-
-By itself,
-
-````javascript
-require('yargs').argv
-`````
-
-will use `process.argv` array to construct the `argv` object.
-
-You can pass in the `process.argv` yourself:
-
-````javascript
-require('yargs')([ '-x', '1', '-y', '2' ]).argv
-````
-
-or use .parse() to do the same thing:
-
-````javascript
-require('yargs').parse([ '-x', '1', '-y', '2' ])
-````
-
-The rest of these methods below come in just before the terminating `.argv`.
-
-.alias(key, alias)
-------------------
-
-Set key names as equivalent such that updates to a key will propagate to aliases
-and vice-versa.
-
-Optionally `.alias()` can take an object that maps keys to aliases.
-Each key of this object should be the canonical version of the option, and each
-value should be a string or an array of strings.
-
-.default(key, value, [description])
---------------------
-
-Set `argv[key]` to `value` if no option was specified on `process.argv`.
-
-Optionally `.default()` can take an object that maps keys to default values.
-
-But wait, there's more! the default value can be a `function` which returns
-a value. The name of the function will be used in the usage string:
-
-```js
-var argv = require('yargs')
-  .default('random', function randomValue() {
-    return Math.random() * 256;
-  }).argv;
-```
-
-Optionally, `description` can also be provided and will take precedence over
-displaying the value in the usage instructions:
-
-```js
-.default('timeout', 60000, '(one-minute)');
-```
-
-.demand(key, [msg | boolean])
------------------------------
-.require(key, [msg | boolean])
-------------------------------
-.required(key, [msg | boolean])
--------------------------------
-
-If `key` is a string, show the usage information and exit if `key` wasn't
-specified in `process.argv`.
-
-If `key` is a number, demand at least as many non-option arguments, which show
-up in `argv._`.
-
-If `key` is an Array, demand each element.
-
-If a `msg` string is given, it will be printed when the argument is missing,
-instead of the standard error message. This is especially helpful for the non-option arguments in `argv._`.
-
-If a `boolean` value is given, it controls whether the option is demanded;
-this is useful when using `.options()` to specify command line parameters.
-
-.requiresArg(key)
------------------
-
-Specifies either a single option key (string), or an array of options that
-must be followed by option values. If any option value is missing, show the
-usage information and exit.
-
-The default behaviour is to set the value of any key not followed by an
-option value to `true`.
-
-.implies(x, y)
---------------
-
-Given the key `x` is set, it is required that the key `y` is set.
-
-implies can also accept an object specifying multiple implications.
-
-.describe(key, desc)
---------------------
-
-Describe a `key` for the generated usage information.
-
-Optionally `.describe()` can take an object that maps keys to descriptions.
-
-.option(key, opt)
------------------
-.options(key, opt)
-------------------
-
-Instead of chaining together `.alias().demand().default().describe().string()`, you can specify
-keys in `opt` for each of the chainable methods.
-
-For example:
-
-````javascript
-var argv = require('yargs')
-    .option('f', {
-        alias : 'file',
-        demand: true,
-        default: '/etc/passwd',
-        describe: 'x marks the spot',
-        type: 'string'
-    })
-    .argv
-;
-````
-
-is the same as
-
-````javascript
-var argv = require('yargs')
-    .alias('f', 'file')
-    .default('f', '/etc/passwd')
-    .argv
-;
-````
-
-Optionally `.options()` can take an object that maps keys to `opt` parameters.
-
-````javascript
-var argv = require('yargs')
-    .options({
-      'f': {
-        alias: 'file',
-        demand: true,
-        default: '/etc/passwd',
-        describe: 'x marks the spot',
-        type: 'string'
-      }
-    })
-    .argv
-;
-````
-
-.usage(message, opts)
----------------------
-
-Set a usage message to show which commands to use. Inside `message`, the string
-`$0` will get interpolated to the current script name or node command for the
-present script similar to how `$0` works in bash or perl.
-
-`opts` is optional and acts like calling `.options(opts)`.
-
-.command(cmd, desc, [fn])
--------------------
-
-Document the commands exposed by your application.
-
-use `desc` to provide a description for each command your application accepts (the
-values stored in `argv._`).
-
-Optionally, you can provide a handler `fn` which will be executed when
-a given command is provided. The handler will be executed with an instance
-of `yargs`, which can be used to compose nested commands.
-
-Here's an example of top-level and nested commands in action:
-
-```js
-var argv = require('yargs')
-  .usage('npm <command>')
-  .command('install', 'tis a mighty fine package to install')
-  .command('publish', 'shiver me timbers, should you be sharing all that', function (yargs) {
-    argv = yargs.option('f', {
-      alias: 'force',
-      description: 'yar, it usually be a bad idea'
-    })
-    .help('help')
-    .argv
-  })
-  .help('help')
-  .argv;
-```
-
-.example(cmd, desc)
--------------------
-
-Give some example invocations of your program. Inside `cmd`, the string
-`$0` will get interpolated to the current script name or node command for the
-present script similar to how `$0` works in bash or perl.
-Examples will be printed out as part of the help message.
-
-
-.epilogue(str)
---------------
-.epilog(str)
-------------
-
-A message to print at the end of the usage instructions, e.g.,
-
-```js
-var argv = require('yargs')
-  .epilogue('for more information, find our manual at http://example.com');
-```
-
-.check(fn)
-----------
-
-Check that certain conditions are met in the provided arguments.
-
-`fn` is called with two arguments, the parsed `argv` hash and an array of options and their aliases.
-
-If `fn` throws or returns a non-truthy value, show the thrown error, usage information, and
-exit.
-
-.fail(fn)
----------
-
-Method to execute when a failure occurs, rather then printing the failure message.
-
-`fn` is called with the failure message that would have been printed.
-
-.boolean(key)
--------------
-
-Interpret `key` as a boolean. If a non-flag option follows `key` in
-`process.argv`, that string won't get set as the value of `key`.
-
-`key` will default to `false`, unless an `default(key, undefined)` is
-explicitly set.
-
-If `key` is an Array, interpret all the elements as booleans.
-
-.string(key)
-------------
-
-Tell the parser logic not to interpret `key` as a number or boolean.
-This can be useful if you need to preserve leading zeros in an input.
-
-If `key` is an Array, interpret all the elements as strings.
-
-`.string('_')` will result in non-hyphenated arguments being interpreted as strings,
-regardless of whether they resemble numbers.
-
-.array(key)
-----------
-
-Tell the parser to interpret `key` as an array. If `.array('foo')` is set,
-`--foo foo bar` will be parsed as `['foo', 'bar']` rather than as `'bar'`.
-
-.nargs(key, count)
------------
-
-The number of arguments that should be consumed after a key. This can be a
-useful hint to prevent parsing ambiguity:
-
-```js
-var argv = require('yargs')
-  .nargs('token', 1)
-  .parse(['--token', '-my-token']);
-```
-
-parses as:
-
-`{ _: [], token: '-my-token', '$0': 'node test' }`
-
-Optionally `.nargs()` can take an object of `key`/`narg` pairs.
-
-.config(key)
-------------
-
-Tells the parser that if the option specified by `key` is passed in, it
-should be interpreted as a path to a JSON config file. The file is loaded
-and parsed, and its properties are set as arguments.
-
-.wrap(columns)
---------------
-
-Format usage output to wrap at `columns` many columns.
-
-By default wrap will be set to `Math.min(80, windowWidth)`. Use `.wrap(null)` to
-specify no column limit.
-
-`yargs.wrap(yargs.terminalWidth())` can be used to maximize the width
-of yargs' usage instructions.
-
-.strict()
----------
-
-Any command-line argument given that is not demanded, or does not have a
-corresponding description, will be reported as an error.
-
-.help([option, [description]])
-------------------------------
-
-Add an option (e.g., `--help`) that displays the usage string and exits the
-process. If present, the `description` parameter customises the description of
-the help option in the usage string.
-
-If invoked without parameters, `.help` returns the generated usage string.
-
-Example:
-
-```
-var yargs = require("yargs")
-       .usage("$0 -operand1 number -operand2 number -operation [add|subtract]");
-console.log(yargs.help());
-```
-
-Later on, ```argv``` can be retrived with ```yargs.argv```
-
-.version(version, [option], [description])
-----------------------------------------
-
-Add an option (e.g., `--version`) that displays the version number (given by the
-`version` parameter) and exits the process. If present, the `description`
-parameter customizes the description of the version option in the usage string.
-
-You can provide a `function` for version, rather than a string.
-This is useful if you want to use the version from your package.json:
-
-```js
-var argv = require('yargs')
-  .version(function() {
-    return require('../package').version;
-  })
-  .argv;
-```
-
-.showHelpOnFail(enable, [message])
-----------------------------------
-
-By default, yargs outputs a usage string if any error is detected. Use the
-`.showHelpOnFail` method to customize this behaviour. if `enable` is `false`,
-the usage string is not output. If the `message` parameter is present, this
-message is output after the error message.
-
-line_count.js
-
-````javascript
-#!/usr/bin/env node
-var argv = require('yargs')
-    .usage('Count the lines in a file.\nUsage: $0')
-    .demand('f')
-    .alias('f', 'file')
-    .describe('f', 'Load a file')
-    .showHelpOnFail(false, "Specify --help for available options")
-    .argv;
-
-// etc.
-````
-
-***
-
-    $ node line_count.js --file
-    Missing argument value: f
-
-    Specify --help for available options
-
-.showHelp(consoleLevel='error')
----------------------------
-
-Print the usage data using the [`console`](https://nodejs.org/api/console.html) function `consoleLevel` for printing.
-
-Example:
-
-```
-var yargs = require("yargs")
-       .usage("$0 -operand1 number -operand2 number -operation [add|subtract]");
-yargs.showHelp();
-```
-
-Or, to print the usage data to `stdout` instead, you can specify the use of `console.log`:
-
-```
-yargs.showHelp("log");
-```
-
-Later on, ```argv``` can be retrived with ```yargs.argv```
-
-.completion(cmd, [description], [fn]);
--------------
-
-Enable bash-completion shortcuts for commands and options.
-
-`cmd`: when present in `argv._`, will result in the `.bashrc` completion script
-being outputted. To enable bash completions, concat the generated script to your
-`.bashrc`, or `.bash_profile`.
-
-`description`: provide a description in your usage instructions for the command
-that generates bash completion scripts.
-
-`fn`, rather than relying on yargs' default completion functionlity, which
-shiver me timbers is pretty awesome, you can provide your own completion
-method.
-
-```js
-var argv = require('yargs')
-  .completion('completion', function(current, argv) {
-    // 'current' is the current command being completed.
-    // 'argv' is the parsed arguments so far.
-    // simply return an array of completions.
-    return [
-      'foo',
-      'bar'
-    ];
-  })
-  .argv;
-```
-
-But wait, there's more! you can provide asynchronous completions.
-
-```js
-var argv = require('yargs')
-  .completion('completion', function(current, argv, done) {
-    setTimeout(function() {
-      done([
-        'apple',
-        'banana'
-      ]);
-    }, 500);
-  })
-  .argv;
-```
-
-.showCompletionScript()
-----------------------
-
-Generate a bash completion script. Users of your application can install this
-script in their `.bashrc`, and yargs will provide completion shortcuts for
-commands and options.
-
-.exitProcess(enable)
-----------------------------------
-
-By default, yargs exits the process when the user passes a help flag, uses the `.version` functionality or when validation fails. Calling `.exitProcess(false)` disables this behavior, enabling further actions after yargs have been validated.
-
-.parse(args)
-------------
-
-Parse `args` instead of `process.argv`. Returns the `argv` object.
-
-.reset()
---------
-
-Reset the argument object built up so far. This is useful for
-creating nested command line interfaces.
-
-```js
-var yargs = require('./yargs')
-  .usage('$0 command')
-  .command('hello', 'hello command')
-  .command('world', 'world command')
-  .demand(1, 'must provide a valid command'),
-  argv = yargs.argv,
-  command = argv._[0];
-
-if (command === 'hello') {
-  yargs.reset()
-    .usage('$0 hello')
-    .help('h')
-    .example('$0 hello', 'print the hello message!')
-    .argv
-
-  console.log('hello!');
-} else if (command === 'world'){
-  yargs.reset()
-    .usage('$0 world')
-    .help('h')
-    .example('$0 world', 'print the world message!')
-    .argv
-
-  console.log('world!');
-} else {
-  yargs.showHelp();
-}
-```
-
-.argv
------
-
-Get the arguments as a plain old object.
-
-Arguments without a corresponding flag show up in the `argv._` array.
-
-The script name or node command is available at `argv.$0` similarly to how `$0`
-works in bash or perl.
-
-parsing tricks
-==============
-
-stop parsing
-------------
-
-Use `--` to stop parsing flags and stuff the remainder into `argv._`.
-
-    $ node examples/reflect.js -a 1 -b 2 -- -c 3 -d 4
-    { _: [ '-c', '3', '-d', '4' ],
-      '$0': 'node ./examples/reflect.js',
-      a: 1,
-      b: 2 }
-
-negate fields
--------------
-
-If you want to explicity set a field to false instead of just leaving it
-undefined or to override a default you can do `--no-key`.
-
-    $ node examples/reflect.js -a --no-b
-    { _: [],
-      '$0': 'node ./examples/reflect.js',
-      a: true,
-      b: false }
-
-numbers
--------
-
-Every argument that looks like a number (`!isNaN(Number(arg))`) is converted to
-one. This way you can just `net.createConnection(argv.port)` and you can add
-numbers out of `argv` with `+` without having that mean concatenation,
-which is super frustrating.
-
-duplicates
-----------
-
-If you specify a flag multiple times it will get turned into an array containing
-all the values in order.
-
-    $ node examples/reflect.js -x 5 -x 8 -x 0
-    { _: [],
-      '$0': 'node ./examples/reflect.js',
-        x: [ 5, 8, 0 ] }
-
-dot notation
-------------
-
-When you use dots (`.`s) in argument names, an implicit object path is assumed.
-This lets you organize arguments into nested objects.
-
-     $ node examples/reflect.js --foo.bar.baz=33 --foo.quux=5
-     { _: [],
-       '$0': 'node ./examples/reflect.js',
-         foo: { bar: { baz: 33 }, quux: 5 } }
-
-short numbers
--------------
-
-Short numeric `head -n5` style argument work too:
-
-    $ node reflect.js -n123 -m456
-    { '3': true,
-      '6': true,
-      _: [],
-      '$0': 'node ./reflect.js',
-      n: 123,
-      m: 456 }
-
-installation
-============
-
-With [npm](http://github.com/isaacs/npm), just do:
-
-    npm install yargs
-
-or clone this project on github:
-
-    git clone http://github.com/bcoe/yargs.git
-
-To run the tests with npm, just do:
-
-    npm test
-
-inspired by
-===========
-
-This module is loosely inspired by Perl's
-[Getopt::Casual](http://search.cpan.org/~photo/Getopt-Casual-0.13.1/Casual.pm).
diff --git a/node_modules/uglify-js/node_modules/yargs/completion.sh.hbs b/node_modules/uglify-js/node_modules/yargs/completion.sh.hbs
deleted file mode 100644
index c52e49914..000000000
--- a/node_modules/uglify-js/node_modules/yargs/completion.sh.hbs
+++ /dev/null
@@ -1,22 +0,0 @@
-###-begin-{{app_name}}-completions-###
-#
-# yargs command completion script
-#
-# Installation: {{app_path}} completion >> ~/.bashrc
-#    or {{app_path}} completion >> ~/.bash_profile on OSX.
-#
-_yargs_completions()
-{
-    local cur_word args type_list
-
-    cur_word="${COMP_WORDS[COMP_CWORD]}"
-    args=$(printf "%s " "${COMP_WORDS[@]}")
-
-    # ask yargs to generate completions.
-    type_list=`{{app_path}} --get-yargs-completions $args`
-
-    COMPREPLY=( $(compgen -W "${type_list}" -- ${cur_word}) )
-    return 0
-}
-complete -F _yargs_completions {{app_name}}
-###-end-{{app_name}}-completions-###
diff --git a/node_modules/uglify-js/node_modules/yargs/index.js b/node_modules/uglify-js/node_modules/yargs/index.js
deleted file mode 100644
index 96539b08d..000000000
--- a/node_modules/uglify-js/node_modules/yargs/index.js
+++ /dev/null
@@ -1,504 +0,0 @@
-var assert = require('assert'),
-  path = require('path'),
-  Completion = require('./lib/completion'),
-  Parser = require('./lib/parser'),
-  Usage = require('./lib/usage'),
-  Validation = require('./lib/validation')
-
-Argv(process.argv.slice(2))
-
-var exports = module.exports = Argv
-function Argv (processArgs, cwd) {
-  processArgs = processArgs || [] // handle calling yargs().
-
-  var self = {}
-  var completion = null
-  var usage = null
-  var validation = null
-
-  if (!cwd) cwd = process.cwd()
-
-  self.$0 = process.argv
-    .slice(0, 2)
-    .map(function (x, i) {
-      // ignore the node bin, specify this in your
-      // bin file with #!/usr/bin/env node
-      if (i === 0 && /\b(node|iojs)$/.test(x)) return
-      var b = rebase(cwd, x)
-      return x.match(/^\//) && b.length < x.length
-      ? b : x
-    })
-    .join(' ').trim()
-
-  if (process.env._ !== undefined && process.argv[1] === process.env._) {
-    self.$0 = process.env._.replace(
-      path.dirname(process.execPath) + '/', ''
-    )
-  }
-
-  var options
-  self.resetOptions = self.reset = function () {
-    // put yargs back into its initial
-    // state, this is useful for creating a
-    // nested CLI.
-    options = {
-      array: [],
-      boolean: [],
-      string: [],
-      narg: {},
-      key: {},
-      alias: {},
-      default: {},
-      defaultDescription: {},
-      requiresArg: [],
-      count: [],
-      normalize: [],
-      config: []
-    }
-
-    usage = Usage(self) // handle usage output.
-    validation = Validation(self, usage) // handle arg validation.
-    completion = Completion(self, usage)
-
-    demanded = {}
-
-    exitProcess = true
-    strict = false
-    helpOpt = null
-    versionOpt = null
-    completionOpt = null
-    commandHandlers = {}
-    self.parsed = false
-
-    return self
-  }
-  self.resetOptions()
-
-  self.boolean = function (bools) {
-    options.boolean.push.apply(options.boolean, [].concat(bools))
-    return self
-  }
-
-  self.array = function (arrays) {
-    options.array.push.apply(options.array, [].concat(arrays))
-    return self
-  }
-
-  self.nargs = function (key, n) {
-    if (typeof key === 'object') {
-      Object.keys(key).forEach(function (k) {
-        self.nargs(k, key[k])
-      })
-    } else {
-      options.narg[key] = n
-    }
-    return self
-  }
-
-  self.normalize = function (strings) {
-    options.normalize.push.apply(options.normalize, [].concat(strings))
-    return self
-  }
-
-  self.config = function (configs) {
-    options.config.push.apply(options.config, [].concat(configs))
-    return self
-  }
-
-  self.example = function (cmd, description) {
-    usage.example(cmd, description)
-    return self
-  }
-
-  self.command = function (cmd, description, fn) {
-    usage.command(cmd, description)
-    if (fn) commandHandlers[cmd] = fn
-    return self
-  }
-
-  var commandHandlers = {}
-  self.getCommandHandlers = function () {
-    return commandHandlers
-  }
-
-  self.string = function (strings) {
-    options.string.push.apply(options.string, [].concat(strings))
-    return self
-  }
-
-  self.default = function (key, value, defaultDescription) {
-    if (typeof key === 'object') {
-      Object.keys(key).forEach(function (k) {
-        self.default(k, key[k])
-      })
-    } else {
-      if (typeof value === 'function') {
-        defaultDescription = usage.functionDescription(value, defaultDescription)
-        value = value.call()
-      }
-      options.defaultDescription[key] = defaultDescription
-      options.default[key] = value
-    }
-    return self
-  }
-
-  self.alias = function (x, y) {
-    if (typeof x === 'object') {
-      Object.keys(x).forEach(function (key) {
-        self.alias(key, x[key])
-      })
-    } else {
-      options.alias[x] = (options.alias[x] || []).concat(y)
-    }
-    return self
-  }
-
-  self.count = function (counts) {
-    options.count.push.apply(options.count, [].concat(counts))
-    return self
-  }
-
-  var demanded = {}
-  self.demand = self.required = self.require = function (keys, msg) {
-    if (typeof keys === 'number') {
-      if (!demanded._) demanded._ = { count: 0, msg: null }
-      demanded._.count += keys
-      demanded._.msg = msg
-    } else if (Array.isArray(keys)) {
-      keys.forEach(function (key) {
-        self.demand(key, msg)
-      })
-    } else {
-      if (typeof msg === 'string') {
-        demanded[keys] = { msg: msg }
-      } else if (msg === true || typeof msg === 'undefined') {
-        demanded[keys] = { msg: undefined }
-      }
-    }
-
-    return self
-  }
-  self.getDemanded = function () {
-    return demanded
-  }
-
-  self.requiresArg = function (requiresArgs) {
-    options.requiresArg.push.apply(options.requiresArg, [].concat(requiresArgs))
-    return self
-  }
-
-  self.implies = function (key, value) {
-    validation.implies(key, value)
-    return self
-  }
-
-  self.usage = function (msg, opts) {
-    if (!opts && typeof msg === 'object') {
-      opts = msg
-      msg = null
-    }
-
-    usage.usage(msg)
-
-    if (opts) self.options(opts)
-
-    return self
-  }
-
-  self.epilogue = self.epilog = function (msg) {
-    usage.epilog(msg)
-    return self
-  }
-
-  self.fail = function (f) {
-    usage.failFn(f)
-    return self
-  }
-
-  self.check = function (f) {
-    validation.check(f)
-    return self
-  }
-
-  self.defaults = self.default
-
-  self.describe = function (key, desc) {
-    options.key[key] = true
-    usage.describe(key, desc)
-    return self
-  }
-
-  self.parse = function (args) {
-    return parseArgs(args)
-  }
-
-  self.option = self.options = function (key, opt) {
-    if (typeof key === 'object') {
-      Object.keys(key).forEach(function (k) {
-        self.options(k, key[k])
-      })
-    } else {
-      assert(typeof opt === 'object', 'second argument to option must be an object')
-
-      options.key[key] = true // track manually set keys.
-
-      if (opt.alias) self.alias(key, opt.alias)
-
-      var demand = opt.demand || opt.required || opt.require
-
-      if (demand) {
-        self.demand(key, demand)
-      } if ('default' in opt) {
-        self.default(key, opt.default)
-      } if ('nargs' in opt) {
-        self.nargs(key, opt.nargs)
-      } if (opt.boolean || opt.type === 'boolean') {
-        self.boolean(key)
-        if (opt.alias) self.boolean(opt.alias)
-      } if (opt.array || opt.type === 'array') {
-        self.array(key)
-        if (opt.alias) self.array(opt.alias)
-      } if (opt.string || opt.type === 'string') {
-        self.string(key)
-        if (opt.alias) self.string(opt.alias)
-      } if (opt.count || opt.type === 'count') {
-        self.count(key)
-      }
-
-      var desc = opt.describe || opt.description || opt.desc
-      if (desc) {
-        self.describe(key, desc)
-      }
-
-      if (opt.requiresArg) {
-        self.requiresArg(key)
-      }
-    }
-
-    return self
-  }
-  self.getOptions = function () {
-    return options
-  }
-
-  self.wrap = function (cols) {
-    usage.wrap(cols)
-    return self
-  }
-
-  var strict = false
-  self.strict = function () {
-    strict = true
-    return self
-  }
-  self.getStrict = function () {
-    return strict
-  }
-
-  self.showHelp = function (level) {
-    if (!self.parsed) parseArgs(processArgs) // run parser, if it has not already been executed.
-    usage.showHelp(level)
-    return self
-  }
-
-  var versionOpt = null
-  self.version = function (ver, opt, msg) {
-    versionOpt = opt || 'version'
-    usage.version(ver)
-    self.boolean(versionOpt)
-    self.describe(versionOpt, msg || 'Show version number')
-    return self
-  }
-
-  var helpOpt = null
-  self.addHelpOpt = function (opt, msg) {
-    helpOpt = opt
-    self.boolean(opt)
-    self.describe(opt, msg || 'Show help')
-    return self
-  }
-
-  self.showHelpOnFail = function (enabled, message) {
-    usage.showHelpOnFail(enabled, message)
-    return self
-  }
-
-  var exitProcess = true
-  self.exitProcess = function (enabled) {
-    if (typeof enabled !== 'boolean') {
-      enabled = true
-    }
-    exitProcess = enabled
-    return self
-  }
-  self.getExitProcess = function () {
-    return exitProcess
-  }
-
-  self.help = function () {
-    if (arguments.length > 0) return self.addHelpOpt.apply(self, arguments)
-
-    if (!self.parsed) parseArgs(processArgs) // run parser, if it has not already been executed.
-
-    return usage.help()
-  }
-
-  var completionOpt = null,
-  completionCommand = null
-  self.completion = function (cmd, desc, fn) {
-    // a function to execute when generating
-    // completions can be provided as the second
-    // or third argument to completion.
-    if (typeof desc === 'function') {
-      fn = desc
-      desc = null
-    }
-
-    // register the completion command.
-    completionCommand = cmd
-    completionOpt = completion.completionKey
-    self.command(completionCommand, desc || 'generate bash completion script')
-
-    // a function can be provided
-    if (fn) completion.registerFunction(fn)
-
-    return self
-  }
-
-  self.showCompletionScript = function ($0) {
-    $0 = $0 || self.$0
-    console.log(completion.generateCompletionScript($0))
-    return self
-  }
-
-  self.getUsageInstance = function () {
-    return usage
-  }
-
-  self.getValidationInstance = function () {
-    return validation
-  }
-
-  self.terminalWidth = function () {
-    return require('window-size').width
-  }
-
-  Object.defineProperty(self, 'argv', {
-    get: function () {
-      var args = null
-
-      try {
-        args = parseArgs(processArgs)
-      } catch (err) {
-        usage.fail(err.message)
-      }
-
-      return args
-    },
-    enumerable: true
-  })
-
-  function parseArgs (args) {
-    var parsed = Parser(args, options),
-      argv = parsed.argv,
-      aliases = parsed.aliases
-
-    argv.$0 = self.$0
-
-    self.parsed = parsed
-
-    // generate a completion script for adding to ~/.bashrc.
-    if (completionCommand && ~argv._.indexOf(completionCommand)) {
-      self.showCompletionScript()
-      if (exitProcess) {
-        process.exit(0)
-      }
-    }
-
-    // if there's a handler associated with a
-    // command defer processing to it.
-    var handlerKeys = Object.keys(self.getCommandHandlers())
-    for (var i = 0, command; (command = handlerKeys[i]) !== undefined; i++) {
-      if (~argv._.indexOf(command)) {
-        self.getCommandHandlers()[command](self.reset())
-        return self.argv
-      }
-    }
-
-    Object.keys(argv).forEach(function (key) {
-      if (key === helpOpt && argv[key]) {
-        self.showHelp('log')
-        if (exitProcess) {
-          process.exit(0)
-        }
-      } else if (key === versionOpt && argv[key]) {
-        usage.showVersion()
-        if (exitProcess) {
-          process.exit(0)
-        }
-      } else if (key === completionOpt) {
-        // we allow for asynchronous completions,
-        // e.g., loading in a list of commands from an API.
-        completion.getCompletion(function (completions) {
-          ;(completions || []).forEach(function (completion) {
-            console.log(completion)
-          })
-
-          if (exitProcess) {
-            process.exit(0)
-          }
-        })
-        return
-      }
-    })
-
-    validation.nonOptionCount(argv)
-    validation.missingArgumentValue(argv)
-    validation.requiredArguments(argv)
-
-    if (strict) {
-      validation.unknownArguments(argv, aliases)
-    }
-
-    validation.customChecks(argv, aliases)
-    validation.implications(argv)
-    setPlaceholderKeys(argv)
-
-    return argv
-  }
-
-  function setPlaceholderKeys (argv) {
-    Object.keys(options.key).forEach(function (key) {
-      if (typeof argv[key] === 'undefined') argv[key] = undefined
-    })
-  }
-
-  sigletonify(self)
-  return self
-}
-
-// rebase an absolute path to a relative one with respect to a base directory
-// exported for tests
-exports.rebase = rebase
-function rebase (base, dir) {
-  return path.relative(base, dir)
-}
-
-/*  Hack an instance of Argv with process.argv into Argv
-    so people can do
-    require('yargs')(['--beeble=1','-z','zizzle']).argv
-    to parse a list of args and
-    require('yargs').argv
-    to get a parsed version of process.argv.
-*/
-function sigletonify (inst) {
-  Object.keys(inst).forEach(function (key) {
-    if (key === 'argv') {
-      Argv.__defineGetter__(key, inst.__lookupGetter__(key))
-    } else {
-      Argv[key] = typeof inst[key] === 'function'
-      ? inst[key].bind(inst)
-      : inst[key]
-    }
-  })
-}
diff --git a/node_modules/uglify-js/node_modules/yargs/lib/completion.js b/node_modules/uglify-js/node_modules/yargs/lib/completion.js
deleted file mode 100644
index 32387be27..000000000
--- a/node_modules/uglify-js/node_modules/yargs/lib/completion.js
+++ /dev/null
@@ -1,71 +0,0 @@
-var fs = require('fs'),
-  path = require('path')
-
-// add bash completions to your
-//  yargs-powered applications.
-module.exports = function (yargs, usage) {
-  var self = {
-    completionKey: 'get-yargs-completions'
-  }
-
-  // get a list of completion commands.
-  self.getCompletion = function (done) {
-    var completions = [],
-    current = process.argv[process.argv.length - 1],
-    previous = process.argv.slice(process.argv.indexOf('--' + self.completionKey) + 1),
-    argv = yargs.parse(previous)
-
-    // a custom completion function can be provided
-    // to completion().
-    if (completionFunction) {
-      if (completionFunction.length < 3) {
-        // synchronous completion function.
-        return done(completionFunction(current, argv))
-      } else {
-        // asynchronous completion function
-        return completionFunction(current, argv, function (completions) {
-          done(completions)
-        })
-      }
-    }
-
-    if (!current.match(/^-/)) {
-      usage.getCommands().forEach(function (command) {
-        completions.push(command[0])
-      })
-    }
-
-    if (current.match(/^-/)) {
-      Object.keys(yargs.getOptions().key).forEach(function (key) {
-        completions.push('--' + key)
-      })
-    }
-
-    done(completions)
-  }
-
-  // generate the completion script to add to your .bashrc.
-  self.generateCompletionScript = function ($0) {
-    var script = fs.readFileSync(
-      path.resolve(__dirname, '../completion.sh.hbs'),
-      'utf-8'
-    ),
-    name = path.basename($0)
-
-    // add ./to applications not yet installed as bin.
-    if ($0.match(/\.js$/)) $0 = './' + $0
-
-    script = script.replace(/{{app_name}}/g, name)
-    return script.replace(/{{app_path}}/g, $0)
-  }
-
-  // register a function to perform your own custom
-  // completions., this function can be either
-  // synchrnous or asynchronous.
-  var completionFunction = null
-  self.registerFunction = function (fn) {
-    completionFunction = fn
-  }
-
-  return self
-}
diff --git a/node_modules/uglify-js/node_modules/yargs/lib/parser.js b/node_modules/uglify-js/node_modules/yargs/lib/parser.js
deleted file mode 100644
index 5e4618cb5..000000000
--- a/node_modules/uglify-js/node_modules/yargs/lib/parser.js
+++ /dev/null
@@ -1,448 +0,0 @@
-// fancy-pants parsing of argv, originally forked
-// from minimist: https://www.npmjs.com/package/minimist
-var camelCase = require('camelcase'),
-  path = require('path')
-
-function increment (orig) {
-  return orig !== undefined ? orig + 1 : 0
-}
-
-module.exports = function (args, opts) {
-  if (!opts) opts = {}
-  var flags = { arrays: {}, bools: {}, strings: {}, counts: {}, normalize: {}, configs: {} }
-
-  ;[].concat(opts['array']).filter(Boolean).forEach(function (key) {
-    flags.arrays[key] = true
-  })
-
-  ;[].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
-    flags.bools[key] = true
-  })
-
-  ;[].concat(opts.string).filter(Boolean).forEach(function (key) {
-    flags.strings[key] = true
-  })
-
-  ;[].concat(opts.count).filter(Boolean).forEach(function (key) {
-    flags.counts[key] = true
-  })
-
-  ;[].concat(opts.normalize).filter(Boolean).forEach(function (key) {
-    flags.normalize[key] = true
-  })
-
-  ;[].concat(opts.config).filter(Boolean).forEach(function (key) {
-    flags.configs[key] = true
-  })
-
-  var aliases = {},
-  newAliases = {}
-
-  extendAliases(opts.key)
-  extendAliases(opts.alias)
-
-  var defaults = opts['default'] || {}
-  Object.keys(defaults).forEach(function (key) {
-    if (/-/.test(key) && !opts.alias[key]) {
-      aliases[key] = aliases[key] || []
-    }
-    (aliases[key] || []).forEach(function (alias) {
-      defaults[alias] = defaults[key]
-    })
-  })
-
-  var argv = { _: [] }
-
-  Object.keys(flags.bools).forEach(function (key) {
-    setArg(key, !(key in defaults) ? false : defaults[key])
-  })
-
-  var notFlags = []
-  if (args.indexOf('--') !== -1) {
-    notFlags = args.slice(args.indexOf('--') + 1)
-    args = args.slice(0, args.indexOf('--'))
-  }
-
-  for (var i = 0; i < args.length; i++) {
-    var arg = args[i],
-      broken,
-      key,
-      letters,
-      m,
-      next,
-      value
-
-    // -- seperated by =
-    if (arg.match(/^--.+=/)) {
-      // Using [\s\S] instead of . because js doesn't support the
-      // 'dotall' regex modifier. See:
-      // http://stackoverflow.com/a/1068308/13216
-      m = arg.match(/^--([^=]+)=([\s\S]*)$/)
-
-      // nargs format = '--f=monkey washing cat'
-      if (checkAllAliases(m[1], opts.narg)) {
-        args.splice(i + 1, m[1], m[2])
-        i = eatNargs(i, m[1], args)
-      // arrays format = '--f=a b c'
-      } else if (checkAllAliases(m[1], flags.arrays) && args.length > i + 1) {
-        args.splice(i + 1, m[1], m[2])
-        i = eatArray(i, m[1], args)
-      } else {
-        setArg(m[1], m[2])
-      }
-    } else if (arg.match(/^--no-.+/)) {
-      key = arg.match(/^--no-(.+)/)[1]
-      setArg(key, false)
-
-    // -- seperated by space.
-    } else if (arg.match(/^--.+/)) {
-      key = arg.match(/^--(.+)/)[1]
-
-      // nargs format = '--foo a b c'
-      if (checkAllAliases(key, opts.narg)) {
-        i = eatNargs(i, key, args)
-      // array format = '--foo a b c'
-      } else if (checkAllAliases(key, flags.arrays) && args.length > i + 1) {
-        i = eatArray(i, key, args)
-      } else {
-        next = args[i + 1]
-
-        if (next !== undefined && !next.match(/^-/)
-        && !checkAllAliases(key, flags.bools)
-        && !checkAllAliases(key, flags.counts)) {
-          setArg(key, next)
-          i++
-        } else if (/^(true|false)$/.test(next)) {
-          setArg(key, next)
-          i++
-        } else {
-          setArg(key, defaultForType(guessType(key, flags)))
-        }
-      }
-
-    // dot-notation flag seperated by '='.
-    } else if (arg.match(/^-.\..+=/)) {
-      m = arg.match(/^-([^=]+)=([\s\S]*)$/)
-      setArg(m[1], m[2])
-
-    // dot-notation flag seperated by space.
-    } else if (arg.match(/^-.\..+/)) {
-      next = args[i + 1]
-      key = arg.match(/^-(.\..+)/)[1]
-
-      if (next !== undefined && !next.match(/^-/)
-        && !checkAllAliases(key, flags.bools)
-        && !checkAllAliases(key, flags.counts)) {
-        setArg(key, next)
-        i++
-      } else {
-        setArg(key, defaultForType(guessType(key, flags)))
-      }
-    } else if (arg.match(/^-[^-]+/)) {
-      letters = arg.slice(1, -1).split('')
-      broken = false
-
-      for (var j = 0; j < letters.length; j++) {
-        next = arg.slice(j + 2)
-
-        if (letters[j + 1] && letters[j + 1] === '=') {
-          value = arg.slice(j + 3)
-          key = letters[j]
-
-          // nargs format = '-f=monkey washing cat'
-          if (checkAllAliases(letters[j], opts.narg)) {
-            args.splice(i + 1, 0, value)
-            i = eatNargs(i, key, args)
-          // array format = '-f=a b c'
-          } else if (checkAllAliases(key, flags.arrays) && args.length > i + 1) {
-            args.splice(i + 1, 0, value)
-            i = eatArray(i, key, args)
-          } else {
-            setArg(key, value)
-          }
-
-          broken = true
-          break
-        }
-
-        if (next === '-') {
-          setArg(letters[j], next)
-          continue
-        }
-
-        if (/[A-Za-z]/.test(letters[j])
-        && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
-          setArg(letters[j], next)
-          broken = true
-          break
-        }
-
-        if (letters[j + 1] && letters[j + 1].match(/\W/)) {
-          setArg(letters[j], arg.slice(j + 2))
-          broken = true
-          break
-        } else {
-          setArg(letters[j], defaultForType(guessType(letters[j], flags)))
-        }
-      }
-
-      key = arg.slice(-1)[0]
-
-      if (!broken && key !== '-') {
-        // nargs format = '-f a b c'
-        if (checkAllAliases(key, opts.narg)) {
-          i = eatNargs(i, key, args)
-        // array format = '-f a b c'
-        } else if (checkAllAliases(key, flags.arrays) && args.length > i + 1) {
-          i = eatArray(i, key, args)
-        } else {
-          if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1])
-          && !checkAllAliases(key, flags.bools)
-          && !checkAllAliases(key, flags.counts)) {
-            setArg(key, args[i + 1])
-            i++
-          } else if (args[i + 1] && /true|false/.test(args[i + 1])) {
-            setArg(key, args[i + 1])
-            i++
-          } else {
-            setArg(key, defaultForType(guessType(key, flags)))
-          }
-        }
-      }
-    } else {
-      argv._.push(
-        flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
-      )
-    }
-  }
-
-  setConfig(argv)
-  applyDefaultsAndAliases(argv, aliases, defaults)
-
-  Object.keys(flags.counts).forEach(function (key) {
-    setArg(key, defaults[key])
-  })
-
-  notFlags.forEach(function (key) {
-    argv._.push(key)
-  })
-
-  // how many arguments should we consume, based
-  // on the nargs option?
-  function eatNargs (i, key, args) {
-    var toEat = checkAllAliases(key, opts.narg)
-
-    if (args.length - (i + 1) < toEat) throw Error('not enough arguments following: ' + key)
-
-    for (var ii = i + 1; ii < (toEat + i + 1); ii++) {
-      setArg(key, args[ii])
-    }
-
-    return (i + toEat)
-  }
-
-  // if an option is an array, eat all non-hyphenated arguments
-  // following it... YUM!
-  // e.g., --foo apple banana cat becomes ["apple", "banana", "cat"]
-  function eatArray (i, key, args) {
-    for (var ii = i + 1; ii < args.length; ii++) {
-      if (/^-/.test(args[ii])) break
-      i = ii
-      setArg(key, args[ii])
-    }
-
-    return i
-  }
-
-  function setArg (key, val) {
-    // handle parsing boolean arguments --foo=true --bar false.
-    if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
-      if (typeof val === 'string') val = val === 'true'
-    }
-
-    if (/-/.test(key) && !(aliases[key] && aliases[key].length)) {
-      var c = camelCase(key)
-      aliases[key] = [c]
-      newAliases[c] = true
-    }
-
-    var value = !checkAllAliases(key, flags.strings) && isNumber(val) ? Number(val) : val
-
-    if (checkAllAliases(key, flags.counts)) {
-      value = increment
-    }
-
-    var splitKey = key.split('.')
-    setKey(argv, splitKey, value)
-
-    ;(aliases[splitKey[0]] || []).forEach(function (x) {
-      x = x.split('.')
-
-      // handle populating dot notation for both
-      // the key and its aliases.
-      if (splitKey.length > 1) {
-        var a = [].concat(splitKey)
-        a.shift() // nuke the old key.
-        x = x.concat(a)
-      }
-
-      setKey(argv, x, value)
-    })
-
-    var keys = [key].concat(aliases[key] || [])
-    for (var i = 0, l = keys.length; i < l; i++) {
-      if (flags.normalize[keys[i]]) {
-        keys.forEach(function (key) {
-          argv.__defineSetter__(key, function (v) {
-            val = path.normalize(v)
-          })
-
-          argv.__defineGetter__(key, function () {
-            return typeof val === 'string' ?
-            path.normalize(val) : val
-          })
-        })
-        break
-      }
-    }
-  }
-
-  // set args from config.json file, this should be
-  // applied last so that defaults can be applied.
-  function setConfig (argv) {
-    var configLookup = {}
-
-    // expand defaults/aliases, in-case any happen to reference
-    // the config.json file.
-    applyDefaultsAndAliases(configLookup, aliases, defaults)
-
-    Object.keys(flags.configs).forEach(function (configKey) {
-      var configPath = argv[configKey] || configLookup[configKey]
-      if (configPath) {
-        try {
-          var config = require(path.resolve(process.cwd(), configPath))
-
-          Object.keys(config).forEach(function (key) {
-            // setting arguments via CLI takes precedence over
-            // values within the config file.
-            if (argv[key] === undefined) {
-              delete argv[key]
-              setArg(key, config[key])
-            }
-          })
-        } catch (ex) {
-          throw Error('invalid json config file: ' + configPath)
-        }
-      }
-    })
-  }
-
-  function applyDefaultsAndAliases (obj, aliases, defaults) {
-    Object.keys(defaults).forEach(function (key) {
-      if (!hasKey(obj, key.split('.'))) {
-        setKey(obj, key.split('.'), defaults[key])
-
-        ;(aliases[key] || []).forEach(function (x) {
-          setKey(obj, x.split('.'), defaults[key])
-        })
-      }
-    })
-  }
-
-  function hasKey (obj, keys) {
-    var o = obj
-    keys.slice(0, -1).forEach(function (key) {
-      o = (o[key] || {})
-    })
-
-    var key = keys[keys.length - 1]
-    return key in o
-  }
-
-  function setKey (obj, keys, value) {
-    var o = obj
-    keys.slice(0, -1).forEach(function (key) {
-      if (o[key] === undefined) o[key] = {}
-      o = o[key]
-    })
-
-    var key = keys[keys.length - 1]
-    if (value === increment) {
-      o[key] = increment(o[key])
-    } else if (o[key] === undefined && checkAllAliases(key, flags.arrays)) {
-      o[key] = Array.isArray(value) ? value : [value]
-    } else if (o[key] === undefined || typeof o[key] === 'boolean') {
-      o[key] = value
-    } else if (Array.isArray(o[key])) {
-      o[key].push(value)
-    } else {
-      o[key] = [ o[key], value ]
-    }
-  }
-
-  // extend the aliases list with inferred aliases.
-  function extendAliases (obj) {
-    Object.keys(obj || {}).forEach(function (key) {
-      aliases[key] = [].concat(opts.alias[key] || [])
-      // For "--option-name", also set argv.optionName
-      aliases[key].concat(key).forEach(function (x) {
-        if (/-/.test(x)) {
-          var c = camelCase(x)
-          aliases[key].push(c)
-          newAliases[c] = true
-        }
-      })
-      aliases[key].forEach(function (x) {
-        aliases[x] = [key].concat(aliases[key].filter(function (y) {
-          return x !== y
-        }))
-      })
-    })
-  }
-
-  // check if a flag is set for any of a key's aliases.
-  function checkAllAliases (key, flag) {
-    var isSet = false,
-    toCheck = [].concat(aliases[key] || [], key)
-
-    toCheck.forEach(function (key) {
-      if (flag[key]) isSet = flag[key]
-    })
-
-    return isSet
-  }
-
-  // return a default value, given the type of a flag.,
-  // e.g., key of type 'string' will default to '', rather than 'true'.
-  function defaultForType (type) {
-    var def = {
-      boolean: true,
-      string: '',
-      array: []
-    }
-
-    return def[type]
-  }
-
-  // given a flag, enforce a default type.
-  function guessType (key, flags) {
-    var type = 'boolean'
-
-    if (flags.strings && flags.strings[key]) type = 'string'
-    else if (flags.arrays && flags.arrays[key]) type = 'array'
-
-    return type
-  }
-
-  function isNumber (x) {
-    if (typeof x === 'number') return true
-    if (/^0x[0-9a-f]+$/i.test(x)) return true
-    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x)
-  }
-
-  return {
-    argv: argv,
-    aliases: aliases,
-    newAliases: newAliases
-  }
-}
diff --git a/node_modules/uglify-js/node_modules/yargs/lib/usage.js b/node_modules/uglify-js/node_modules/yargs/lib/usage.js
deleted file mode 100644
index 8cfe9dd0c..000000000
--- a/node_modules/uglify-js/node_modules/yargs/lib/usage.js
+++ /dev/null
@@ -1,314 +0,0 @@
-// this file handles outputting usage instructions,
-// failures, etc. keeps logging in one place.
-var cliui = require('cliui'),
-  decamelize = require('decamelize'),
-  wsize = require('window-size')
-
-module.exports = function (yargs) {
-  var self = {}
-
-  // methods for ouputting/building failure message.
-  var fails = []
-  self.failFn = function (f) {
-    fails.push(f)
-  }
-
-  var failMessage = null
-  var showHelpOnFail = true
-  self.showHelpOnFail = function (enabled, message) {
-    if (typeof enabled === 'string') {
-      message = enabled
-      enabled = true
-    } else if (typeof enabled === 'undefined') {
-      enabled = true
-    }
-    failMessage = message
-    showHelpOnFail = enabled
-    return self
-  }
-
-  self.fail = function (msg) {
-    if (fails.length) {
-      fails.forEach(function (f) {
-        f(msg)
-      })
-    } else {
-      if (showHelpOnFail) yargs.showHelp('error')
-      if (msg) console.error(msg)
-      if (failMessage) {
-        if (msg) console.error('')
-        console.error(failMessage)
-      }
-      if (yargs.getExitProcess()) {
-        process.exit(1)
-      } else {
-        throw new Error(msg)
-      }
-    }
-  }
-
-  // methods for ouputting/building help (usage) message.
-  var usage
-  self.usage = function (msg) {
-    usage = msg
-  }
-
-  var examples = []
-  self.example = function (cmd, description) {
-    examples.push([cmd, description || ''])
-  }
-
-  var commands = []
-  self.command = function (cmd, description) {
-    commands.push([cmd, description || ''])
-  }
-  self.getCommands = function () {
-    return commands
-  }
-
-  var descriptions = {}
-  self.describe = function (key, desc) {
-    if (typeof key === 'object') {
-      Object.keys(key).forEach(function (k) {
-        self.describe(k, key[k])
-      })
-    } else {
-      descriptions[key] = desc
-    }
-  }
-  self.getDescriptions = function () {
-    return descriptions
-  }
-
-  var epilog
-  self.epilog = function (msg) {
-    epilog = msg
-  }
-
-  var wrap = windowWidth()
-  self.wrap = function (cols) {
-    wrap = cols
-  }
-
-  self.help = function () {
-    normalizeAliases()
-
-    var demanded = yargs.getDemanded(),
-      options = yargs.getOptions(),
-      keys = Object.keys(
-        Object.keys(descriptions)
-        .concat(Object.keys(demanded))
-        .concat(Object.keys(options.default))
-        .reduce(function (acc, key) {
-          if (key !== '_') acc[key] = true
-          return acc
-        }, {})
-      ),
-      ui = cliui({
-        width: wrap,
-        wrap: !!wrap
-      })
-
-    // the usage string.
-    if (usage) {
-      var u = usage.replace(/\$0/g, yargs.$0)
-      ui.div(u + '\n')
-    }
-
-    // your application's commands, i.e., non-option
-    // arguments populated in '_'.
-    if (commands.length) {
-      ui.div('Commands:')
-
-      commands.forEach(function (command) {
-        ui.div(
-          {text: command[0], padding: [0, 2, 0, 2], width: maxWidth(commands) + 4},
-          {text: command[1]}
-        )
-      })
-
-      ui.div()
-    }
-
-    // the options table.
-    var aliasKeys = (Object.keys(options.alias) || [])
-      .concat(Object.keys(yargs.parsed.newAliases) || [])
-
-    keys = keys.filter(function (key) {
-      return !yargs.parsed.newAliases[key] && aliasKeys.every(function (alias) {
-        return (options.alias[alias] || []).indexOf(key) === -1
-      })
-    })
-
-    var switches = keys.reduce(function (acc, key) {
-      acc[key] = [ key ].concat(options.alias[key] || [])
-      .map(function (sw) {
-        return (sw.length > 1 ? '--' : '-') + sw
-      })
-      .join(', ')
-
-      return acc
-    }, {})
-
-    if (keys.length) {
-      ui.div('Options:')
-
-      keys.forEach(function (key) {
-        var kswitch = switches[key]
-        var desc = descriptions[key] || ''
-        var type = null
-
-        if (~options.boolean.indexOf(key)) type = '[boolean]'
-        if (~options.count.indexOf(key)) type = '[count]'
-        if (~options.string.indexOf(key)) type = '[string]'
-        if (~options.normalize.indexOf(key)) type = '[string]'
-        if (~options.array.indexOf(key)) type = '[array]'
-
-        var extra = [
-            type,
-            demanded[key] ? '[required]' : null,
-            defaultString(options.default[key], options.defaultDescription[key])
-          ].filter(Boolean).join(' ')
-
-        ui.span(
-          {text: kswitch, padding: [0, 2, 0, 2], width: maxWidth(switches) + 4},
-          desc
-        )
-
-        if (extra) ui.div({text: extra, padding: [0, 0, 0, 2], align: 'right'})
-        else ui.div()
-      })
-
-      ui.div()
-    }
-
-    // describe some common use-cases for your application.
-    if (examples.length) {
-      ui.div('Examples:')
-
-      examples.forEach(function (example) {
-        example[0] = example[0].replace(/\$0/g, yargs.$0)
-      })
-
-      examples.forEach(function (example) {
-        ui.div(
-          {text: example[0], padding: [0, 2, 0, 2], width: maxWidth(examples) + 4},
-          example[1]
-        )
-      })
-
-      ui.div()
-    }
-
-    // the usage string.
-    if (epilog) {
-      var e = epilog.replace(/\$0/g, yargs.$0)
-      ui.div(e + '\n')
-    }
-
-    return ui.toString()
-  }
-
-  // return the maximum width of a string
-  // in the left-hand column of a table.
-  function maxWidth (table) {
-    var width = 0
-
-    // table might be of the form [leftColumn],
-    // or {key: leftColumn}}
-    if (!Array.isArray(table)) {
-      table = Object.keys(table).map(function (key) {
-        return [table[key]]
-      })
-    }
-
-    table.forEach(function (v) {
-      width = Math.max(v[0].length, width)
-    })
-
-    // if we've enabled 'wrap' we should limit
-    // the max-width of the left-column.
-    if (wrap) width = Math.min(width, parseInt(wrap * 0.5, 10))
-
-    return width
-  }
-
-  // make sure any options set for aliases,
-  // are copied to the keys being aliased.
-  function normalizeAliases () {
-    var options = yargs.getOptions(),
-    demanded = yargs.getDemanded()
-
-    ;(Object.keys(options.alias) || []).forEach(function (key) {
-      options.alias[key].forEach(function (alias) {
-        // copy descriptions.
-        if (descriptions[alias]) self.describe(key, descriptions[alias])
-        // copy demanded.
-        if (demanded[alias]) yargs.demand(key, demanded[alias].msg)
-
-        // type messages.
-        if (~options.boolean.indexOf(alias)) yargs.boolean(key)
-        if (~options.count.indexOf(alias)) yargs.count(key)
-        if (~options.string.indexOf(alias)) yargs.string(key)
-        if (~options.normalize.indexOf(alias)) yargs.normalize(key)
-        if (~options.array.indexOf(alias)) yargs.array(key)
-      })
-    })
-  }
-
-  self.showHelp = function (level) {
-    level = level || 'error'
-    console[level](self.help())
-  }
-
-  self.functionDescription = function (fn, defaultDescription) {
-    if (defaultDescription) {
-      return defaultDescription
-    }
-    var description = fn.name ? decamelize(fn.name, '-') : 'generated-value'
-    return ['(', description, ')'].join('')
-  }
-
-  // format the default-value-string displayed in
-  // the right-hand column.
-  function defaultString (value, defaultDescription) {
-    var string = '[default: '
-
-    if (value === undefined) return null
-
-    if (defaultDescription) {
-      string += defaultDescription
-    } else {
-      switch (typeof value) {
-        case 'string':
-          string += JSON.stringify(value)
-          break
-        case 'object':
-          string += JSON.stringify(value)
-          break
-        default:
-          string += value
-      }
-    }
-
-    return string + ']'
-  }
-
-  // guess the width of the console window, max-width 80.
-  function windowWidth () {
-    return wsize.width ? Math.min(80, wsize.width) : null
-  }
-
-  // logic for displaying application version.
-  var version = null
-  self.version = function (ver, opt, msg) {
-    version = ver
-  }
-
-  self.showVersion = function () {
-    if (typeof version === 'function') console.log(version())
-    else console.log(version)
-  }
-
-  return self
-}
diff --git a/node_modules/uglify-js/node_modules/yargs/lib/validation.js b/node_modules/uglify-js/node_modules/yargs/lib/validation.js
deleted file mode 100644
index 19afe9401..000000000
--- a/node_modules/uglify-js/node_modules/yargs/lib/validation.js
+++ /dev/null
@@ -1,196 +0,0 @@
-// validation-type-stuff, missing params,
-// bad implications, custom checks.
-module.exports = function (yargs, usage) {
-  var self = {}
-
-  // validate appropriate # of non-option
-  // arguments were provided, i.e., '_'.
-  self.nonOptionCount = function (argv) {
-    var demanded = yargs.getDemanded()
-
-    if (demanded._ && argv._.length < demanded._.count) {
-      if (demanded._.msg !== undefined) {
-        usage.fail(demanded._.msg)
-      } else {
-        usage.fail('Not enough non-option arguments: got '
-          + argv._.length + ', need at least ' + demanded._.count
-        )
-      }
-    }
-  }
-
-  // make sure that any args that require an
-  // value (--foo=bar), have a value.
-  self.missingArgumentValue = function (argv) {
-    var options = yargs.getOptions(),
-      defaultValues = [true, false, '']
-
-    if (options.requiresArg.length > 0) {
-      var missingRequiredArgs = []
-
-      options.requiresArg.forEach(function (key) {
-        var value = argv[key]
-
-        // if a value is explicitly requested,
-        // flag argument as missing if it does not
-        // look like foo=bar was entered.
-        if (~defaultValues.indexOf(value)
-        || (Array.isArray(value) && !value.length)) {
-          missingRequiredArgs.push(key)
-        }
-      })
-
-      if (missingRequiredArgs.length === 1) {
-        usage.fail('Missing argument value: ' + missingRequiredArgs[0])
-      } else if (missingRequiredArgs.length > 1) {
-        var message = 'Missing argument values: ' + missingRequiredArgs.join(', ')
-        usage.fail(message)
-      }
-    }
-  }
-
-  // make sure all the required arguments are present.
-  self.requiredArguments = function (argv) {
-    var demanded = yargs.getDemanded(),
-      missing = null
-
-    Object.keys(demanded).forEach(function (key) {
-      if (!argv.hasOwnProperty(key)) {
-        missing = missing || {}
-        missing[key] = demanded[key]
-      }
-    })
-
-    if (missing) {
-      var customMsgs = []
-      Object.keys(missing).forEach(function (key) {
-        var msg = missing[key].msg
-        if (msg && customMsgs.indexOf(msg) < 0) {
-          customMsgs.push(msg)
-        }
-      })
-
-      var customMsg = customMsgs.length ? '\n' + customMsgs.join('\n') : ''
-      usage.fail('Missing required arguments: ' + Object.keys(missing).join(', ') + customMsg)
-    }
-  }
-
-  // check for unknown arguments (strict-mode).
-  self.unknownArguments = function (argv, aliases) {
-    var descriptions = usage.getDescriptions(),
-      demanded = yargs.getDemanded(),
-      unknown = [],
-      aliasLookup = {}
-
-    Object.keys(aliases).forEach(function (key) {
-      aliases[key].forEach(function (alias) {
-        aliasLookup[alias] = key
-      })
-    })
-
-    Object.keys(argv).forEach(function (key) {
-      if (key !== '$0' && key !== '_' &&
-        !descriptions.hasOwnProperty(key) &&
-        !demanded.hasOwnProperty(key) &&
-        !aliasLookup.hasOwnProperty(key)) {
-        unknown.push(key)
-      }
-    })
-
-    if (unknown.length === 1) {
-      usage.fail('Unknown argument: ' + unknown[0])
-    } else if (unknown.length > 1) {
-      usage.fail('Unknown arguments: ' + unknown.join(', '))
-    }
-  }
-
-  // custom checks, added using the `check` option on yargs.
-  var checks = []
-  self.check = function (f) {
-    checks.push(f)
-  }
-
-  self.customChecks = function (argv, aliases) {
-    checks.forEach(function (f) {
-      try {
-        var result = f(argv, aliases)
-        if (!result) {
-          usage.fail('Argument check failed: ' + f.toString())
-        } else if (typeof result === 'string') {
-          usage.fail(result)
-        }
-      } catch (err) {
-        usage.fail(err.message ? err.message : err)
-      }
-    })
-  }
-
-  // check implications, argument foo implies => argument bar.
-  var implied = {}
-  self.implies = function (key, value) {
-    if (typeof key === 'object') {
-      Object.keys(key).forEach(function (k) {
-        self.implies(k, key[k])
-      })
-    } else {
-      implied[key] = value
-    }
-  }
-  self.getImplied = function () {
-    return implied
-  }
-
-  self.implications = function (argv) {
-    var implyFail = []
-
-    Object.keys(implied).forEach(function (key) {
-      var num,
-        origKey = key,
-        value = implied[key]
-
-      // convert string '1' to number 1
-      num = Number(key)
-      key = isNaN(num) ? key : num
-
-      if (typeof key === 'number') {
-        // check length of argv._
-        key = argv._.length >= key
-      } else if (key.match(/^--no-.+/)) {
-        // check if key doesn't exist
-        key = key.match(/^--no-(.+)/)[1]
-        key = !argv[key]
-      } else {
-        // check if key exists
-        key = argv[key]
-      }
-
-      num = Number(value)
-      value = isNaN(num) ? value : num
-
-      if (typeof value === 'number') {
-        value = argv._.length >= value
-      } else if (value.match(/^--no-.+/)) {
-        value = value.match(/^--no-(.+)/)[1]
-        value = !argv[value]
-      } else {
-        value = argv[value]
-      }
-
-      if (key && !value) {
-        implyFail.push(origKey)
-      }
-    })
-
-    if (implyFail.length) {
-      var msg = 'Implications failed:\n'
-
-      implyFail.forEach(function (key) {
-        msg += ('  ' + key + ' -> ' + implied[key])
-      })
-
-      usage.fail(msg)
-    }
-  }
-
-  return self
-}
diff --git a/node_modules/uglify-js/node_modules/yargs/package.json b/node_modules/uglify-js/node_modules/yargs/package.json
deleted file mode 100644
index 7dfc3ced7..000000000
--- a/node_modules/uglify-js/node_modules/yargs/package.json
+++ /dev/null
@@ -1,85 +0,0 @@
-{
-  "name": "yargs",
-  "version": "3.10.0",
-  "description": "Light-weight option parsing with an argv hash. No optstrings attached.",
-  "main": "./index.js",
-  "files": [
-    "index.js",
-    "lib",
-    "completion.sh.hbs",
-    "LICENSE"
-  ],
-  "dependencies": {
-    "camelcase": "^1.0.2",
-    "cliui": "^2.1.0",
-    "decamelize": "^1.0.0",
-    "window-size": "0.1.0"
-  },
-  "devDependencies": {
-    "chai": "^2.2.0",
-    "coveralls": "^2.11.2",
-    "hashish": "0.0.4",
-    "mocha": "^2.2.1",
-    "nyc": "^2.2.1",
-    "standard": "^3.11.1"
-  },
-  "scripts": {
-    "test": "standard && nyc mocha --check-leaks && nyc report",
-    "coverage": "nyc report --reporter=text-lcov | coveralls"
-  },
-  "repository": {
-    "type": "git",
-    "url": "http://github.com/bcoe/yargs.git"
-  },
-  "standard": {
-    "ignore": [
-      "**/example/**"
-    ],
-    "globals": [
-      "it"
-    ]
-  },
-  "keywords": [
-    "argument",
-    "args",
-    "option",
-    "parser",
-    "parsing",
-    "cli",
-    "command"
-  ],
-  "author": {
-    "name": "Alex Ford",
-    "email": "Alex.Ford@CodeTunnel.com",
-    "url": "http://CodeTunnel.com"
-  },
-  "contributors": [
-    {
-      "name": "Benjamin Coe",
-      "email": "ben@npmjs.com",
-      "url": "https://github.com/bcoe"
-    },
-    {
-      "name": "Chris Needham",
-      "email": "chris@chrisneedham.com",
-      "url": "http://chrisneedham.com"
-    },
-    {
-      "name": "James Nylen",
-      "email": "jnylen@gmail.com",
-      "url": "https://github.com/nylen"
-    },
-    {
-      "name": "Benjamin Horsleben",
-      "url": "https://github.com/fizker"
-    },
-    {
-      "name": "Lin Clark",
-      "url": "https://github.com/linclark"
-    }
-  ],
-  "license": "MIT",
-  "engine": {
-    "node": ">=0.4"
-  }
-}
diff --git a/node_modules/uglify-js/package.json b/node_modules/uglify-js/package.json
index a06c051f3..d22110be8 100644
--- a/node_modules/uglify-js/package.json
+++ b/node_modules/uglify-js/package.json
@@ -4,7 +4,7 @@
   "homepage": "http://lisperator.net/uglifyjs",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "2.8.27",
+  "version": "3.0.27",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -29,23 +29,16 @@
     "LICENSE"
   ],
   "dependencies": {
-    "source-map": "~0.5.1",
-    "yargs": "~3.10.0"
+    "commander": "~2.11.0",
+    "source-map": "~0.5.1"
   },
   "devDependencies": {
-    "acorn": "~5.0.3",
-    "mocha": "~2.3.4"
-  },
-  "optionalDependencies": {
-    "uglify-to-browserify": "~1.0.0"
-  },
-  "browserify": {
-    "transform": [
-      "uglify-to-browserify"
-    ]
+    "acorn": "~5.1.1",
+    "mocha": "~3.4.2",
+    "semver": "~5.3.0"
   },
   "scripts": {
     "test": "node test/run-tests.js"
   },
-  "keywords": ["uglify", "uglify-js", "minify", "minifier"]
+  "keywords": ["uglify", "uglify-js", "minify", "minifier", "es5"]
 }
diff --git a/node_modules/uglify-js/tools/domprops.json b/node_modules/uglify-js/tools/domprops.json
index 6f6c221db..481e8018d 100644
--- a/node_modules/uglify-js/tools/domprops.json
+++ b/node_modules/uglify-js/tools/domprops.json
@@ -1,5603 +1,5601 @@
-{
-    "props": [
-        "$&",
-        "$'",
-        "$*",
-        "$+",
-        "$1",
-        "$2",
-        "$3",
-        "$4",
-        "$5",
-        "$6",
-        "$7",
-        "$8",
-        "$9",
-        "$_",
-        "$`",
-        "$input",
-        "@@iterator",
-        "ABORT_ERR",
-        "ACTIVE",
-        "ACTIVE_ATTRIBUTES",
-        "ACTIVE_TEXTURE",
-        "ACTIVE_UNIFORMS",
-        "ADDITION",
-        "ALIASED_LINE_WIDTH_RANGE",
-        "ALIASED_POINT_SIZE_RANGE",
-        "ALLOW_KEYBOARD_INPUT",
-        "ALLPASS",
-        "ALPHA",
-        "ALPHA_BITS",
-        "ALT_MASK",
-        "ALWAYS",
-        "ANY_TYPE",
-        "ANY_UNORDERED_NODE_TYPE",
-        "ARRAY_BUFFER",
-        "ARRAY_BUFFER_BINDING",
-        "ATTACHED_SHADERS",
-        "ATTRIBUTE_NODE",
-        "AT_TARGET",
-        "AddSearchProvider",
-        "AnalyserNode",
-        "AnimationEvent",
-        "AnonXMLHttpRequest",
-        "ApplicationCache",
-        "ApplicationCacheErrorEvent",
-        "Array",
-        "ArrayBuffer",
-        "Attr",
-        "Audio",
-        "AudioBuffer",
-        "AudioBufferSourceNode",
-        "AudioContext",
-        "AudioDestinationNode",
-        "AudioListener",
-        "AudioNode",
-        "AudioParam",
-        "AudioProcessingEvent",
-        "AudioStreamTrack",
-        "AutocompleteErrorEvent",
-        "BACK",
-        "BAD_BOUNDARYPOINTS_ERR",
-        "BANDPASS",
-        "BLEND",
-        "BLEND_COLOR",
-        "BLEND_DST_ALPHA",
-        "BLEND_DST_RGB",
-        "BLEND_EQUATION",
-        "BLEND_EQUATION_ALPHA",
-        "BLEND_EQUATION_RGB",
-        "BLEND_SRC_ALPHA",
-        "BLEND_SRC_RGB",
-        "BLUE_BITS",
-        "BLUR",
-        "BOOL",
-        "BOOLEAN_TYPE",
-        "BOOL_VEC2",
-        "BOOL_VEC3",
-        "BOOL_VEC4",
-        "BOTH",
-        "BROWSER_DEFAULT_WEBGL",
-        "BUBBLING_PHASE",
-        "BUFFER_SIZE",
-        "BUFFER_USAGE",
-        "BYTE",
-        "BYTES_PER_ELEMENT",
-        "BarProp",
-        "BaseHref",
-        "BatteryManager",
-        "BeforeLoadEvent",
-        "BeforeUnloadEvent",
-        "BiquadFilterNode",
-        "Blob",
-        "BlobEvent",
-        "Boolean",
-        "CAPTURING_PHASE",
-        "CCW",
-        "CDATASection",
-        "CDATA_SECTION_NODE",
-        "CHANGE",
-        "CHARSET_RULE",
-        "CHECKING",
-        "CLAMP_TO_EDGE",
-        "CLICK",
-        "CLOSED",
-        "CLOSING",
-        "COLOR_ATTACHMENT0",
-        "COLOR_BUFFER_BIT",
-        "COLOR_CLEAR_VALUE",
-        "COLOR_WRITEMASK",
-        "COMMENT_NODE",
-        "COMPILE_STATUS",
-        "COMPRESSED_RGBA_S3TC_DXT1_EXT",
-        "COMPRESSED_RGBA_S3TC_DXT3_EXT",
-        "COMPRESSED_RGBA_S3TC_DXT5_EXT",
-        "COMPRESSED_RGB_S3TC_DXT1_EXT",
-        "COMPRESSED_TEXTURE_FORMATS",
-        "CONNECTING",
-        "CONSTANT_ALPHA",
-        "CONSTANT_COLOR",
-        "CONSTRAINT_ERR",
-        "CONTEXT_LOST_WEBGL",
-        "CONTROL_MASK",
-        "COUNTER_STYLE_RULE",
-        "CSS",
-        "CSS2Properties",
-        "CSSCharsetRule",
-        "CSSConditionRule",
-        "CSSCounterStyleRule",
-        "CSSFontFaceRule",
-        "CSSFontFeatureValuesRule",
-        "CSSGroupingRule",
-        "CSSImportRule",
-        "CSSKeyframeRule",
-        "CSSKeyframesRule",
-        "CSSMediaRule",
-        "CSSMozDocumentRule",
-        "CSSNameSpaceRule",
-        "CSSPageRule",
-        "CSSPrimitiveValue",
-        "CSSRule",
-        "CSSRuleList",
-        "CSSStyleDeclaration",
-        "CSSStyleRule",
-        "CSSStyleSheet",
-        "CSSSupportsRule",
-        "CSSUnknownRule",
-        "CSSValue",
-        "CSSValueList",
-        "CSSVariablesDeclaration",
-        "CSSVariablesRule",
-        "CSSViewportRule",
-        "CSS_ATTR",
-        "CSS_CM",
-        "CSS_COUNTER",
-        "CSS_CUSTOM",
-        "CSS_DEG",
-        "CSS_DIMENSION",
-        "CSS_EMS",
-        "CSS_EXS",
-        "CSS_FILTER_BLUR",
-        "CSS_FILTER_BRIGHTNESS",
-        "CSS_FILTER_CONTRAST",
-        "CSS_FILTER_CUSTOM",
-        "CSS_FILTER_DROP_SHADOW",
-        "CSS_FILTER_GRAYSCALE",
-        "CSS_FILTER_HUE_ROTATE",
-        "CSS_FILTER_INVERT",
-        "CSS_FILTER_OPACITY",
-        "CSS_FILTER_REFERENCE",
-        "CSS_FILTER_SATURATE",
-        "CSS_FILTER_SEPIA",
-        "CSS_GRAD",
-        "CSS_HZ",
-        "CSS_IDENT",
-        "CSS_IN",
-        "CSS_INHERIT",
-        "CSS_KHZ",
-        "CSS_MATRIX",
-        "CSS_MATRIX3D",
-        "CSS_MM",
-        "CSS_MS",
-        "CSS_NUMBER",
-        "CSS_PC",
-        "CSS_PERCENTAGE",
-        "CSS_PERSPECTIVE",
-        "CSS_PRIMITIVE_VALUE",
-        "CSS_PT",
-        "CSS_PX",
-        "CSS_RAD",
-        "CSS_RECT",
-        "CSS_RGBCOLOR",
-        "CSS_ROTATE",
-        "CSS_ROTATE3D",
-        "CSS_ROTATEX",
-        "CSS_ROTATEY",
-        "CSS_ROTATEZ",
-        "CSS_S",
-        "CSS_SCALE",
-        "CSS_SCALE3D",
-        "CSS_SCALEX",
-        "CSS_SCALEY",
-        "CSS_SCALEZ",
-        "CSS_SKEW",
-        "CSS_SKEWX",
-        "CSS_SKEWY",
-        "CSS_STRING",
-        "CSS_TRANSLATE",
-        "CSS_TRANSLATE3D",
-        "CSS_TRANSLATEX",
-        "CSS_TRANSLATEY",
-        "CSS_TRANSLATEZ",
-        "CSS_UNKNOWN",
-        "CSS_URI",
-        "CSS_VALUE_LIST",
-        "CSS_VH",
-        "CSS_VMAX",
-        "CSS_VMIN",
-        "CSS_VW",
-        "CULL_FACE",
-        "CULL_FACE_MODE",
-        "CURRENT_PROGRAM",
-        "CURRENT_VERTEX_ATTRIB",
-        "CUSTOM",
-        "CW",
-        "CanvasGradient",
-        "CanvasPattern",
-        "CanvasRenderingContext2D",
-        "CaretPosition",
-        "ChannelMergerNode",
-        "ChannelSplitterNode",
-        "CharacterData",
-        "ClientRect",
-        "ClientRectList",
-        "Clipboard",
-        "ClipboardEvent",
-        "CloseEvent",
-        "Collator",
-        "CommandEvent",
-        "Comment",
-        "CompositionEvent",
-        "Console",
-        "Controllers",
-        "ConvolverNode",
-        "Counter",
-        "Crypto",
-        "CryptoKey",
-        "CustomEvent",
-        "DATABASE_ERR",
-        "DATA_CLONE_ERR",
-        "DATA_ERR",
-        "DBLCLICK",
-        "DECR",
-        "DECR_WRAP",
-        "DELETE_STATUS",
-        "DEPTH_ATTACHMENT",
-        "DEPTH_BITS",
-        "DEPTH_BUFFER_BIT",
-        "DEPTH_CLEAR_VALUE",
-        "DEPTH_COMPONENT",
-        "DEPTH_COMPONENT16",
-        "DEPTH_FUNC",
-        "DEPTH_RANGE",
-        "DEPTH_STENCIL",
-        "DEPTH_STENCIL_ATTACHMENT",
-        "DEPTH_TEST",
-        "DEPTH_WRITEMASK",
-        "DIRECTION_DOWN",
-        "DIRECTION_LEFT",
-        "DIRECTION_RIGHT",
-        "DIRECTION_UP",
-        "DISABLED",
-        "DISPATCH_REQUEST_ERR",
-        "DITHER",
-        "DOCUMENT_FRAGMENT_NODE",
-        "DOCUMENT_NODE",
-        "DOCUMENT_POSITION_CONTAINED_BY",
-        "DOCUMENT_POSITION_CONTAINS",
-        "DOCUMENT_POSITION_DISCONNECTED",
-        "DOCUMENT_POSITION_FOLLOWING",
-        "DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC",
-        "DOCUMENT_POSITION_PRECEDING",
-        "DOCUMENT_TYPE_NODE",
-        "DOMCursor",
-        "DOMError",
-        "DOMException",
-        "DOMImplementation",
-        "DOMImplementationLS",
-        "DOMMatrix",
-        "DOMMatrixReadOnly",
-        "DOMParser",
-        "DOMPoint",
-        "DOMPointReadOnly",
-        "DOMQuad",
-        "DOMRect",
-        "DOMRectList",
-        "DOMRectReadOnly",
-        "DOMRequest",
-        "DOMSTRING_SIZE_ERR",
-        "DOMSettableTokenList",
-        "DOMStringList",
-        "DOMStringMap",
-        "DOMTokenList",
-        "DOMTransactionEvent",
-        "DOM_DELTA_LINE",
-        "DOM_DELTA_PAGE",
-        "DOM_DELTA_PIXEL",
-        "DOM_INPUT_METHOD_DROP",
-        "DOM_INPUT_METHOD_HANDWRITING",
-        "DOM_INPUT_METHOD_IME",
-        "DOM_INPUT_METHOD_KEYBOARD",
-        "DOM_INPUT_METHOD_MULTIMODAL",
-        "DOM_INPUT_METHOD_OPTION",
-        "DOM_INPUT_METHOD_PASTE",
-        "DOM_INPUT_METHOD_SCRIPT",
-        "DOM_INPUT_METHOD_UNKNOWN",
-        "DOM_INPUT_METHOD_VOICE",
-        "DOM_KEY_LOCATION_JOYSTICK",
-        "DOM_KEY_LOCATION_LEFT",
-        "DOM_KEY_LOCATION_MOBILE",
-        "DOM_KEY_LOCATION_NUMPAD",
-        "DOM_KEY_LOCATION_RIGHT",
-        "DOM_KEY_LOCATION_STANDARD",
-        "DOM_VK_0",
-        "DOM_VK_1",
-        "DOM_VK_2",
-        "DOM_VK_3",
-        "DOM_VK_4",
-        "DOM_VK_5",
-        "DOM_VK_6",
-        "DOM_VK_7",
-        "DOM_VK_8",
-        "DOM_VK_9",
-        "DOM_VK_A",
-        "DOM_VK_ACCEPT",
-        "DOM_VK_ADD",
-        "DOM_VK_ALT",
-        "DOM_VK_ALTGR",
-        "DOM_VK_AMPERSAND",
-        "DOM_VK_ASTERISK",
-        "DOM_VK_AT",
-        "DOM_VK_ATTN",
-        "DOM_VK_B",
-        "DOM_VK_BACKSPACE",
-        "DOM_VK_BACK_QUOTE",
-        "DOM_VK_BACK_SLASH",
-        "DOM_VK_BACK_SPACE",
-        "DOM_VK_C",
-        "DOM_VK_CANCEL",
-        "DOM_VK_CAPS_LOCK",
-        "DOM_VK_CIRCUMFLEX",
-        "DOM_VK_CLEAR",
-        "DOM_VK_CLOSE_BRACKET",
-        "DOM_VK_CLOSE_CURLY_BRACKET",
-        "DOM_VK_CLOSE_PAREN",
-        "DOM_VK_COLON",
-        "DOM_VK_COMMA",
-        "DOM_VK_CONTEXT_MENU",
-        "DOM_VK_CONTROL",
-        "DOM_VK_CONVERT",
-        "DOM_VK_CRSEL",
-        "DOM_VK_CTRL",
-        "DOM_VK_D",
-        "DOM_VK_DECIMAL",
-        "DOM_VK_DELETE",
-        "DOM_VK_DIVIDE",
-        "DOM_VK_DOLLAR",
-        "DOM_VK_DOUBLE_QUOTE",
-        "DOM_VK_DOWN",
-        "DOM_VK_E",
-        "DOM_VK_EISU",
-        "DOM_VK_END",
-        "DOM_VK_ENTER",
-        "DOM_VK_EQUALS",
-        "DOM_VK_EREOF",
-        "DOM_VK_ESCAPE",
-        "DOM_VK_EXCLAMATION",
-        "DOM_VK_EXECUTE",
-        "DOM_VK_EXSEL",
-        "DOM_VK_F",
-        "DOM_VK_F1",
-        "DOM_VK_F10",
-        "DOM_VK_F11",
-        "DOM_VK_F12",
-        "DOM_VK_F13",
-        "DOM_VK_F14",
-        "DOM_VK_F15",
-        "DOM_VK_F16",
-        "DOM_VK_F17",
-        "DOM_VK_F18",
-        "DOM_VK_F19",
-        "DOM_VK_F2",
-        "DOM_VK_F20",
-        "DOM_VK_F21",
-        "DOM_VK_F22",
-        "DOM_VK_F23",
-        "DOM_VK_F24",
-        "DOM_VK_F25",
-        "DOM_VK_F26",
-        "DOM_VK_F27",
-        "DOM_VK_F28",
-        "DOM_VK_F29",
-        "DOM_VK_F3",
-        "DOM_VK_F30",
-        "DOM_VK_F31",
-        "DOM_VK_F32",
-        "DOM_VK_F33",
-        "DOM_VK_F34",
-        "DOM_VK_F35",
-        "DOM_VK_F36",
-        "DOM_VK_F4",
-        "DOM_VK_F5",
-        "DOM_VK_F6",
-        "DOM_VK_F7",
-        "DOM_VK_F8",
-        "DOM_VK_F9",
-        "DOM_VK_FINAL",
-        "DOM_VK_FRONT",
-        "DOM_VK_G",
-        "DOM_VK_GREATER_THAN",
-        "DOM_VK_H",
-        "DOM_VK_HANGUL",
-        "DOM_VK_HANJA",
-        "DOM_VK_HASH",
-        "DOM_VK_HELP",
-        "DOM_VK_HK_TOGGLE",
-        "DOM_VK_HOME",
-        "DOM_VK_HYPHEN_MINUS",
-        "DOM_VK_I",
-        "DOM_VK_INSERT",
-        "DOM_VK_J",
-        "DOM_VK_JUNJA",
-        "DOM_VK_K",
-        "DOM_VK_KANA",
-        "DOM_VK_KANJI",
-        "DOM_VK_L",
-        "DOM_VK_LEFT",
-        "DOM_VK_LEFT_TAB",
-        "DOM_VK_LESS_THAN",
-        "DOM_VK_M",
-        "DOM_VK_META",
-        "DOM_VK_MODECHANGE",
-        "DOM_VK_MULTIPLY",
-        "DOM_VK_N",
-        "DOM_VK_NONCONVERT",
-        "DOM_VK_NUMPAD0",
-        "DOM_VK_NUMPAD1",
-        "DOM_VK_NUMPAD2",
-        "DOM_VK_NUMPAD3",
-        "DOM_VK_NUMPAD4",
-        "DOM_VK_NUMPAD5",
-        "DOM_VK_NUMPAD6",
-        "DOM_VK_NUMPAD7",
-        "DOM_VK_NUMPAD8",
-        "DOM_VK_NUMPAD9",
-        "DOM_VK_NUM_LOCK",
-        "DOM_VK_O",
-        "DOM_VK_OEM_1",
-        "DOM_VK_OEM_102",
-        "DOM_VK_OEM_2",
-        "DOM_VK_OEM_3",
-        "DOM_VK_OEM_4",
-        "DOM_VK_OEM_5",
-        "DOM_VK_OEM_6",
-        "DOM_VK_OEM_7",
-        "DOM_VK_OEM_8",
-        "DOM_VK_OEM_COMMA",
-        "DOM_VK_OEM_MINUS",
-        "DOM_VK_OEM_PERIOD",
-        "DOM_VK_OEM_PLUS",
-        "DOM_VK_OPEN_BRACKET",
-        "DOM_VK_OPEN_CURLY_BRACKET",
-        "DOM_VK_OPEN_PAREN",
-        "DOM_VK_P",
-        "DOM_VK_PA1",
-        "DOM_VK_PAGEDOWN",
-        "DOM_VK_PAGEUP",
-        "DOM_VK_PAGE_DOWN",
-        "DOM_VK_PAGE_UP",
-        "DOM_VK_PAUSE",
-        "DOM_VK_PERCENT",
-        "DOM_VK_PERIOD",
-        "DOM_VK_PIPE",
-        "DOM_VK_PLAY",
-        "DOM_VK_PLUS",
-        "DOM_VK_PRINT",
-        "DOM_VK_PRINTSCREEN",
-        "DOM_VK_PROCESSKEY",
-        "DOM_VK_PROPERITES",
-        "DOM_VK_Q",
-        "DOM_VK_QUESTION_MARK",
-        "DOM_VK_QUOTE",
-        "DOM_VK_R",
-        "DOM_VK_REDO",
-        "DOM_VK_RETURN",
-        "DOM_VK_RIGHT",
-        "DOM_VK_S",
-        "DOM_VK_SCROLL_LOCK",
-        "DOM_VK_SELECT",
-        "DOM_VK_SEMICOLON",
-        "DOM_VK_SEPARATOR",
-        "DOM_VK_SHIFT",
-        "DOM_VK_SLASH",
-        "DOM_VK_SLEEP",
-        "DOM_VK_SPACE",
-        "DOM_VK_SUBTRACT",
-        "DOM_VK_T",
-        "DOM_VK_TAB",
-        "DOM_VK_TILDE",
-        "DOM_VK_U",
-        "DOM_VK_UNDERSCORE",
-        "DOM_VK_UNDO",
-        "DOM_VK_UNICODE",
-        "DOM_VK_UP",
-        "DOM_VK_V",
-        "DOM_VK_VOLUME_DOWN",
-        "DOM_VK_VOLUME_MUTE",
-        "DOM_VK_VOLUME_UP",
-        "DOM_VK_W",
-        "DOM_VK_WIN",
-        "DOM_VK_WINDOW",
-        "DOM_VK_WIN_ICO_00",
-        "DOM_VK_WIN_ICO_CLEAR",
-        "DOM_VK_WIN_ICO_HELP",
-        "DOM_VK_WIN_OEM_ATTN",
-        "DOM_VK_WIN_OEM_AUTO",
-        "DOM_VK_WIN_OEM_BACKTAB",
-        "DOM_VK_WIN_OEM_CLEAR",
-        "DOM_VK_WIN_OEM_COPY",
-        "DOM_VK_WIN_OEM_CUSEL",
-        "DOM_VK_WIN_OEM_ENLW",
-        "DOM_VK_WIN_OEM_FINISH",
-        "DOM_VK_WIN_OEM_FJ_JISHO",
-        "DOM_VK_WIN_OEM_FJ_LOYA",
-        "DOM_VK_WIN_OEM_FJ_MASSHOU",
-        "DOM_VK_WIN_OEM_FJ_ROYA",
-        "DOM_VK_WIN_OEM_FJ_TOUROKU",
-        "DOM_VK_WIN_OEM_JUMP",
-        "DOM_VK_WIN_OEM_PA1",
-        "DOM_VK_WIN_OEM_PA2",
-        "DOM_VK_WIN_OEM_PA3",
-        "DOM_VK_WIN_OEM_RESET",
-        "DOM_VK_WIN_OEM_WSCTRL",
-        "DOM_VK_X",
-        "DOM_VK_XF86XK_ADD_FAVORITE",
-        "DOM_VK_XF86XK_APPLICATION_LEFT",
-        "DOM_VK_XF86XK_APPLICATION_RIGHT",
-        "DOM_VK_XF86XK_AUDIO_CYCLE_TRACK",
-        "DOM_VK_XF86XK_AUDIO_FORWARD",
-        "DOM_VK_XF86XK_AUDIO_LOWER_VOLUME",
-        "DOM_VK_XF86XK_AUDIO_MEDIA",
-        "DOM_VK_XF86XK_AUDIO_MUTE",
-        "DOM_VK_XF86XK_AUDIO_NEXT",
-        "DOM_VK_XF86XK_AUDIO_PAUSE",
-        "DOM_VK_XF86XK_AUDIO_PLAY",
-        "DOM_VK_XF86XK_AUDIO_PREV",
-        "DOM_VK_XF86XK_AUDIO_RAISE_VOLUME",
-        "DOM_VK_XF86XK_AUDIO_RANDOM_PLAY",
-        "DOM_VK_XF86XK_AUDIO_RECORD",
-        "DOM_VK_XF86XK_AUDIO_REPEAT",
-        "DOM_VK_XF86XK_AUDIO_REWIND",
-        "DOM_VK_XF86XK_AUDIO_STOP",
-        "DOM_VK_XF86XK_AWAY",
-        "DOM_VK_XF86XK_BACK",
-        "DOM_VK_XF86XK_BACK_FORWARD",
-        "DOM_VK_XF86XK_BATTERY",
-        "DOM_VK_XF86XK_BLUE",
-        "DOM_VK_XF86XK_BLUETOOTH",
-        "DOM_VK_XF86XK_BOOK",
-        "DOM_VK_XF86XK_BRIGHTNESS_ADJUST",
-        "DOM_VK_XF86XK_CALCULATOR",
-        "DOM_VK_XF86XK_CALENDAR",
-        "DOM_VK_XF86XK_CD",
-        "DOM_VK_XF86XK_CLOSE",
-        "DOM_VK_XF86XK_COMMUNITY",
-        "DOM_VK_XF86XK_CONTRAST_ADJUST",
-        "DOM_VK_XF86XK_COPY",
-        "DOM_VK_XF86XK_CUT",
-        "DOM_VK_XF86XK_CYCLE_ANGLE",
-        "DOM_VK_XF86XK_DISPLAY",
-        "DOM_VK_XF86XK_DOCUMENTS",
-        "DOM_VK_XF86XK_DOS",
-        "DOM_VK_XF86XK_EJECT",
-        "DOM_VK_XF86XK_EXCEL",
-        "DOM_VK_XF86XK_EXPLORER",
-        "DOM_VK_XF86XK_FAVORITES",
-        "DOM_VK_XF86XK_FINANCE",
-        "DOM_VK_XF86XK_FORWARD",
-        "DOM_VK_XF86XK_FRAME_BACK",
-        "DOM_VK_XF86XK_FRAME_FORWARD",
-        "DOM_VK_XF86XK_GAME",
-        "DOM_VK_XF86XK_GO",
-        "DOM_VK_XF86XK_GREEN",
-        "DOM_VK_XF86XK_HIBERNATE",
-        "DOM_VK_XF86XK_HISTORY",
-        "DOM_VK_XF86XK_HOME_PAGE",
-        "DOM_VK_XF86XK_HOT_LINKS",
-        "DOM_VK_XF86XK_I_TOUCH",
-        "DOM_VK_XF86XK_KBD_BRIGHTNESS_DOWN",
-        "DOM_VK_XF86XK_KBD_BRIGHTNESS_UP",
-        "DOM_VK_XF86XK_KBD_LIGHT_ON_OFF",
-        "DOM_VK_XF86XK_LAUNCH0",
-        "DOM_VK_XF86XK_LAUNCH1",
-        "DOM_VK_XF86XK_LAUNCH2",
-        "DOM_VK_XF86XK_LAUNCH3",
-        "DOM_VK_XF86XK_LAUNCH4",
-        "DOM_VK_XF86XK_LAUNCH5",
-        "DOM_VK_XF86XK_LAUNCH6",
-        "DOM_VK_XF86XK_LAUNCH7",
-        "DOM_VK_XF86XK_LAUNCH8",
-        "DOM_VK_XF86XK_LAUNCH9",
-        "DOM_VK_XF86XK_LAUNCH_A",
-        "DOM_VK_XF86XK_LAUNCH_B",
-        "DOM_VK_XF86XK_LAUNCH_C",
-        "DOM_VK_XF86XK_LAUNCH_D",
-        "DOM_VK_XF86XK_LAUNCH_E",
-        "DOM_VK_XF86XK_LAUNCH_F",
-        "DOM_VK_XF86XK_LIGHT_BULB",
-        "DOM_VK_XF86XK_LOG_OFF",
-        "DOM_VK_XF86XK_MAIL",
-        "DOM_VK_XF86XK_MAIL_FORWARD",
-        "DOM_VK_XF86XK_MARKET",
-        "DOM_VK_XF86XK_MEETING",
-        "DOM_VK_XF86XK_MEMO",
-        "DOM_VK_XF86XK_MENU_KB",
-        "DOM_VK_XF86XK_MENU_PB",
-        "DOM_VK_XF86XK_MESSENGER",
-        "DOM_VK_XF86XK_MON_BRIGHTNESS_DOWN",
-        "DOM_VK_XF86XK_MON_BRIGHTNESS_UP",
-        "DOM_VK_XF86XK_MUSIC",
-        "DOM_VK_XF86XK_MY_COMPUTER",
-        "DOM_VK_XF86XK_MY_SITES",
-        "DOM_VK_XF86XK_NEW",
-        "DOM_VK_XF86XK_NEWS",
-        "DOM_VK_XF86XK_OFFICE_HOME",
-        "DOM_VK_XF86XK_OPEN",
-        "DOM_VK_XF86XK_OPEN_URL",
-        "DOM_VK_XF86XK_OPTION",
-        "DOM_VK_XF86XK_PASTE",
-        "DOM_VK_XF86XK_PHONE",
-        "DOM_VK_XF86XK_PICTURES",
-        "DOM_VK_XF86XK_POWER_DOWN",
-        "DOM_VK_XF86XK_POWER_OFF",
-        "DOM_VK_XF86XK_RED",
-        "DOM_VK_XF86XK_REFRESH",
-        "DOM_VK_XF86XK_RELOAD",
-        "DOM_VK_XF86XK_REPLY",
-        "DOM_VK_XF86XK_ROCKER_DOWN",
-        "DOM_VK_XF86XK_ROCKER_ENTER",
-        "DOM_VK_XF86XK_ROCKER_UP",
-        "DOM_VK_XF86XK_ROTATE_WINDOWS",
-        "DOM_VK_XF86XK_ROTATION_KB",
-        "DOM_VK_XF86XK_ROTATION_PB",
-        "DOM_VK_XF86XK_SAVE",
-        "DOM_VK_XF86XK_SCREEN_SAVER",
-        "DOM_VK_XF86XK_SCROLL_CLICK",
-        "DOM_VK_XF86XK_SCROLL_DOWN",
-        "DOM_VK_XF86XK_SCROLL_UP",
-        "DOM_VK_XF86XK_SEARCH",
-        "DOM_VK_XF86XK_SEND",
-        "DOM_VK_XF86XK_SHOP",
-        "DOM_VK_XF86XK_SPELL",
-        "DOM_VK_XF86XK_SPLIT_SCREEN",
-        "DOM_VK_XF86XK_STANDBY",
-        "DOM_VK_XF86XK_START",
-        "DOM_VK_XF86XK_STOP",
-        "DOM_VK_XF86XK_SUBTITLE",
-        "DOM_VK_XF86XK_SUPPORT",
-        "DOM_VK_XF86XK_SUSPEND",
-        "DOM_VK_XF86XK_TASK_PANE",
-        "DOM_VK_XF86XK_TERMINAL",
-        "DOM_VK_XF86XK_TIME",
-        "DOM_VK_XF86XK_TOOLS",
-        "DOM_VK_XF86XK_TOP_MENU",
-        "DOM_VK_XF86XK_TO_DO_LIST",
-        "DOM_VK_XF86XK_TRAVEL",
-        "DOM_VK_XF86XK_USER1KB",
-        "DOM_VK_XF86XK_USER2KB",
-        "DOM_VK_XF86XK_USER_PB",
-        "DOM_VK_XF86XK_UWB",
-        "DOM_VK_XF86XK_VENDOR_HOME",
-        "DOM_VK_XF86XK_VIDEO",
-        "DOM_VK_XF86XK_VIEW",
-        "DOM_VK_XF86XK_WAKE_UP",
-        "DOM_VK_XF86XK_WEB_CAM",
-        "DOM_VK_XF86XK_WHEEL_BUTTON",
-        "DOM_VK_XF86XK_WLAN",
-        "DOM_VK_XF86XK_WORD",
-        "DOM_VK_XF86XK_WWW",
-        "DOM_VK_XF86XK_XFER",
-        "DOM_VK_XF86XK_YELLOW",
-        "DOM_VK_XF86XK_ZOOM_IN",
-        "DOM_VK_XF86XK_ZOOM_OUT",
-        "DOM_VK_Y",
-        "DOM_VK_Z",
-        "DOM_VK_ZOOM",
-        "DONE",
-        "DONT_CARE",
-        "DOWNLOADING",
-        "DRAGDROP",
-        "DST_ALPHA",
-        "DST_COLOR",
-        "DYNAMIC_DRAW",
-        "DataChannel",
-        "DataTransfer",
-        "DataTransferItem",
-        "DataTransferItemList",
-        "DataView",
-        "Date",
-        "DateTimeFormat",
-        "DelayNode",
-        "DesktopNotification",
-        "DesktopNotificationCenter",
-        "DeviceLightEvent",
-        "DeviceMotionEvent",
-        "DeviceOrientationEvent",
-        "DeviceProximityEvent",
-        "DeviceStorage",
-        "DeviceStorageChangeEvent",
-        "Document",
-        "DocumentFragment",
-        "DocumentType",
-        "DragEvent",
-        "DynamicsCompressorNode",
-        "E",
-        "ELEMENT_ARRAY_BUFFER",
-        "ELEMENT_ARRAY_BUFFER_BINDING",
-        "ELEMENT_NODE",
-        "EMPTY",
-        "ENCODING_ERR",
-        "ENDED",
-        "END_TO_END",
-        "END_TO_START",
-        "ENTITY_NODE",
-        "ENTITY_REFERENCE_NODE",
-        "EPSILON",
-        "EQUAL",
-        "EQUALPOWER",
-        "ERROR",
-        "EXPONENTIAL_DISTANCE",
-        "Element",
-        "ElementQuery",
-        "Entity",
-        "EntityReference",
-        "Error",
-        "ErrorEvent",
-        "EvalError",
-        "Event",
-        "EventException",
-        "EventSource",
-        "EventTarget",
-        "External",
-        "FASTEST",
-        "FIDOSDK",
-        "FILTER_ACCEPT",
-        "FILTER_INTERRUPT",
-        "FILTER_REJECT",
-        "FILTER_SKIP",
-        "FINISHED_STATE",
-        "FIRST_ORDERED_NODE_TYPE",
-        "FLOAT",
-        "FLOAT_MAT2",
-        "FLOAT_MAT3",
-        "FLOAT_MAT4",
-        "FLOAT_VEC2",
-        "FLOAT_VEC3",
-        "FLOAT_VEC4",
-        "FOCUS",
-        "FONT_FACE_RULE",
-        "FONT_FEATURE_VALUES_RULE",
-        "FRAGMENT_SHADER",
-        "FRAGMENT_SHADER_DERIVATIVE_HINT_OES",
-        "FRAMEBUFFER",
-        "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",
-        "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",
-        "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",
-        "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",
-        "FRAMEBUFFER_BINDING",
-        "FRAMEBUFFER_COMPLETE",
-        "FRAMEBUFFER_INCOMPLETE_ATTACHMENT",
-        "FRAMEBUFFER_INCOMPLETE_DIMENSIONS",
-        "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",
-        "FRAMEBUFFER_UNSUPPORTED",
-        "FRONT",
-        "FRONT_AND_BACK",
-        "FRONT_FACE",
-        "FUNC_ADD",
-        "FUNC_REVERSE_SUBTRACT",
-        "FUNC_SUBTRACT",
-        "Feed",
-        "FeedEntry",
-        "File",
-        "FileError",
-        "FileList",
-        "FileReader",
-        "FindInPage",
-        "Float32Array",
-        "Float64Array",
-        "FocusEvent",
-        "FontFace",
-        "FormData",
-        "Function",
-        "GENERATE_MIPMAP_HINT",
-        "GEQUAL",
-        "GREATER",
-        "GREEN_BITS",
-        "GainNode",
-        "Gamepad",
-        "GamepadButton",
-        "GamepadEvent",
-        "GestureEvent",
-        "HAVE_CURRENT_DATA",
-        "HAVE_ENOUGH_DATA",
-        "HAVE_FUTURE_DATA",
-        "HAVE_METADATA",
-        "HAVE_NOTHING",
-        "HEADERS_RECEIVED",
-        "HIDDEN",
-        "HIERARCHY_REQUEST_ERR",
-        "HIGHPASS",
-        "HIGHSHELF",
-        "HIGH_FLOAT",
-        "HIGH_INT",
-        "HORIZONTAL",
-        "HORIZONTAL_AXIS",
-        "HRTF",
-        "HTMLAllCollection",
-        "HTMLAnchorElement",
-        "HTMLAppletElement",
-        "HTMLAreaElement",
-        "HTMLAudioElement",
-        "HTMLBRElement",
-        "HTMLBaseElement",
-        "HTMLBaseFontElement",
-        "HTMLBlockquoteElement",
-        "HTMLBodyElement",
-        "HTMLButtonElement",
-        "HTMLCanvasElement",
-        "HTMLCollection",
-        "HTMLCommandElement",
-        "HTMLContentElement",
-        "HTMLDListElement",
-        "HTMLDataElement",
-        "HTMLDataListElement",
-        "HTMLDetailsElement",
-        "HTMLDialogElement",
-        "HTMLDirectoryElement",
-        "HTMLDivElement",
-        "HTMLDocument",
-        "HTMLElement",
-        "HTMLEmbedElement",
-        "HTMLFieldSetElement",
-        "HTMLFontElement",
-        "HTMLFormControlsCollection",
-        "HTMLFormElement",
-        "HTMLFrameElement",
-        "HTMLFrameSetElement",
-        "HTMLHRElement",
-        "HTMLHeadElement",
-        "HTMLHeadingElement",
-        "HTMLHtmlElement",
-        "HTMLIFrameElement",
-        "HTMLImageElement",
-        "HTMLInputElement",
-        "HTMLIsIndexElement",
-        "HTMLKeygenElement",
-        "HTMLLIElement",
-        "HTMLLabelElement",
-        "HTMLLegendElement",
-        "HTMLLinkElement",
-        "HTMLMapElement",
-        "HTMLMarqueeElement",
-        "HTMLMediaElement",
-        "HTMLMenuElement",
-        "HTMLMenuItemElement",
-        "HTMLMetaElement",
-        "HTMLMeterElement",
-        "HTMLModElement",
-        "HTMLOListElement",
-        "HTMLObjectElement",
-        "HTMLOptGroupElement",
-        "HTMLOptionElement",
-        "HTMLOptionsCollection",
-        "HTMLOutputElement",
-        "HTMLParagraphElement",
-        "HTMLParamElement",
-        "HTMLPictureElement",
-        "HTMLPreElement",
-        "HTMLProgressElement",
-        "HTMLPropertiesCollection",
-        "HTMLQuoteElement",
-        "HTMLScriptElement",
-        "HTMLSelectElement",
-        "HTMLShadowElement",
-        "HTMLSourceElement",
-        "HTMLSpanElement",
-        "HTMLStyleElement",
-        "HTMLTableCaptionElement",
-        "HTMLTableCellElement",
-        "HTMLTableColElement",
-        "HTMLTableElement",
-        "HTMLTableRowElement",
-        "HTMLTableSectionElement",
-        "HTMLTemplateElement",
-        "HTMLTextAreaElement",
-        "HTMLTimeElement",
-        "HTMLTitleElement",
-        "HTMLTrackElement",
-        "HTMLUListElement",
-        "HTMLUnknownElement",
-        "HTMLVideoElement",
-        "HashChangeEvent",
-        "Headers",
-        "History",
-        "ICE_CHECKING",
-        "ICE_CLOSED",
-        "ICE_COMPLETED",
-        "ICE_CONNECTED",
-        "ICE_FAILED",
-        "ICE_GATHERING",
-        "ICE_WAITING",
-        "IDBCursor",
-        "IDBCursorWithValue",
-        "IDBDatabase",
-        "IDBDatabaseException",
-        "IDBFactory",
-        "IDBFileHandle",
-        "IDBFileRequest",
-        "IDBIndex",
-        "IDBKeyRange",
-        "IDBMutableFile",
-        "IDBObjectStore",
-        "IDBOpenDBRequest",
-        "IDBRequest",
-        "IDBTransaction",
-        "IDBVersionChangeEvent",
-        "IDLE",
-        "IMPLEMENTATION_COLOR_READ_FORMAT",
-        "IMPLEMENTATION_COLOR_READ_TYPE",
-        "IMPORT_RULE",
-        "INCR",
-        "INCR_WRAP",
-        "INDEX_SIZE_ERR",
-        "INT",
-        "INT_VEC2",
-        "INT_VEC3",
-        "INT_VEC4",
-        "INUSE_ATTRIBUTE_ERR",
-        "INVALID_ACCESS_ERR",
-        "INVALID_CHARACTER_ERR",
-        "INVALID_ENUM",
-        "INVALID_EXPRESSION_ERR",
-        "INVALID_FRAMEBUFFER_OPERATION",
-        "INVALID_MODIFICATION_ERR",
-        "INVALID_NODE_TYPE_ERR",
-        "INVALID_OPERATION",
-        "INVALID_STATE_ERR",
-        "INVALID_VALUE",
-        "INVERSE_DISTANCE",
-        "INVERT",
-        "IceCandidate",
-        "Image",
-        "ImageBitmap",
-        "ImageData",
-        "Infinity",
-        "InputEvent",
-        "InputMethodContext",
-        "InstallTrigger",
-        "Int16Array",
-        "Int32Array",
-        "Int8Array",
-        "Intent",
-        "InternalError",
-        "Intl",
-        "IsSearchProviderInstalled",
-        "Iterator",
-        "JSON",
-        "KEEP",
-        "KEYDOWN",
-        "KEYFRAMES_RULE",
-        "KEYFRAME_RULE",
-        "KEYPRESS",
-        "KEYUP",
-        "KeyEvent",
-        "KeyboardEvent",
-        "LENGTHADJUST_SPACING",
-        "LENGTHADJUST_SPACINGANDGLYPHS",
-        "LENGTHADJUST_UNKNOWN",
-        "LEQUAL",
-        "LESS",
-        "LINEAR",
-        "LINEAR_DISTANCE",
-        "LINEAR_MIPMAP_LINEAR",
-        "LINEAR_MIPMAP_NEAREST",
-        "LINES",
-        "LINE_LOOP",
-        "LINE_STRIP",
-        "LINE_WIDTH",
-        "LINK_STATUS",
-        "LIVE",
-        "LN10",
-        "LN2",
-        "LOADED",
-        "LOADING",
-        "LOG10E",
-        "LOG2E",
-        "LOWPASS",
-        "LOWSHELF",
-        "LOW_FLOAT",
-        "LOW_INT",
-        "LSException",
-        "LSParserFilter",
-        "LUMINANCE",
-        "LUMINANCE_ALPHA",
-        "LocalMediaStream",
-        "Location",
-        "MAX_COMBINED_TEXTURE_IMAGE_UNITS",
-        "MAX_CUBE_MAP_TEXTURE_SIZE",
-        "MAX_FRAGMENT_UNIFORM_VECTORS",
-        "MAX_RENDERBUFFER_SIZE",
-        "MAX_SAFE_INTEGER",
-        "MAX_TEXTURE_IMAGE_UNITS",
-        "MAX_TEXTURE_MAX_ANISOTROPY_EXT",
-        "MAX_TEXTURE_SIZE",
-        "MAX_VALUE",
-        "MAX_VARYING_VECTORS",
-        "MAX_VERTEX_ATTRIBS",
-        "MAX_VERTEX_TEXTURE_IMAGE_UNITS",
-        "MAX_VERTEX_UNIFORM_VECTORS",
-        "MAX_VIEWPORT_DIMS",
-        "MEDIA_ERR_ABORTED",
-        "MEDIA_ERR_DECODE",
-        "MEDIA_ERR_ENCRYPTED",
-        "MEDIA_ERR_NETWORK",
-        "MEDIA_ERR_SRC_NOT_SUPPORTED",
-        "MEDIA_KEYERR_CLIENT",
-        "MEDIA_KEYERR_DOMAIN",
-        "MEDIA_KEYERR_HARDWARECHANGE",
-        "MEDIA_KEYERR_OUTPUT",
-        "MEDIA_KEYERR_SERVICE",
-        "MEDIA_KEYERR_UNKNOWN",
-        "MEDIA_RULE",
-        "MEDIUM_FLOAT",
-        "MEDIUM_INT",
-        "META_MASK",
-        "MIN_SAFE_INTEGER",
-        "MIN_VALUE",
-        "MIRRORED_REPEAT",
-        "MODE_ASYNCHRONOUS",
-        "MODE_SYNCHRONOUS",
-        "MODIFICATION",
-        "MOUSEDOWN",
-        "MOUSEDRAG",
-        "MOUSEMOVE",
-        "MOUSEOUT",
-        "MOUSEOVER",
-        "MOUSEUP",
-        "MOZ_KEYFRAMES_RULE",
-        "MOZ_KEYFRAME_RULE",
-        "MOZ_SOURCE_CURSOR",
-        "MOZ_SOURCE_ERASER",
-        "MOZ_SOURCE_KEYBOARD",
-        "MOZ_SOURCE_MOUSE",
-        "MOZ_SOURCE_PEN",
-        "MOZ_SOURCE_TOUCH",
-        "MOZ_SOURCE_UNKNOWN",
-        "MSGESTURE_FLAG_BEGIN",
-        "MSGESTURE_FLAG_CANCEL",
-        "MSGESTURE_FLAG_END",
-        "MSGESTURE_FLAG_INERTIA",
-        "MSGESTURE_FLAG_NONE",
-        "MSPOINTER_TYPE_MOUSE",
-        "MSPOINTER_TYPE_PEN",
-        "MSPOINTER_TYPE_TOUCH",
-        "MS_ASYNC_CALLBACK_STATUS_ASSIGN_DELEGATE",
-        "MS_ASYNC_CALLBACK_STATUS_CANCEL",
-        "MS_ASYNC_CALLBACK_STATUS_CHOOSEANY",
-        "MS_ASYNC_CALLBACK_STATUS_ERROR",
-        "MS_ASYNC_CALLBACK_STATUS_JOIN",
-        "MS_ASYNC_OP_STATUS_CANCELED",
-        "MS_ASYNC_OP_STATUS_ERROR",
-        "MS_ASYNC_OP_STATUS_SUCCESS",
-        "MS_MANIPULATION_STATE_ACTIVE",
-        "MS_MANIPULATION_STATE_CANCELLED",
-        "MS_MANIPULATION_STATE_COMMITTED",
-        "MS_MANIPULATION_STATE_DRAGGING",
-        "MS_MANIPULATION_STATE_INERTIA",
-        "MS_MANIPULATION_STATE_PRESELECT",
-        "MS_MANIPULATION_STATE_SELECTING",
-        "MS_MANIPULATION_STATE_STOPPED",
-        "MS_MEDIA_ERR_ENCRYPTED",
-        "MS_MEDIA_KEYERR_CLIENT",
-        "MS_MEDIA_KEYERR_DOMAIN",
-        "MS_MEDIA_KEYERR_HARDWARECHANGE",
-        "MS_MEDIA_KEYERR_OUTPUT",
-        "MS_MEDIA_KEYERR_SERVICE",
-        "MS_MEDIA_KEYERR_UNKNOWN",
-        "Map",
-        "Math",
-        "MediaController",
-        "MediaDevices",
-        "MediaElementAudioSourceNode",
-        "MediaEncryptedEvent",
-        "MediaError",
-        "MediaKeyError",
-        "MediaKeyEvent",
-        "MediaKeyMessageEvent",
-        "MediaKeyNeededEvent",
-        "MediaKeySession",
-        "MediaKeyStatusMap",
-        "MediaKeySystemAccess",
-        "MediaKeys",
-        "MediaList",
-        "MediaQueryList",
-        "MediaQueryListEvent",
-        "MediaRecorder",
-        "MediaSource",
-        "MediaStream",
-        "MediaStreamAudioDestinationNode",
-        "MediaStreamAudioSourceNode",
-        "MediaStreamEvent",
-        "MediaStreamTrack",
-        "MediaStreamTrackEvent",
-        "MessageChannel",
-        "MessageEvent",
-        "MessagePort",
-        "Methods",
-        "MimeType",
-        "MimeTypeArray",
-        "MouseEvent",
-        "MouseScrollEvent",
-        "MozAnimation",
-        "MozAnimationDelay",
-        "MozAnimationDirection",
-        "MozAnimationDuration",
-        "MozAnimationFillMode",
-        "MozAnimationIterationCount",
-        "MozAnimationName",
-        "MozAnimationPlayState",
-        "MozAnimationTimingFunction",
-        "MozAppearance",
-        "MozBackfaceVisibility",
-        "MozBinding",
-        "MozBorderBottomColors",
-        "MozBorderEnd",
-        "MozBorderEndColor",
-        "MozBorderEndStyle",
-        "MozBorderEndWidth",
-        "MozBorderImage",
-        "MozBorderLeftColors",
-        "MozBorderRightColors",
-        "MozBorderStart",
-        "MozBorderStartColor",
-        "MozBorderStartStyle",
-        "MozBorderStartWidth",
-        "MozBorderTopColors",
-        "MozBoxAlign",
-        "MozBoxDirection",
-        "MozBoxFlex",
-        "MozBoxOrdinalGroup",
-        "MozBoxOrient",
-        "MozBoxPack",
-        "MozBoxSizing",
-        "MozCSSKeyframeRule",
-        "MozCSSKeyframesRule",
-        "MozColumnCount",
-        "MozColumnFill",
-        "MozColumnGap",
-        "MozColumnRule",
-        "MozColumnRuleColor",
-        "MozColumnRuleStyle",
-        "MozColumnRuleWidth",
-        "MozColumnWidth",
-        "MozColumns",
-        "MozContactChangeEvent",
-        "MozFloatEdge",
-        "MozFontFeatureSettings",
-        "MozFontLanguageOverride",
-        "MozForceBrokenImageIcon",
-        "MozHyphens",
-        "MozImageRegion",
-        "MozMarginEnd",
-        "MozMarginStart",
-        "MozMmsEvent",
-        "MozMmsMessage",
-        "MozMobileMessageThread",
-        "MozOSXFontSmoothing",
-        "MozOrient",
-        "MozOutlineRadius",
-        "MozOutlineRadiusBottomleft",
-        "MozOutlineRadiusBottomright",
-        "MozOutlineRadiusTopleft",
-        "MozOutlineRadiusTopright",
-        "MozPaddingEnd",
-        "MozPaddingStart",
-        "MozPerspective",
-        "MozPerspectiveOrigin",
-        "MozPowerManager",
-        "MozSettingsEvent",
-        "MozSmsEvent",
-        "MozSmsMessage",
-        "MozStackSizing",
-        "MozTabSize",
-        "MozTextAlignLast",
-        "MozTextDecorationColor",
-        "MozTextDecorationLine",
-        "MozTextDecorationStyle",
-        "MozTextSizeAdjust",
-        "MozTransform",
-        "MozTransformOrigin",
-        "MozTransformStyle",
-        "MozTransition",
-        "MozTransitionDelay",
-        "MozTransitionDuration",
-        "MozTransitionProperty",
-        "MozTransitionTimingFunction",
-        "MozUserFocus",
-        "MozUserInput",
-        "MozUserModify",
-        "MozUserSelect",
-        "MozWindowDragging",
-        "MozWindowShadow",
-        "MutationEvent",
-        "MutationObserver",
-        "MutationRecord",
-        "NAMESPACE_ERR",
-        "NAMESPACE_RULE",
-        "NEAREST",
-        "NEAREST_MIPMAP_LINEAR",
-        "NEAREST_MIPMAP_NEAREST",
-        "NEGATIVE_INFINITY",
-        "NETWORK_EMPTY",
-        "NETWORK_ERR",
-        "NETWORK_IDLE",
-        "NETWORK_LOADED",
-        "NETWORK_LOADING",
-        "NETWORK_NO_SOURCE",
-        "NEVER",
-        "NEW",
-        "NEXT",
-        "NEXT_NO_DUPLICATE",
-        "NICEST",
-        "NODE_AFTER",
-        "NODE_BEFORE",
-        "NODE_BEFORE_AND_AFTER",
-        "NODE_INSIDE",
-        "NONE",
-        "NON_TRANSIENT_ERR",
-        "NOTATION_NODE",
-        "NOTCH",
-        "NOTEQUAL",
-        "NOT_ALLOWED_ERR",
-        "NOT_FOUND_ERR",
-        "NOT_READABLE_ERR",
-        "NOT_SUPPORTED_ERR",
-        "NO_DATA_ALLOWED_ERR",
-        "NO_ERR",
-        "NO_ERROR",
-        "NO_MODIFICATION_ALLOWED_ERR",
-        "NUMBER_TYPE",
-        "NUM_COMPRESSED_TEXTURE_FORMATS",
-        "NaN",
-        "NamedNodeMap",
-        "Navigator",
-        "NearbyLinks",
-        "NetworkInformation",
-        "Node",
-        "NodeFilter",
-        "NodeIterator",
-        "NodeList",
-        "Notation",
-        "Notification",
-        "NotifyPaintEvent",
-        "Number",
-        "NumberFormat",
-        "OBSOLETE",
-        "ONE",
-        "ONE_MINUS_CONSTANT_ALPHA",
-        "ONE_MINUS_CONSTANT_COLOR",
-        "ONE_MINUS_DST_ALPHA",
-        "ONE_MINUS_DST_COLOR",
-        "ONE_MINUS_SRC_ALPHA",
-        "ONE_MINUS_SRC_COLOR",
-        "OPEN",
-        "OPENED",
-        "OPENING",
-        "ORDERED_NODE_ITERATOR_TYPE",
-        "ORDERED_NODE_SNAPSHOT_TYPE",
-        "OUT_OF_MEMORY",
-        "Object",
-        "OfflineAudioCompletionEvent",
-        "OfflineAudioContext",
-        "OfflineResourceList",
-        "Option",
-        "OscillatorNode",
-        "OverflowEvent",
-        "PACK_ALIGNMENT",
-        "PAGE_RULE",
-        "PARSE_ERR",
-        "PATHSEG_ARC_ABS",
-        "PATHSEG_ARC_REL",
-        "PATHSEG_CLOSEPATH",
-        "PATHSEG_CURVETO_CUBIC_ABS",
-        "PATHSEG_CURVETO_CUBIC_REL",
-        "PATHSEG_CURVETO_CUBIC_SMOOTH_ABS",
-        "PATHSEG_CURVETO_CUBIC_SMOOTH_REL",
-        "PATHSEG_CURVETO_QUADRATIC_ABS",
-        "PATHSEG_CURVETO_QUADRATIC_REL",
-        "PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS",
-        "PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL",
-        "PATHSEG_LINETO_ABS",
-        "PATHSEG_LINETO_HORIZONTAL_ABS",
-        "PATHSEG_LINETO_HORIZONTAL_REL",
-        "PATHSEG_LINETO_REL",
-        "PATHSEG_LINETO_VERTICAL_ABS",
-        "PATHSEG_LINETO_VERTICAL_REL",
-        "PATHSEG_MOVETO_ABS",
-        "PATHSEG_MOVETO_REL",
-        "PATHSEG_UNKNOWN",
-        "PATH_EXISTS_ERR",
-        "PEAKING",
-        "PERMISSION_DENIED",
-        "PERSISTENT",
-        "PI",
-        "PLAYING_STATE",
-        "POINTS",
-        "POLYGON_OFFSET_FACTOR",
-        "POLYGON_OFFSET_FILL",
-        "POLYGON_OFFSET_UNITS",
-        "POSITION_UNAVAILABLE",
-        "POSITIVE_INFINITY",
-        "PREV",
-        "PREV_NO_DUPLICATE",
-        "PROCESSING_INSTRUCTION_NODE",
-        "PageChangeEvent",
-        "PageTransitionEvent",
-        "PaintRequest",
-        "PaintRequestList",
-        "PannerNode",
-        "Path2D",
-        "Performance",
-        "PerformanceEntry",
-        "PerformanceMark",
-        "PerformanceMeasure",
-        "PerformanceNavigation",
-        "PerformanceResourceTiming",
-        "PerformanceTiming",
-        "PeriodicWave",
-        "Plugin",
-        "PluginArray",
-        "PopStateEvent",
-        "PopupBlockedEvent",
-        "ProcessingInstruction",
-        "ProgressEvent",
-        "Promise",
-        "PropertyNodeList",
-        "Proxy",
-        "PushManager",
-        "PushSubscription",
-        "Q",
-        "QUOTA_ERR",
-        "QUOTA_EXCEEDED_ERR",
-        "QueryInterface",
-        "READ_ONLY",
-        "READ_ONLY_ERR",
-        "READ_WRITE",
-        "RED_BITS",
-        "REMOVAL",
-        "RENDERBUFFER",
-        "RENDERBUFFER_ALPHA_SIZE",
-        "RENDERBUFFER_BINDING",
-        "RENDERBUFFER_BLUE_SIZE",
-        "RENDERBUFFER_DEPTH_SIZE",
-        "RENDERBUFFER_GREEN_SIZE",
-        "RENDERBUFFER_HEIGHT",
-        "RENDERBUFFER_INTERNAL_FORMAT",
-        "RENDERBUFFER_RED_SIZE",
-        "RENDERBUFFER_STENCIL_SIZE",
-        "RENDERBUFFER_WIDTH",
-        "RENDERER",
-        "RENDERING_INTENT_ABSOLUTE_COLORIMETRIC",
-        "RENDERING_INTENT_AUTO",
-        "RENDERING_INTENT_PERCEPTUAL",
-        "RENDERING_INTENT_RELATIVE_COLORIMETRIC",
-        "RENDERING_INTENT_SATURATION",
-        "RENDERING_INTENT_UNKNOWN",
-        "REPEAT",
-        "REPLACE",
-        "RGB",
-        "RGB565",
-        "RGB5_A1",
-        "RGBA",
-        "RGBA4",
-        "RGBColor",
-        "ROTATION_CLOCKWISE",
-        "ROTATION_COUNTERCLOCKWISE",
-        "RTCDataChannelEvent",
-        "RTCIceCandidate",
-        "RTCPeerConnectionIceEvent",
-        "RTCRtpReceiver",
-        "RTCRtpSender",
-        "RTCSessionDescription",
-        "RTCStatsReport",
-        "RadioNodeList",
-        "Range",
-        "RangeError",
-        "RangeException",
-        "RecordErrorEvent",
-        "Rect",
-        "ReferenceError",
-        "RegExp",
-        "Request",
-        "Response",
-        "SAMPLER_2D",
-        "SAMPLER_CUBE",
-        "SAMPLES",
-        "SAMPLE_ALPHA_TO_COVERAGE",
-        "SAMPLE_BUFFERS",
-        "SAMPLE_COVERAGE",
-        "SAMPLE_COVERAGE_INVERT",
-        "SAMPLE_COVERAGE_VALUE",
-        "SAWTOOTH",
-        "SCHEDULED_STATE",
-        "SCISSOR_BOX",
-        "SCISSOR_TEST",
-        "SCROLL_PAGE_DOWN",
-        "SCROLL_PAGE_UP",
-        "SDP_ANSWER",
-        "SDP_OFFER",
-        "SDP_PRANSWER",
-        "SECURITY_ERR",
-        "SELECT",
-        "SERIALIZE_ERR",
-        "SEVERITY_ERROR",
-        "SEVERITY_FATAL_ERROR",
-        "SEVERITY_WARNING",
-        "SHADER_COMPILER",
-        "SHADER_TYPE",
-        "SHADING_LANGUAGE_VERSION",
-        "SHIFT_MASK",
-        "SHORT",
-        "SHOWING",
-        "SHOW_ALL",
-        "SHOW_ATTRIBUTE",
-        "SHOW_CDATA_SECTION",
-        "SHOW_COMMENT",
-        "SHOW_DOCUMENT",
-        "SHOW_DOCUMENT_FRAGMENT",
-        "SHOW_DOCUMENT_TYPE",
-        "SHOW_ELEMENT",
-        "SHOW_ENTITY",
-        "SHOW_ENTITY_REFERENCE",
-        "SHOW_NOTATION",
-        "SHOW_PROCESSING_INSTRUCTION",
-        "SHOW_TEXT",
-        "SINE",
-        "SOUNDFIELD",
-        "SQLException",
-        "SQRT1_2",
-        "SQRT2",
-        "SQUARE",
-        "SRC_ALPHA",
-        "SRC_ALPHA_SATURATE",
-        "SRC_COLOR",
-        "START_TO_END",
-        "START_TO_START",
-        "STATIC_DRAW",
-        "STENCIL_ATTACHMENT",
-        "STENCIL_BACK_FAIL",
-        "STENCIL_BACK_FUNC",
-        "STENCIL_BACK_PASS_DEPTH_FAIL",
-        "STENCIL_BACK_PASS_DEPTH_PASS",
-        "STENCIL_BACK_REF",
-        "STENCIL_BACK_VALUE_MASK",
-        "STENCIL_BACK_WRITEMASK",
-        "STENCIL_BITS",
-        "STENCIL_BUFFER_BIT",
-        "STENCIL_CLEAR_VALUE",
-        "STENCIL_FAIL",
-        "STENCIL_FUNC",
-        "STENCIL_INDEX",
-        "STENCIL_INDEX8",
-        "STENCIL_PASS_DEPTH_FAIL",
-        "STENCIL_PASS_DEPTH_PASS",
-        "STENCIL_REF",
-        "STENCIL_TEST",
-        "STENCIL_VALUE_MASK",
-        "STENCIL_WRITEMASK",
-        "STREAM_DRAW",
-        "STRING_TYPE",
-        "STYLE_RULE",
-        "SUBPIXEL_BITS",
-        "SUPPORTS_RULE",
-        "SVGAElement",
-        "SVGAltGlyphDefElement",
-        "SVGAltGlyphElement",
-        "SVGAltGlyphItemElement",
-        "SVGAngle",
-        "SVGAnimateColorElement",
-        "SVGAnimateElement",
-        "SVGAnimateMotionElement",
-        "SVGAnimateTransformElement",
-        "SVGAnimatedAngle",
-        "SVGAnimatedBoolean",
-        "SVGAnimatedEnumeration",
-        "SVGAnimatedInteger",
-        "SVGAnimatedLength",
-        "SVGAnimatedLengthList",
-        "SVGAnimatedNumber",
-        "SVGAnimatedNumberList",
-        "SVGAnimatedPreserveAspectRatio",
-        "SVGAnimatedRect",
-        "SVGAnimatedString",
-        "SVGAnimatedTransformList",
-        "SVGAnimationElement",
-        "SVGCircleElement",
-        "SVGClipPathElement",
-        "SVGColor",
-        "SVGComponentTransferFunctionElement",
-        "SVGCursorElement",
-        "SVGDefsElement",
-        "SVGDescElement",
-        "SVGDiscardElement",
-        "SVGDocument",
-        "SVGElement",
-        "SVGElementInstance",
-        "SVGElementInstanceList",
-        "SVGEllipseElement",
-        "SVGException",
-        "SVGFEBlendElement",
-        "SVGFEColorMatrixElement",
-        "SVGFEComponentTransferElement",
-        "SVGFECompositeElement",
-        "SVGFEConvolveMatrixElement",
-        "SVGFEDiffuseLightingElement",
-        "SVGFEDisplacementMapElement",
-        "SVGFEDistantLightElement",
-        "SVGFEDropShadowElement",
-        "SVGFEFloodElement",
-        "SVGFEFuncAElement",
-        "SVGFEFuncBElement",
-        "SVGFEFuncGElement",
-        "SVGFEFuncRElement",
-        "SVGFEGaussianBlurElement",
-        "SVGFEImageElement",
-        "SVGFEMergeElement",
-        "SVGFEMergeNodeElement",
-        "SVGFEMorphologyElement",
-        "SVGFEOffsetElement",
-        "SVGFEPointLightElement",
-        "SVGFESpecularLightingElement",
-        "SVGFESpotLightElement",
-        "SVGFETileElement",
-        "SVGFETurbulenceElement",
-        "SVGFilterElement",
-        "SVGFontElement",
-        "SVGFontFaceElement",
-        "SVGFontFaceFormatElement",
-        "SVGFontFaceNameElement",
-        "SVGFontFaceSrcElement",
-        "SVGFontFaceUriElement",
-        "SVGForeignObjectElement",
-        "SVGGElement",
-        "SVGGeometryElement",
-        "SVGGlyphElement",
-        "SVGGlyphRefElement",
-        "SVGGradientElement",
-        "SVGGraphicsElement",
-        "SVGHKernElement",
-        "SVGImageElement",
-        "SVGLength",
-        "SVGLengthList",
-        "SVGLineElement",
-        "SVGLinearGradientElement",
-        "SVGMPathElement",
-        "SVGMarkerElement",
-        "SVGMaskElement",
-        "SVGMatrix",
-        "SVGMetadataElement",
-        "SVGMissingGlyphElement",
-        "SVGNumber",
-        "SVGNumberList",
-        "SVGPaint",
-        "SVGPathElement",
-        "SVGPathSeg",
-        "SVGPathSegArcAbs",
-        "SVGPathSegArcRel",
-        "SVGPathSegClosePath",
-        "SVGPathSegCurvetoCubicAbs",
-        "SVGPathSegCurvetoCubicRel",
-        "SVGPathSegCurvetoCubicSmoothAbs",
-        "SVGPathSegCurvetoCubicSmoothRel",
-        "SVGPathSegCurvetoQuadraticAbs",
-        "SVGPathSegCurvetoQuadraticRel",
-        "SVGPathSegCurvetoQuadraticSmoothAbs",
-        "SVGPathSegCurvetoQuadraticSmoothRel",
-        "SVGPathSegLinetoAbs",
-        "SVGPathSegLinetoHorizontalAbs",
-        "SVGPathSegLinetoHorizontalRel",
-        "SVGPathSegLinetoRel",
-        "SVGPathSegLinetoVerticalAbs",
-        "SVGPathSegLinetoVerticalRel",
-        "SVGPathSegList",
-        "SVGPathSegMovetoAbs",
-        "SVGPathSegMovetoRel",
-        "SVGPatternElement",
-        "SVGPoint",
-        "SVGPointList",
-        "SVGPolygonElement",
-        "SVGPolylineElement",
-        "SVGPreserveAspectRatio",
-        "SVGRadialGradientElement",
-        "SVGRect",
-        "SVGRectElement",
-        "SVGRenderingIntent",
-        "SVGSVGElement",
-        "SVGScriptElement",
-        "SVGSetElement",
-        "SVGStopElement",
-        "SVGStringList",
-        "SVGStyleElement",
-        "SVGSwitchElement",
-        "SVGSymbolElement",
-        "SVGTRefElement",
-        "SVGTSpanElement",
-        "SVGTextContentElement",
-        "SVGTextElement",
-        "SVGTextPathElement",
-        "SVGTextPositioningElement",
-        "SVGTitleElement",
-        "SVGTransform",
-        "SVGTransformList",
-        "SVGUnitTypes",
-        "SVGUseElement",
-        "SVGVKernElement",
-        "SVGViewElement",
-        "SVGViewSpec",
-        "SVGZoomAndPan",
-        "SVGZoomEvent",
-        "SVG_ANGLETYPE_DEG",
-        "SVG_ANGLETYPE_GRAD",
-        "SVG_ANGLETYPE_RAD",
-        "SVG_ANGLETYPE_UNKNOWN",
-        "SVG_ANGLETYPE_UNSPECIFIED",
-        "SVG_CHANNEL_A",
-        "SVG_CHANNEL_B",
-        "SVG_CHANNEL_G",
-        "SVG_CHANNEL_R",
-        "SVG_CHANNEL_UNKNOWN",
-        "SVG_COLORTYPE_CURRENTCOLOR",
-        "SVG_COLORTYPE_RGBCOLOR",
-        "SVG_COLORTYPE_RGBCOLOR_ICCCOLOR",
-        "SVG_COLORTYPE_UNKNOWN",
-        "SVG_EDGEMODE_DUPLICATE",
-        "SVG_EDGEMODE_NONE",
-        "SVG_EDGEMODE_UNKNOWN",
-        "SVG_EDGEMODE_WRAP",
-        "SVG_FEBLEND_MODE_COLOR",
-        "SVG_FEBLEND_MODE_COLOR_BURN",
-        "SVG_FEBLEND_MODE_COLOR_DODGE",
-        "SVG_FEBLEND_MODE_DARKEN",
-        "SVG_FEBLEND_MODE_DIFFERENCE",
-        "SVG_FEBLEND_MODE_EXCLUSION",
-        "SVG_FEBLEND_MODE_HARD_LIGHT",
-        "SVG_FEBLEND_MODE_HUE",
-        "SVG_FEBLEND_MODE_LIGHTEN",
-        "SVG_FEBLEND_MODE_LUMINOSITY",
-        "SVG_FEBLEND_MODE_MULTIPLY",
-        "SVG_FEBLEND_MODE_NORMAL",
-        "SVG_FEBLEND_MODE_OVERLAY",
-        "SVG_FEBLEND_MODE_SATURATION",
-        "SVG_FEBLEND_MODE_SCREEN",
-        "SVG_FEBLEND_MODE_SOFT_LIGHT",
-        "SVG_FEBLEND_MODE_UNKNOWN",
-        "SVG_FECOLORMATRIX_TYPE_HUEROTATE",
-        "SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA",
-        "SVG_FECOLORMATRIX_TYPE_MATRIX",
-        "SVG_FECOLORMATRIX_TYPE_SATURATE",
-        "SVG_FECOLORMATRIX_TYPE_UNKNOWN",
-        "SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE",
-        "SVG_FECOMPONENTTRANSFER_TYPE_GAMMA",
-        "SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY",
-        "SVG_FECOMPONENTTRANSFER_TYPE_LINEAR",
-        "SVG_FECOMPONENTTRANSFER_TYPE_TABLE",
-        "SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN",
-        "SVG_FECOMPOSITE_OPERATOR_ARITHMETIC",
-        "SVG_FECOMPOSITE_OPERATOR_ATOP",
-        "SVG_FECOMPOSITE_OPERATOR_IN",
-        "SVG_FECOMPOSITE_OPERATOR_OUT",
-        "SVG_FECOMPOSITE_OPERATOR_OVER",
-        "SVG_FECOMPOSITE_OPERATOR_UNKNOWN",
-        "SVG_FECOMPOSITE_OPERATOR_XOR",
-        "SVG_INVALID_VALUE_ERR",
-        "SVG_LENGTHTYPE_CM",
-        "SVG_LENGTHTYPE_EMS",
-        "SVG_LENGTHTYPE_EXS",
-        "SVG_LENGTHTYPE_IN",
-        "SVG_LENGTHTYPE_MM",
-        "SVG_LENGTHTYPE_NUMBER",
-        "SVG_LENGTHTYPE_PC",
-        "SVG_LENGTHTYPE_PERCENTAGE",
-        "SVG_LENGTHTYPE_PT",
-        "SVG_LENGTHTYPE_PX",
-        "SVG_LENGTHTYPE_UNKNOWN",
-        "SVG_MARKERUNITS_STROKEWIDTH",
-        "SVG_MARKERUNITS_UNKNOWN",
-        "SVG_MARKERUNITS_USERSPACEONUSE",
-        "SVG_MARKER_ORIENT_ANGLE",
-        "SVG_MARKER_ORIENT_AUTO",
-        "SVG_MARKER_ORIENT_UNKNOWN",
-        "SVG_MASKTYPE_ALPHA",
-        "SVG_MASKTYPE_LUMINANCE",
-        "SVG_MATRIX_NOT_INVERTABLE",
-        "SVG_MEETORSLICE_MEET",
-        "SVG_MEETORSLICE_SLICE",
-        "SVG_MEETORSLICE_UNKNOWN",
-        "SVG_MORPHOLOGY_OPERATOR_DILATE",
-        "SVG_MORPHOLOGY_OPERATOR_ERODE",
-        "SVG_MORPHOLOGY_OPERATOR_UNKNOWN",
-        "SVG_PAINTTYPE_CURRENTCOLOR",
-        "SVG_PAINTTYPE_NONE",
-        "SVG_PAINTTYPE_RGBCOLOR",
-        "SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR",
-        "SVG_PAINTTYPE_UNKNOWN",
-        "SVG_PAINTTYPE_URI",
-        "SVG_PAINTTYPE_URI_CURRENTCOLOR",
-        "SVG_PAINTTYPE_URI_NONE",
-        "SVG_PAINTTYPE_URI_RGBCOLOR",
-        "SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR",
-        "SVG_PRESERVEASPECTRATIO_NONE",
-        "SVG_PRESERVEASPECTRATIO_UNKNOWN",
-        "SVG_PRESERVEASPECTRATIO_XMAXYMAX",
-        "SVG_PRESERVEASPECTRATIO_XMAXYMID",
-        "SVG_PRESERVEASPECTRATIO_XMAXYMIN",
-        "SVG_PRESERVEASPECTRATIO_XMIDYMAX",
-        "SVG_PRESERVEASPECTRATIO_XMIDYMID",
-        "SVG_PRESERVEASPECTRATIO_XMIDYMIN",
-        "SVG_PRESERVEASPECTRATIO_XMINYMAX",
-        "SVG_PRESERVEASPECTRATIO_XMINYMID",
-        "SVG_PRESERVEASPECTRATIO_XMINYMIN",
-        "SVG_SPREADMETHOD_PAD",
-        "SVG_SPREADMETHOD_REFLECT",
-        "SVG_SPREADMETHOD_REPEAT",
-        "SVG_SPREADMETHOD_UNKNOWN",
-        "SVG_STITCHTYPE_NOSTITCH",
-        "SVG_STITCHTYPE_STITCH",
-        "SVG_STITCHTYPE_UNKNOWN",
-        "SVG_TRANSFORM_MATRIX",
-        "SVG_TRANSFORM_ROTATE",
-        "SVG_TRANSFORM_SCALE",
-        "SVG_TRANSFORM_SKEWX",
-        "SVG_TRANSFORM_SKEWY",
-        "SVG_TRANSFORM_TRANSLATE",
-        "SVG_TRANSFORM_UNKNOWN",
-        "SVG_TURBULENCE_TYPE_FRACTALNOISE",
-        "SVG_TURBULENCE_TYPE_TURBULENCE",
-        "SVG_TURBULENCE_TYPE_UNKNOWN",
-        "SVG_UNIT_TYPE_OBJECTBOUNDINGBOX",
-        "SVG_UNIT_TYPE_UNKNOWN",
-        "SVG_UNIT_TYPE_USERSPACEONUSE",
-        "SVG_WRONG_TYPE_ERR",
-        "SVG_ZOOMANDPAN_DISABLE",
-        "SVG_ZOOMANDPAN_MAGNIFY",
-        "SVG_ZOOMANDPAN_UNKNOWN",
-        "SYNTAX_ERR",
-        "SavedPages",
-        "Screen",
-        "ScreenOrientation",
-        "Script",
-        "ScriptProcessorNode",
-        "ScrollAreaEvent",
-        "SecurityPolicyViolationEvent",
-        "Selection",
-        "ServiceWorker",
-        "ServiceWorkerContainer",
-        "ServiceWorkerRegistration",
-        "SessionDescription",
-        "Set",
-        "ShadowRoot",
-        "SharedWorker",
-        "SimpleGestureEvent",
-        "SpeechSynthesisEvent",
-        "SpeechSynthesisUtterance",
-        "StopIteration",
-        "Storage",
-        "StorageEvent",
-        "String",
-        "StyleSheet",
-        "StyleSheetList",
-        "SubtleCrypto",
-        "Symbol",
-        "SyntaxError",
-        "TEMPORARY",
-        "TEXTPATH_METHODTYPE_ALIGN",
-        "TEXTPATH_METHODTYPE_STRETCH",
-        "TEXTPATH_METHODTYPE_UNKNOWN",
-        "TEXTPATH_SPACINGTYPE_AUTO",
-        "TEXTPATH_SPACINGTYPE_EXACT",
-        "TEXTPATH_SPACINGTYPE_UNKNOWN",
-        "TEXTURE",
-        "TEXTURE0",
-        "TEXTURE1",
-        "TEXTURE10",
-        "TEXTURE11",
-        "TEXTURE12",
-        "TEXTURE13",
-        "TEXTURE14",
-        "TEXTURE15",
-        "TEXTURE16",
-        "TEXTURE17",
-        "TEXTURE18",
-        "TEXTURE19",
-        "TEXTURE2",
-        "TEXTURE20",
-        "TEXTURE21",
-        "TEXTURE22",
-        "TEXTURE23",
-        "TEXTURE24",
-        "TEXTURE25",
-        "TEXTURE26",
-        "TEXTURE27",
-        "TEXTURE28",
-        "TEXTURE29",
-        "TEXTURE3",
-        "TEXTURE30",
-        "TEXTURE31",
-        "TEXTURE4",
-        "TEXTURE5",
-        "TEXTURE6",
-        "TEXTURE7",
-        "TEXTURE8",
-        "TEXTURE9",
-        "TEXTURE_2D",
-        "TEXTURE_BINDING_2D",
-        "TEXTURE_BINDING_CUBE_MAP",
-        "TEXTURE_CUBE_MAP",
-        "TEXTURE_CUBE_MAP_NEGATIVE_X",
-        "TEXTURE_CUBE_MAP_NEGATIVE_Y",
-        "TEXTURE_CUBE_MAP_NEGATIVE_Z",
-        "TEXTURE_CUBE_MAP_POSITIVE_X",
-        "TEXTURE_CUBE_MAP_POSITIVE_Y",
-        "TEXTURE_CUBE_MAP_POSITIVE_Z",
-        "TEXTURE_MAG_FILTER",
-        "TEXTURE_MAX_ANISOTROPY_EXT",
-        "TEXTURE_MIN_FILTER",
-        "TEXTURE_WRAP_S",
-        "TEXTURE_WRAP_T",
-        "TEXT_NODE",
-        "TIMEOUT",
-        "TIMEOUT_ERR",
-        "TOO_LARGE_ERR",
-        "TRANSACTION_INACTIVE_ERR",
-        "TRIANGLE",
-        "TRIANGLES",
-        "TRIANGLE_FAN",
-        "TRIANGLE_STRIP",
-        "TYPE_BACK_FORWARD",
-        "TYPE_ERR",
-        "TYPE_MISMATCH_ERR",
-        "TYPE_NAVIGATE",
-        "TYPE_RELOAD",
-        "TYPE_RESERVED",
-        "Text",
-        "TextDecoder",
-        "TextEncoder",
-        "TextEvent",
-        "TextMetrics",
-        "TextTrack",
-        "TextTrackCue",
-        "TextTrackCueList",
-        "TextTrackList",
-        "TimeEvent",
-        "TimeRanges",
-        "Touch",
-        "TouchEvent",
-        "TouchList",
-        "TrackEvent",
-        "TransitionEvent",
-        "TreeWalker",
-        "TypeError",
-        "UIEvent",
-        "UNCACHED",
-        "UNKNOWN_ERR",
-        "UNKNOWN_RULE",
-        "UNMASKED_RENDERER_WEBGL",
-        "UNMASKED_VENDOR_WEBGL",
-        "UNORDERED_NODE_ITERATOR_TYPE",
-        "UNORDERED_NODE_SNAPSHOT_TYPE",
-        "UNPACK_ALIGNMENT",
-        "UNPACK_COLORSPACE_CONVERSION_WEBGL",
-        "UNPACK_FLIP_Y_WEBGL",
-        "UNPACK_PREMULTIPLY_ALPHA_WEBGL",
-        "UNSCHEDULED_STATE",
-        "UNSENT",
-        "UNSIGNED_BYTE",
-        "UNSIGNED_INT",
-        "UNSIGNED_SHORT",
-        "UNSIGNED_SHORT_4_4_4_4",
-        "UNSIGNED_SHORT_5_5_5_1",
-        "UNSIGNED_SHORT_5_6_5",
-        "UNSPECIFIED_EVENT_TYPE_ERR",
-        "UPDATEREADY",
-        "URIError",
-        "URL",
-        "URLSearchParams",
-        "URLUnencoded",
-        "URL_MISMATCH_ERR",
-        "UTC",
-        "Uint16Array",
-        "Uint32Array",
-        "Uint8Array",
-        "Uint8ClampedArray",
-        "UserMessageHandler",
-        "UserMessageHandlersNamespace",
-        "UserProximityEvent",
-        "VALIDATE_STATUS",
-        "VALIDATION_ERR",
-        "VARIABLES_RULE",
-        "VENDOR",
-        "VERSION",
-        "VERSION_CHANGE",
-        "VERSION_ERR",
-        "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",
-        "VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE",
-        "VERTEX_ATTRIB_ARRAY_ENABLED",
-        "VERTEX_ATTRIB_ARRAY_NORMALIZED",
-        "VERTEX_ATTRIB_ARRAY_POINTER",
-        "VERTEX_ATTRIB_ARRAY_SIZE",
-        "VERTEX_ATTRIB_ARRAY_STRIDE",
-        "VERTEX_ATTRIB_ARRAY_TYPE",
-        "VERTEX_SHADER",
-        "VERTICAL",
-        "VERTICAL_AXIS",
-        "VER_ERR",
-        "VIEWPORT",
-        "VIEWPORT_RULE",
-        "VTTCue",
-        "VTTRegion",
-        "ValidityState",
-        "VideoStreamTrack",
-        "WEBKIT_FILTER_RULE",
-        "WEBKIT_KEYFRAMES_RULE",
-        "WEBKIT_KEYFRAME_RULE",
-        "WEBKIT_REGION_RULE",
-        "WRONG_DOCUMENT_ERR",
-        "WaveShaperNode",
-        "WeakMap",
-        "WeakSet",
-        "WebGLActiveInfo",
-        "WebGLBuffer",
-        "WebGLContextEvent",
-        "WebGLFramebuffer",
-        "WebGLProgram",
-        "WebGLRenderbuffer",
-        "WebGLRenderingContext",
-        "WebGLShader",
-        "WebGLShaderPrecisionFormat",
-        "WebGLTexture",
-        "WebGLUniformLocation",
-        "WebGLVertexArray",
-        "WebKitAnimationEvent",
-        "WebKitBlobBuilder",
-        "WebKitCSSFilterRule",
-        "WebKitCSSFilterValue",
-        "WebKitCSSKeyframeRule",
-        "WebKitCSSKeyframesRule",
-        "WebKitCSSMatrix",
-        "WebKitCSSRegionRule",
-        "WebKitCSSTransformValue",
-        "WebKitDataCue",
-        "WebKitGamepad",
-        "WebKitMediaKeyError",
-        "WebKitMediaKeyMessageEvent",
-        "WebKitMediaKeySession",
-        "WebKitMediaKeys",
-        "WebKitMediaSource",
-        "WebKitMutationObserver",
-        "WebKitNamespace",
-        "WebKitPlaybackTargetAvailabilityEvent",
-        "WebKitPoint",
-        "WebKitShadowRoot",
-        "WebKitSourceBuffer",
-        "WebKitSourceBufferList",
-        "WebKitTransitionEvent",
-        "WebSocket",
-        "WheelEvent",
-        "Window",
-        "Worker",
-        "XMLDocument",
-        "XMLHttpRequest",
-        "XMLHttpRequestEventTarget",
-        "XMLHttpRequestException",
-        "XMLHttpRequestProgressEvent",
-        "XMLHttpRequestUpload",
-        "XMLSerializer",
-        "XMLStylesheetProcessingInstruction",
-        "XPathEvaluator",
-        "XPathException",
-        "XPathExpression",
-        "XPathNSResolver",
-        "XPathResult",
-        "XSLTProcessor",
-        "ZERO",
-        "_XD0M_",
-        "_YD0M_",
-        "__defineGetter__",
-        "__defineSetter__",
-        "__lookupGetter__",
-        "__lookupSetter__",
-        "__opera",
-        "__proto__",
-        "_browserjsran",
-        "a",
-        "aLink",
-        "abbr",
-        "abort",
-        "abs",
-        "absolute",
-        "acceleration",
-        "accelerationIncludingGravity",
-        "accelerator",
-        "accept",
-        "acceptCharset",
-        "acceptNode",
-        "accessKey",
-        "accessKeyLabel",
-        "accuracy",
-        "acos",
-        "acosh",
-        "action",
-        "actionURL",
-        "active",
-        "activeCues",
-        "activeElement",
-        "activeSourceBuffers",
-        "activeSourceCount",
-        "activeTexture",
-        "add",
-        "addBehavior",
-        "addCandidate",
-        "addColorStop",
-        "addCue",
-        "addElement",
-        "addEventListener",
-        "addFilter",
-        "addFromString",
-        "addFromUri",
-        "addIceCandidate",
-        "addImport",
-        "addListener",
-        "addNamed",
-        "addPageRule",
-        "addPath",
-        "addPointer",
-        "addRange",
-        "addRegion",
-        "addRule",
-        "addSearchEngine",
-        "addSourceBuffer",
-        "addStream",
-        "addTextTrack",
-        "addTrack",
-        "addWakeLockListener",
-        "addedNodes",
-        "additionalName",
-        "additiveSymbols",
-        "addons",
-        "adoptNode",
-        "adr",
-        "advance",
-        "alert",
-        "algorithm",
-        "align",
-        "align-content",
-        "align-items",
-        "align-self",
-        "alignContent",
-        "alignItems",
-        "alignSelf",
-        "alignmentBaseline",
-        "alinkColor",
-        "all",
-        "allowFullscreen",
-        "allowedDirections",
-        "alpha",
-        "alt",
-        "altGraphKey",
-        "altHtml",
-        "altKey",
-        "altLeft",
-        "altitude",
-        "altitudeAccuracy",
-        "amplitude",
-        "ancestorOrigins",
-        "anchor",
-        "anchorNode",
-        "anchorOffset",
-        "anchors",
-        "angle",
-        "animVal",
-        "animate",
-        "animatedInstanceRoot",
-        "animatedNormalizedPathSegList",
-        "animatedPathSegList",
-        "animatedPoints",
-        "animation",
-        "animation-delay",
-        "animation-direction",
-        "animation-duration",
-        "animation-fill-mode",
-        "animation-iteration-count",
-        "animation-name",
-        "animation-play-state",
-        "animation-timing-function",
-        "animationDelay",
-        "animationDirection",
-        "animationDuration",
-        "animationFillMode",
-        "animationIterationCount",
-        "animationName",
-        "animationPlayState",
-        "animationStartTime",
-        "animationTimingFunction",
-        "animationsPaused",
-        "anniversary",
-        "app",
-        "appCodeName",
-        "appMinorVersion",
-        "appName",
-        "appNotifications",
-        "appVersion",
-        "append",
-        "appendBuffer",
-        "appendChild",
-        "appendData",
-        "appendItem",
-        "appendMedium",
-        "appendNamed",
-        "appendRule",
-        "appendStream",
-        "appendWindowEnd",
-        "appendWindowStart",
-        "applets",
-        "applicationCache",
-        "apply",
-        "applyElement",
-        "arc",
-        "arcTo",
-        "archive",
-        "areas",
-        "arguments",
-        "arrayBuffer",
-        "asin",
-        "asinh",
-        "assert",
-        "assign",
-        "async",
-        "atEnd",
-        "atan",
-        "atan2",
-        "atanh",
-        "atob",
-        "attachEvent",
-        "attachShader",
-        "attachments",
-        "attack",
-        "attrChange",
-        "attrName",
-        "attributeName",
-        "attributeNamespace",
-        "attributes",
-        "audioTracks",
-        "autoIncrement",
-        "autobuffer",
-        "autocapitalize",
-        "autocomplete",
-        "autocorrect",
-        "autofocus",
-        "autoplay",
-        "availHeight",
-        "availLeft",
-        "availTop",
-        "availWidth",
-        "availability",
-        "available",
-        "aversion",
-        "axes",
-        "axis",
-        "azimuth",
-        "b",
-        "back",
-        "backface-visibility",
-        "backfaceVisibility",
-        "background",
-        "background-attachment",
-        "background-blend-mode",
-        "background-clip",
-        "background-color",
-        "background-image",
-        "background-origin",
-        "background-position",
-        "background-repeat",
-        "background-size",
-        "backgroundAttachment",
-        "backgroundBlendMode",
-        "backgroundClip",
-        "backgroundColor",
-        "backgroundImage",
-        "backgroundOrigin",
-        "backgroundPosition",
-        "backgroundPositionX",
-        "backgroundPositionY",
-        "backgroundRepeat",
-        "backgroundSize",
-        "badInput",
-        "balance",
-        "baseFrequencyX",
-        "baseFrequencyY",
-        "baseNode",
-        "baseOffset",
-        "baseURI",
-        "baseVal",
-        "baselineShift",
-        "battery",
-        "bday",
-        "beginElement",
-        "beginElementAt",
-        "beginPath",
-        "behavior",
-        "behaviorCookie",
-        "behaviorPart",
-        "behaviorUrns",
-        "beta",
-        "bezierCurveTo",
-        "bgColor",
-        "bgProperties",
-        "bias",
-        "big",
-        "binaryType",
-        "bind",
-        "bindAttribLocation",
-        "bindBuffer",
-        "bindFramebuffer",
-        "bindRenderbuffer",
-        "bindTexture",
-        "blendColor",
-        "blendEquation",
-        "blendEquationSeparate",
-        "blendFunc",
-        "blendFuncSeparate",
-        "blink",
-        "blob",
-        "blockDirection",
-        "blue",
-        "blur",
-        "body",
-        "bodyUsed",
-        "bold",
-        "bookmarks",
-        "booleanValue",
-        "border",
-        "border-bottom",
-        "border-bottom-color",
-        "border-bottom-left-radius",
-        "border-bottom-right-radius",
-        "border-bottom-style",
-        "border-bottom-width",
-        "border-collapse",
-        "border-color",
-        "border-image",
-        "border-image-outset",
-        "border-image-repeat",
-        "border-image-slice",
-        "border-image-source",
-        "border-image-width",
-        "border-left",
-        "border-left-color",
-        "border-left-style",
-        "border-left-width",
-        "border-radius",
-        "border-right",
-        "border-right-color",
-        "border-right-style",
-        "border-right-width",
-        "border-spacing",
-        "border-style",
-        "border-top",
-        "border-top-color",
-        "border-top-left-radius",
-        "border-top-right-radius",
-        "border-top-style",
-        "border-top-width",
-        "border-width",
-        "borderBottom",
-        "borderBottomColor",
-        "borderBottomLeftRadius",
-        "borderBottomRightRadius",
-        "borderBottomStyle",
-        "borderBottomWidth",
-        "borderCollapse",
-        "borderColor",
-        "borderColorDark",
-        "borderColorLight",
-        "borderImage",
-        "borderImageOutset",
-        "borderImageRepeat",
-        "borderImageSlice",
-        "borderImageSource",
-        "borderImageWidth",
-        "borderLeft",
-        "borderLeftColor",
-        "borderLeftStyle",
-        "borderLeftWidth",
-        "borderRadius",
-        "borderRight",
-        "borderRightColor",
-        "borderRightStyle",
-        "borderRightWidth",
-        "borderSpacing",
-        "borderStyle",
-        "borderTop",
-        "borderTopColor",
-        "borderTopLeftRadius",
-        "borderTopRightRadius",
-        "borderTopStyle",
-        "borderTopWidth",
-        "borderWidth",
-        "bottom",
-        "bottomMargin",
-        "bound",
-        "boundElements",
-        "boundingClientRect",
-        "boundingHeight",
-        "boundingLeft",
-        "boundingTop",
-        "boundingWidth",
-        "bounds",
-        "box-decoration-break",
-        "box-shadow",
-        "box-sizing",
-        "boxDecorationBreak",
-        "boxShadow",
-        "boxSizing",
-        "breakAfter",
-        "breakBefore",
-        "breakInside",
-        "browserLanguage",
-        "btoa",
-        "bubbles",
-        "buffer",
-        "bufferData",
-        "bufferDepth",
-        "bufferSize",
-        "bufferSubData",
-        "buffered",
-        "bufferedAmount",
-        "buildID",
-        "buildNumber",
-        "button",
-        "buttonID",
-        "buttons",
-        "byteLength",
-        "byteOffset",
-        "c",
-        "call",
-        "caller",
-        "canBeFormatted",
-        "canBeMounted",
-        "canBeShared",
-        "canHaveChildren",
-        "canHaveHTML",
-        "canPlayType",
-        "cancel",
-        "cancelAnimationFrame",
-        "cancelBubble",
-        "cancelScheduledValues",
-        "cancelable",
-        "candidate",
-        "canvas",
-        "caption",
-        "caption-side",
-        "captionSide",
-        "captureEvents",
-        "captureStackTrace",
-        "caretPositionFromPoint",
-        "caretRangeFromPoint",
-        "cast",
-        "catch",
-        "category",
-        "cbrt",
-        "cd",
-        "ceil",
-        "cellIndex",
-        "cellPadding",
-        "cellSpacing",
-        "cells",
-        "ch",
-        "chOff",
-        "chain",
-        "challenge",
-        "changedTouches",
-        "channel",
-        "channelCount",
-        "channelCountMode",
-        "channelInterpretation",
-        "char",
-        "charAt",
-        "charCode",
-        "charCodeAt",
-        "charIndex",
-        "characterSet",
-        "charging",
-        "chargingTime",
-        "charset",
-        "checkEnclosure",
-        "checkFramebufferStatus",
-        "checkIntersection",
-        "checkValidity",
-        "checked",
-        "childElementCount",
-        "childNodes",
-        "children",
-        "chrome",
-        "ciphertext",
-        "cite",
-        "classList",
-        "className",
-        "classid",
-        "clear",
-        "clearAttributes",
-        "clearColor",
-        "clearData",
-        "clearDepth",
-        "clearImmediate",
-        "clearInterval",
-        "clearMarks",
-        "clearMeasures",
-        "clearParameters",
-        "clearRect",
-        "clearResourceTimings",
-        "clearShadow",
-        "clearStencil",
-        "clearTimeout",
-        "clearWatch",
-        "click",
-        "clickCount",
-        "clientHeight",
-        "clientInformation",
-        "clientLeft",
-        "clientRect",
-        "clientRects",
-        "clientTop",
-        "clientWidth",
-        "clientX",
-        "clientY",
-        "clip",
-        "clip-path",
-        "clip-rule",
-        "clipBottom",
-        "clipLeft",
-        "clipPath",
-        "clipPathUnits",
-        "clipRight",
-        "clipRule",
-        "clipTop",
-        "clipboardData",
-        "clone",
-        "cloneContents",
-        "cloneNode",
-        "cloneRange",
-        "close",
-        "closePath",
-        "closed",
-        "closest",
-        "clz",
-        "clz32",
-        "cmp",
-        "code",
-        "codeBase",
-        "codePointAt",
-        "codeType",
-        "colSpan",
-        "collapse",
-        "collapseToEnd",
-        "collapseToStart",
-        "collapsed",
-        "collect",
-        "colno",
-        "color",
-        "color-interpolation",
-        "color-interpolation-filters",
-        "colorDepth",
-        "colorInterpolation",
-        "colorInterpolationFilters",
-        "colorMask",
-        "colorType",
-        "cols",
-        "columnCount",
-        "columnFill",
-        "columnGap",
-        "columnNumber",
-        "columnRule",
-        "columnRuleColor",
-        "columnRuleStyle",
-        "columnRuleWidth",
-        "columnSpan",
-        "columnWidth",
-        "columns",
-        "command",
-        "commitPreferences",
-        "commonAncestorContainer",
-        "compact",
-        "compareBoundaryPoints",
-        "compareDocumentPosition",
-        "compareEndPoints",
-        "compareNode",
-        "comparePoint",
-        "compatMode",
-        "compatible",
-        "compile",
-        "compileShader",
-        "complete",
-        "componentFromPoint",
-        "compositionEndOffset",
-        "compositionStartOffset",
-        "compressedTexImage2D",
-        "compressedTexSubImage2D",
-        "concat",
-        "conditionText",
-        "coneInnerAngle",
-        "coneOuterAngle",
-        "coneOuterGain",
-        "confirm",
-        "confirmComposition",
-        "confirmSiteSpecificTrackingException",
-        "confirmWebWideTrackingException",
-        "connect",
-        "connectEnd",
-        "connectStart",
-        "connected",
-        "connection",
-        "connectionSpeed",
-        "console",
-        "consolidate",
-        "constrictionActive",
-        "constructor",
-        "contactID",
-        "contains",
-        "containsNode",
-        "content",
-        "contentDocument",
-        "contentEditable",
-        "contentOverflow",
-        "contentScriptType",
-        "contentStyleType",
-        "contentType",
-        "contentWindow",
-        "context",
-        "contextMenu",
-        "contextmenu",
-        "continue",
-        "continuous",
-        "control",
-        "controller",
-        "controls",
-        "convertToSpecifiedUnits",
-        "cookie",
-        "cookieEnabled",
-        "coords",
-        "copyFromChannel",
-        "copyTexImage2D",
-        "copyTexSubImage2D",
-        "copyToChannel",
-        "copyWithin",
-        "correspondingElement",
-        "correspondingUseElement",
-        "cos",
-        "cosh",
-        "count",
-        "counter-increment",
-        "counter-reset",
-        "counterIncrement",
-        "counterReset",
-        "cpuClass",
-        "cpuSleepAllowed",
-        "create",
-        "createAnalyser",
-        "createAnswer",
-        "createAttribute",
-        "createAttributeNS",
-        "createBiquadFilter",
-        "createBuffer",
-        "createBufferSource",
-        "createCDATASection",
-        "createCSSStyleSheet",
-        "createCaption",
-        "createChannelMerger",
-        "createChannelSplitter",
-        "createComment",
-        "createContextualFragment",
-        "createControlRange",
-        "createConvolver",
-        "createDTMFSender",
-        "createDataChannel",
-        "createDelay",
-        "createDelayNode",
-        "createDocument",
-        "createDocumentFragment",
-        "createDocumentType",
-        "createDynamicsCompressor",
-        "createElement",
-        "createElementNS",
-        "createEntityReference",
-        "createEvent",
-        "createEventObject",
-        "createExpression",
-        "createFramebuffer",
-        "createFunction",
-        "createGain",
-        "createGainNode",
-        "createHTMLDocument",
-        "createImageBitmap",
-        "createImageData",
-        "createIndex",
-        "createJavaScriptNode",
-        "createLinearGradient",
-        "createMediaElementSource",
-        "createMediaKeys",
-        "createMediaStreamDestination",
-        "createMediaStreamSource",
-        "createMutableFile",
-        "createNSResolver",
-        "createNodeIterator",
-        "createNotification",
-        "createObjectStore",
-        "createObjectURL",
-        "createOffer",
-        "createOscillator",
-        "createPanner",
-        "createPattern",
-        "createPeriodicWave",
-        "createPopup",
-        "createProcessingInstruction",
-        "createProgram",
-        "createRadialGradient",
-        "createRange",
-        "createRangeCollection",
-        "createRenderbuffer",
-        "createSVGAngle",
-        "createSVGLength",
-        "createSVGMatrix",
-        "createSVGNumber",
-        "createSVGPathSegArcAbs",
-        "createSVGPathSegArcRel",
-        "createSVGPathSegClosePath",
-        "createSVGPathSegCurvetoCubicAbs",
-        "createSVGPathSegCurvetoCubicRel",
-        "createSVGPathSegCurvetoCubicSmoothAbs",
-        "createSVGPathSegCurvetoCubicSmoothRel",
-        "createSVGPathSegCurvetoQuadraticAbs",
-        "createSVGPathSegCurvetoQuadraticRel",
-        "createSVGPathSegCurvetoQuadraticSmoothAbs",
-        "createSVGPathSegCurvetoQuadraticSmoothRel",
-        "createSVGPathSegLinetoAbs",
-        "createSVGPathSegLinetoHorizontalAbs",
-        "createSVGPathSegLinetoHorizontalRel",
-        "createSVGPathSegLinetoRel",
-        "createSVGPathSegLinetoVerticalAbs",
-        "createSVGPathSegLinetoVerticalRel",
-        "createSVGPathSegMovetoAbs",
-        "createSVGPathSegMovetoRel",
-        "createSVGPoint",
-        "createSVGRect",
-        "createSVGTransform",
-        "createSVGTransformFromMatrix",
-        "createScriptProcessor",
-        "createSession",
-        "createShader",
-        "createShadowRoot",
-        "createStereoPanner",
-        "createStyleSheet",
-        "createTBody",
-        "createTFoot",
-        "createTHead",
-        "createTextNode",
-        "createTextRange",
-        "createTexture",
-        "createTouch",
-        "createTouchList",
-        "createTreeWalker",
-        "createWaveShaper",
-        "creationTime",
-        "crossOrigin",
-        "crypto",
-        "csi",
-        "cssFloat",
-        "cssRules",
-        "cssText",
-        "cssValueType",
-        "ctrlKey",
-        "ctrlLeft",
-        "cues",
-        "cullFace",
-        "currentNode",
-        "currentPage",
-        "currentScale",
-        "currentScript",
-        "currentSrc",
-        "currentState",
-        "currentStyle",
-        "currentTarget",
-        "currentTime",
-        "currentTranslate",
-        "currentView",
-        "cursor",
-        "curve",
-        "customError",
-        "cx",
-        "cy",
-        "d",
-        "data",
-        "dataFld",
-        "dataFormatAs",
-        "dataPageSize",
-        "dataSrc",
-        "dataTransfer",
-        "database",
-        "dataset",
-        "dateTime",
-        "db",
-        "debug",
-        "debuggerEnabled",
-        "declare",
-        "decode",
-        "decodeAudioData",
-        "decodeURI",
-        "decodeURIComponent",
-        "decrypt",
-        "default",
-        "defaultCharset",
-        "defaultChecked",
-        "defaultMuted",
-        "defaultPlaybackRate",
-        "defaultPrevented",
-        "defaultSelected",
-        "defaultStatus",
-        "defaultURL",
-        "defaultValue",
-        "defaultView",
-        "defaultstatus",
-        "defer",
-        "defineMagicFunction",
-        "defineMagicVariable",
-        "defineProperties",
-        "defineProperty",
-        "delayTime",
-        "delete",
-        "deleteBuffer",
-        "deleteCaption",
-        "deleteCell",
-        "deleteContents",
-        "deleteData",
-        "deleteDatabase",
-        "deleteFramebuffer",
-        "deleteFromDocument",
-        "deleteIndex",
-        "deleteMedium",
-        "deleteObjectStore",
-        "deleteProgram",
-        "deleteRenderbuffer",
-        "deleteRow",
-        "deleteRule",
-        "deleteShader",
-        "deleteTFoot",
-        "deleteTHead",
-        "deleteTexture",
-        "deliverChangeRecords",
-        "delivery",
-        "deliveryInfo",
-        "deliveryStatus",
-        "deliveryTimestamp",
-        "delta",
-        "deltaMode",
-        "deltaX",
-        "deltaY",
-        "deltaZ",
-        "depthFunc",
-        "depthMask",
-        "depthRange",
-        "deriveBits",
-        "deriveKey",
-        "description",
-        "deselectAll",
-        "designMode",
-        "destination",
-        "destinationURL",
-        "detach",
-        "detachEvent",
-        "detachShader",
-        "detail",
-        "detune",
-        "devicePixelRatio",
-        "deviceXDPI",
-        "deviceYDPI",
-        "diffuseConstant",
-        "digest",
-        "dimensions",
-        "dir",
-        "dirName",
-        "direction",
-        "dirxml",
-        "disable",
-        "disableVertexAttribArray",
-        "disabled",
-        "dischargingTime",
-        "disconnect",
-        "dispatchEvent",
-        "display",
-        "distanceModel",
-        "divisor",
-        "djsapi",
-        "djsproxy",
-        "doImport",
-        "doNotTrack",
-        "doScroll",
-        "doctype",
-        "document",
-        "documentElement",
-        "documentMode",
-        "documentURI",
-        "dolphin",
-        "dolphinGameCenter",
-        "dolphininfo",
-        "dolphinmeta",
-        "domComplete",
-        "domContentLoadedEventEnd",
-        "domContentLoadedEventStart",
-        "domInteractive",
-        "domLoading",
-        "domain",
-        "domainLookupEnd",
-        "domainLookupStart",
-        "dominant-baseline",
-        "dominantBaseline",
-        "done",
-        "dopplerFactor",
-        "download",
-        "dragDrop",
-        "draggable",
-        "drawArrays",
-        "drawArraysInstancedANGLE",
-        "drawCustomFocusRing",
-        "drawElements",
-        "drawElementsInstancedANGLE",
-        "drawFocusIfNeeded",
-        "drawImage",
-        "drawImageFromRect",
-        "drawSystemFocusRing",
-        "drawingBufferHeight",
-        "drawingBufferWidth",
-        "dropEffect",
-        "droppedVideoFrames",
-        "dropzone",
-        "dump",
-        "duplicate",
-        "duration",
-        "dvname",
-        "dvnum",
-        "dx",
-        "dy",
-        "dynsrc",
-        "e",
-        "edgeMode",
-        "effectAllowed",
-        "elapsedTime",
-        "elementFromPoint",
-        "elements",
-        "elevation",
-        "ellipse",
-        "email",
-        "embeds",
-        "empty",
-        "empty-cells",
-        "emptyCells",
-        "enable",
-        "enableBackground",
-        "enableStyleSheetsForSet",
-        "enableVertexAttribArray",
-        "enabled",
-        "enabledPlugin",
-        "encode",
-        "encodeURI",
-        "encodeURIComponent",
-        "encoding",
-        "encrypt",
-        "enctype",
-        "end",
-        "endContainer",
-        "endElement",
-        "endElementAt",
-        "endOfStream",
-        "endOffset",
-        "endTime",
-        "ended",
-        "endsWith",
-        "entities",
-        "entries",
-        "entryType",
-        "enumerate",
-        "enumerateEditable",
-        "error",
-        "errorCode",
-        "escape",
-        "eval",
-        "evaluate",
-        "event",
-        "eventPhase",
-        "every",
-        "exception",
-        "exec",
-        "execCommand",
-        "execCommandShowHelp",
-        "execScript",
-        "exitFullscreen",
-        "exitPointerLock",
-        "exp",
-        "expand",
-        "expandEntityReferences",
-        "expando",
-        "expansion",
-        "expiryDate",
-        "explicitOriginalTarget",
-        "expm1",
-        "exponent",
-        "exponentialRampToValueAtTime",
-        "exportKey",
-        "extend",
-        "extensions",
-        "extentNode",
-        "extentOffset",
-        "external",
-        "externalResourcesRequired",
-        "extractContents",
-        "extractable",
-        "f",
-        "face",
-        "factoryReset",
-        "fallback",
-        "familyName",
-        "farthestViewportElement",
-        "fastSeek",
-        "fatal",
-        "fetch",
-        "fetchStart",
-        "fftSize",
-        "fgColor",
-        "fileCreatedDate",
-        "fileHandle",
-        "fileModifiedDate",
-        "fileName",
-        "fileSize",
-        "fileUpdatedDate",
-        "filename",
-        "files",
-        "fill",
-        "fill-opacity",
-        "fill-rule",
-        "fillOpacity",
-        "fillRect",
-        "fillRule",
-        "fillStyle",
-        "fillText",
-        "filter",
-        "filterResX",
-        "filterResY",
-        "filterUnits",
-        "filters",
-        "find",
-        "findIndex",
-        "findRule",
-        "findText",
-        "finish",
-        "fireEvent",
-        "firstChild",
-        "firstElementChild",
-        "firstPage",
-        "fixed",
-        "flex",
-        "flex-basis",
-        "flex-direction",
-        "flex-flow",
-        "flex-grow",
-        "flex-shrink",
-        "flex-wrap",
-        "flexBasis",
-        "flexDirection",
-        "flexFlow",
-        "flexGrow",
-        "flexShrink",
-        "flexWrap",
-        "flipX",
-        "flipY",
-        "float",
-        "flood-color",
-        "flood-opacity",
-        "floodColor",
-        "floodOpacity",
-        "floor",
-        "flush",
-        "focus",
-        "focusNode",
-        "focusOffset",
-        "font",
-        "font-family",
-        "font-feature-settings",
-        "font-kerning",
-        "font-language-override",
-        "font-size",
-        "font-size-adjust",
-        "font-stretch",
-        "font-style",
-        "font-synthesis",
-        "font-variant",
-        "font-variant-alternates",
-        "font-variant-caps",
-        "font-variant-east-asian",
-        "font-variant-ligatures",
-        "font-variant-numeric",
-        "font-variant-position",
-        "font-weight",
-        "fontFamily",
-        "fontFeatureSettings",
-        "fontKerning",
-        "fontLanguageOverride",
-        "fontSize",
-        "fontSizeAdjust",
-        "fontSmoothingEnabled",
-        "fontStretch",
-        "fontStyle",
-        "fontSynthesis",
-        "fontVariant",
-        "fontVariantAlternates",
-        "fontVariantCaps",
-        "fontVariantEastAsian",
-        "fontVariantLigatures",
-        "fontVariantNumeric",
-        "fontVariantPosition",
-        "fontWeight",
-        "fontcolor",
-        "fonts",
-        "fontsize",
-        "for",
-        "forEach",
-        "forceRedraw",
-        "form",
-        "formAction",
-        "formEnctype",
-        "formMethod",
-        "formNoValidate",
-        "formTarget",
-        "format",
-        "forms",
-        "forward",
-        "fr",
-        "frame",
-        "frameBorder",
-        "frameElement",
-        "frameSpacing",
-        "framebufferRenderbuffer",
-        "framebufferTexture2D",
-        "frames",
-        "freeSpace",
-        "freeze",
-        "frequency",
-        "frequencyBinCount",
-        "from",
-        "fromCharCode",
-        "fromCodePoint",
-        "fromElement",
-        "frontFace",
-        "fround",
-        "fullScreen",
-        "fullscreenElement",
-        "fullscreenEnabled",
-        "fx",
-        "fy",
-        "gain",
-        "gamepad",
-        "gamma",
-        "genderIdentity",
-        "generateKey",
-        "generateMipmap",
-        "generateRequest",
-        "geolocation",
-        "gestureObject",
-        "get",
-        "getActiveAttrib",
-        "getActiveUniform",
-        "getAdjacentText",
-        "getAll",
-        "getAllResponseHeaders",
-        "getAsFile",
-        "getAsString",
-        "getAttachedShaders",
-        "getAttribLocation",
-        "getAttribute",
-        "getAttributeNS",
-        "getAttributeNode",
-        "getAttributeNodeNS",
-        "getAudioTracks",
-        "getBBox",
-        "getBattery",
-        "getBlob",
-        "getBookmark",
-        "getBoundingClientRect",
-        "getBufferParameter",
-        "getByteFrequencyData",
-        "getByteTimeDomainData",
-        "getCSSCanvasContext",
-        "getCTM",
-        "getCandidateWindowClientRect",
-        "getChannelData",
-        "getCharNumAtPosition",
-        "getClientRect",
-        "getClientRects",
-        "getCompositionAlternatives",
-        "getComputedStyle",
-        "getComputedTextLength",
-        "getConfiguration",
-        "getContext",
-        "getContextAttributes",
-        "getCounterValue",
-        "getCueAsHTML",
-        "getCueById",
-        "getCurrentPosition",
-        "getCurrentTime",
-        "getData",
-        "getDatabaseNames",
-        "getDate",
-        "getDay",
-        "getDefaultComputedStyle",
-        "getDestinationInsertionPoints",
-        "getDistributedNodes",
-        "getEditable",
-        "getElementById",
-        "getElementsByClassName",
-        "getElementsByName",
-        "getElementsByTagName",
-        "getElementsByTagNameNS",
-        "getEnclosureList",
-        "getEndPositionOfChar",
-        "getEntries",
-        "getEntriesByName",
-        "getEntriesByType",
-        "getError",
-        "getExtension",
-        "getExtentOfChar",
-        "getFeature",
-        "getFile",
-        "getFloat32",
-        "getFloat64",
-        "getFloatFrequencyData",
-        "getFloatTimeDomainData",
-        "getFloatValue",
-        "getFramebufferAttachmentParameter",
-        "getFrequencyResponse",
-        "getFullYear",
-        "getGamepads",
-        "getHours",
-        "getImageData",
-        "getInt16",
-        "getInt32",
-        "getInt8",
-        "getIntersectionList",
-        "getItem",
-        "getItems",
-        "getKey",
-        "getLineDash",
-        "getLocalStreams",
-        "getMarks",
-        "getMatchedCSSRules",
-        "getMeasures",
-        "getMetadata",
-        "getMilliseconds",
-        "getMinutes",
-        "getModifierState",
-        "getMonth",
-        "getNamedItem",
-        "getNamedItemNS",
-        "getNotifier",
-        "getNumberOfChars",
-        "getOverrideHistoryNavigationMode",
-        "getOverrideStyle",
-        "getOwnPropertyDescriptor",
-        "getOwnPropertyNames",
-        "getOwnPropertySymbols",
-        "getParameter",
-        "getPathSegAtLength",
-        "getPointAtLength",
-        "getPreference",
-        "getPreferenceDefault",
-        "getPresentationAttribute",
-        "getPreventDefault",
-        "getProgramInfoLog",
-        "getProgramParameter",
-        "getPropertyCSSValue",
-        "getPropertyPriority",
-        "getPropertyShorthand",
-        "getPropertyValue",
-        "getPrototypeOf",
-        "getRGBColorValue",
-        "getRandomValues",
-        "getRangeAt",
-        "getReceivers",
-        "getRectValue",
-        "getRegistration",
-        "getRemoteStreams",
-        "getRenderbufferParameter",
-        "getResponseHeader",
-        "getRoot",
-        "getRotationOfChar",
-        "getSVGDocument",
-        "getScreenCTM",
-        "getSeconds",
-        "getSelection",
-        "getSenders",
-        "getShaderInfoLog",
-        "getShaderParameter",
-        "getShaderPrecisionFormat",
-        "getShaderSource",
-        "getSimpleDuration",
-        "getSiteIcons",
-        "getSources",
-        "getSpeculativeParserUrls",
-        "getStartPositionOfChar",
-        "getStartTime",
-        "getStats",
-        "getStorageUpdates",
-        "getStreamById",
-        "getStringValue",
-        "getSubStringLength",
-        "getSubscription",
-        "getSupportedExtensions",
-        "getTexParameter",
-        "getTime",
-        "getTimezoneOffset",
-        "getTotalLength",
-        "getTrackById",
-        "getTracks",
-        "getTransformToElement",
-        "getUTCDate",
-        "getUTCDay",
-        "getUTCFullYear",
-        "getUTCHours",
-        "getUTCMilliseconds",
-        "getUTCMinutes",
-        "getUTCMonth",
-        "getUTCSeconds",
-        "getUint16",
-        "getUint32",
-        "getUint8",
-        "getUniform",
-        "getUniformLocation",
-        "getUserMedia",
-        "getValues",
-        "getVarDate",
-        "getVariableValue",
-        "getVertexAttrib",
-        "getVertexAttribOffset",
-        "getVideoPlaybackQuality",
-        "getVideoTracks",
-        "getWakeLockState",
-        "getYear",
-        "givenName",
-        "global",
-        "globalAlpha",
-        "globalCompositeOperation",
-        "glyphOrientationHorizontal",
-        "glyphOrientationVertical",
-        "glyphRef",
-        "go",
-        "gradientTransform",
-        "gradientUnits",
-        "grammars",
-        "green",
-        "group",
-        "groupCollapsed",
-        "groupEnd",
-        "hardwareConcurrency",
-        "has",
-        "hasAttribute",
-        "hasAttributeNS",
-        "hasAttributes",
-        "hasChildNodes",
-        "hasComposition",
-        "hasExtension",
-        "hasFeature",
-        "hasFocus",
-        "hasLayout",
-        "hasOwnProperty",
-        "hash",
-        "head",
-        "headers",
-        "heading",
-        "height",
-        "hidden",
-        "hide",
-        "hideFocus",
-        "high",
-        "hint",
-        "history",
-        "honorificPrefix",
-        "honorificSuffix",
-        "horizontalOverflow",
-        "host",
-        "hostname",
-        "href",
-        "hreflang",
-        "hspace",
-        "html5TagCheckInerface",
-        "htmlFor",
-        "htmlText",
-        "httpEquiv",
-        "hwTimestamp",
-        "hypot",
-        "iccId",
-        "iceConnectionState",
-        "iceGatheringState",
-        "icon",
-        "id",
-        "identifier",
-        "identity",
-        "ignoreBOM",
-        "ignoreCase",
-        "image-orientation",
-        "image-rendering",
-        "imageOrientation",
-        "imageRendering",
-        "images",
-        "ime-mode",
-        "imeMode",
-        "implementation",
-        "importKey",
-        "importNode",
-        "importStylesheet",
-        "imports",
-        "impp",
-        "imul",
-        "in1",
-        "in2",
-        "inBandMetadataTrackDispatchType",
-        "inRange",
-        "includes",
-        "incremental",
-        "indeterminate",
-        "index",
-        "indexNames",
-        "indexOf",
-        "indexedDB",
-        "inertiaDestinationX",
-        "inertiaDestinationY",
-        "info",
-        "init",
-        "initAnimationEvent",
-        "initBeforeLoadEvent",
-        "initClipboardEvent",
-        "initCloseEvent",
-        "initCommandEvent",
-        "initCompositionEvent",
-        "initCustomEvent",
-        "initData",
-        "initDeviceMotionEvent",
-        "initDeviceOrientationEvent",
-        "initDragEvent",
-        "initErrorEvent",
-        "initEvent",
-        "initFocusEvent",
-        "initGestureEvent",
-        "initHashChangeEvent",
-        "initKeyEvent",
-        "initKeyboardEvent",
-        "initMSManipulationEvent",
-        "initMessageEvent",
-        "initMouseEvent",
-        "initMouseScrollEvent",
-        "initMouseWheelEvent",
-        "initMutationEvent",
-        "initNSMouseEvent",
-        "initOverflowEvent",
-        "initPageEvent",
-        "initPageTransitionEvent",
-        "initPointerEvent",
-        "initPopStateEvent",
-        "initProgressEvent",
-        "initScrollAreaEvent",
-        "initSimpleGestureEvent",
-        "initStorageEvent",
-        "initTextEvent",
-        "initTimeEvent",
-        "initTouchEvent",
-        "initTransitionEvent",
-        "initUIEvent",
-        "initWebKitAnimationEvent",
-        "initWebKitTransitionEvent",
-        "initWebKitWheelEvent",
-        "initWheelEvent",
-        "initialTime",
-        "initialize",
-        "initiatorType",
-        "inner",
-        "innerHTML",
-        "innerHeight",
-        "innerText",
-        "innerWidth",
-        "input",
-        "inputBuffer",
-        "inputEncoding",
-        "inputMethod",
-        "insertAdjacentElement",
-        "insertAdjacentHTML",
-        "insertAdjacentText",
-        "insertBefore",
-        "insertCell",
-        "insertData",
-        "insertItemBefore",
-        "insertNode",
-        "insertRow",
-        "insertRule",
-        "instanceRoot",
-        "intercept",
-        "interimResults",
-        "internalSubset",
-        "intersectsNode",
-        "interval",
-        "invalidIteratorState",
-        "inverse",
-        "invertSelf",
-        "is",
-        "is2D",
-        "isAlternate",
-        "isArray",
-        "isBingCurrentSearchDefault",
-        "isBuffer",
-        "isCandidateWindowVisible",
-        "isChar",
-        "isCollapsed",
-        "isComposing",
-        "isContentEditable",
-        "isContentHandlerRegistered",
-        "isContextLost",
-        "isDefaultNamespace",
-        "isDisabled",
-        "isEnabled",
-        "isEqual",
-        "isEqualNode",
-        "isExtensible",
-        "isFinite",
-        "isFramebuffer",
-        "isFrozen",
-        "isGenerator",
-        "isId",
-        "isInjected",
-        "isInteger",
-        "isMap",
-        "isMultiLine",
-        "isNaN",
-        "isOpen",
-        "isPointInFill",
-        "isPointInPath",
-        "isPointInRange",
-        "isPointInStroke",
-        "isPrefAlternate",
-        "isPrimary",
-        "isProgram",
-        "isPropertyImplicit",
-        "isProtocolHandlerRegistered",
-        "isPrototypeOf",
-        "isRenderbuffer",
-        "isSafeInteger",
-        "isSameNode",
-        "isSealed",
-        "isShader",
-        "isSupported",
-        "isTextEdit",
-        "isTexture",
-        "isTrusted",
-        "isTypeSupported",
-        "isView",
-        "isolation",
-        "italics",
-        "item",
-        "itemId",
-        "itemProp",
-        "itemRef",
-        "itemScope",
-        "itemType",
-        "itemValue",
-        "iterateNext",
-        "iterator",
-        "javaEnabled",
-        "jobTitle",
-        "join",
-        "json",
-        "justify-content",
-        "justifyContent",
-        "k1",
-        "k2",
-        "k3",
-        "k4",
-        "kernelMatrix",
-        "kernelUnitLengthX",
-        "kernelUnitLengthY",
-        "kerning",
-        "key",
-        "keyCode",
-        "keyFor",
-        "keyIdentifier",
-        "keyLightEnabled",
-        "keyLocation",
-        "keyPath",
-        "keySystem",
-        "keyText",
-        "keyUsage",
-        "keys",
-        "keytype",
-        "kind",
-        "knee",
-        "label",
-        "labels",
-        "lang",
-        "language",
-        "languages",
-        "largeArcFlag",
-        "lastChild",
-        "lastElementChild",
-        "lastEventId",
-        "lastIndex",
-        "lastIndexOf",
-        "lastMatch",
-        "lastMessageSubject",
-        "lastMessageType",
-        "lastModified",
-        "lastModifiedDate",
-        "lastPage",
-        "lastParen",
-        "lastState",
-        "lastStyleSheetSet",
-        "latitude",
-        "layerX",
-        "layerY",
-        "layoutFlow",
-        "layoutGrid",
-        "layoutGridChar",
-        "layoutGridLine",
-        "layoutGridMode",
-        "layoutGridType",
-        "lbound",
-        "left",
-        "leftContext",
-        "leftMargin",
-        "length",
-        "lengthAdjust",
-        "lengthComputable",
-        "letter-spacing",
-        "letterSpacing",
-        "level",
-        "lighting-color",
-        "lightingColor",
-        "limitingConeAngle",
-        "line",
-        "line-height",
-        "lineAlign",
-        "lineBreak",
-        "lineCap",
-        "lineDashOffset",
-        "lineHeight",
-        "lineJoin",
-        "lineNumber",
-        "lineTo",
-        "lineWidth",
-        "linearRampToValueAtTime",
-        "lineno",
-        "link",
-        "linkColor",
-        "linkProgram",
-        "links",
-        "list",
-        "list-style",
-        "list-style-image",
-        "list-style-position",
-        "list-style-type",
-        "listStyle",
-        "listStyleImage",
-        "listStylePosition",
-        "listStyleType",
-        "listener",
-        "load",
-        "loadEventEnd",
-        "loadEventStart",
-        "loadTimes",
-        "loaded",
-        "localDescription",
-        "localName",
-        "localStorage",
-        "locale",
-        "localeCompare",
-        "location",
-        "locationbar",
-        "lock",
-        "lockedFile",
-        "log",
-        "log10",
-        "log1p",
-        "log2",
-        "logicalXDPI",
-        "logicalYDPI",
-        "longDesc",
-        "longitude",
-        "lookupNamespaceURI",
-        "lookupPrefix",
-        "loop",
-        "loopEnd",
-        "loopStart",
-        "looping",
-        "low",
-        "lower",
-        "lowerBound",
-        "lowerOpen",
-        "lowsrc",
-        "m11",
-        "m12",
-        "m13",
-        "m14",
-        "m21",
-        "m22",
-        "m23",
-        "m24",
-        "m31",
-        "m32",
-        "m33",
-        "m34",
-        "m41",
-        "m42",
-        "m43",
-        "m44",
-        "manifest",
-        "map",
-        "mapping",
-        "margin",
-        "margin-bottom",
-        "margin-left",
-        "margin-right",
-        "margin-top",
-        "marginBottom",
-        "marginHeight",
-        "marginLeft",
-        "marginRight",
-        "marginTop",
-        "marginWidth",
-        "mark",
-        "marker",
-        "marker-end",
-        "marker-mid",
-        "marker-offset",
-        "marker-start",
-        "markerEnd",
-        "markerHeight",
-        "markerMid",
-        "markerOffset",
-        "markerStart",
-        "markerUnits",
-        "markerWidth",
-        "marks",
-        "mask",
-        "mask-type",
-        "maskContentUnits",
-        "maskType",
-        "maskUnits",
-        "match",
-        "matchMedia",
-        "matchMedium",
-        "matches",
-        "matrix",
-        "matrixTransform",
-        "max",
-        "max-height",
-        "max-width",
-        "maxAlternatives",
-        "maxChannelCount",
-        "maxConnectionsPerServer",
-        "maxDecibels",
-        "maxDistance",
-        "maxHeight",
-        "maxLength",
-        "maxTouchPoints",
-        "maxValue",
-        "maxWidth",
-        "measure",
-        "measureText",
-        "media",
-        "mediaDevices",
-        "mediaElement",
-        "mediaGroup",
-        "mediaKeys",
-        "mediaText",
-        "meetOrSlice",
-        "memory",
-        "menubar",
-        "mergeAttributes",
-        "message",
-        "messageClass",
-        "messageHandlers",
-        "metaKey",
-        "method",
-        "mimeType",
-        "mimeTypes",
-        "min",
-        "min-height",
-        "min-width",
-        "minDecibels",
-        "minHeight",
-        "minValue",
-        "minWidth",
-        "miterLimit",
-        "mix-blend-mode",
-        "mixBlendMode",
-        "mode",
-        "modify",
-        "mount",
-        "move",
-        "moveBy",
-        "moveEnd",
-        "moveFirst",
-        "moveFocusDown",
-        "moveFocusLeft",
-        "moveFocusRight",
-        "moveFocusUp",
-        "moveNext",
-        "moveRow",
-        "moveStart",
-        "moveTo",
-        "moveToBookmark",
-        "moveToElementText",
-        "moveToPoint",
-        "mozAdd",
-        "mozAnimationStartTime",
-        "mozAnon",
-        "mozApps",
-        "mozAudioCaptured",
-        "mozAudioChannelType",
-        "mozAutoplayEnabled",
-        "mozCancelAnimationFrame",
-        "mozCancelFullScreen",
-        "mozCancelRequestAnimationFrame",
-        "mozCaptureStream",
-        "mozCaptureStreamUntilEnded",
-        "mozClearDataAt",
-        "mozContact",
-        "mozContacts",
-        "mozCreateFileHandle",
-        "mozCurrentTransform",
-        "mozCurrentTransformInverse",
-        "mozCursor",
-        "mozDash",
-        "mozDashOffset",
-        "mozDecodedFrames",
-        "mozExitPointerLock",
-        "mozFillRule",
-        "mozFragmentEnd",
-        "mozFrameDelay",
-        "mozFullScreen",
-        "mozFullScreenElement",
-        "mozFullScreenEnabled",
-        "mozGetAll",
-        "mozGetAllKeys",
-        "mozGetAsFile",
-        "mozGetDataAt",
-        "mozGetMetadata",
-        "mozGetUserMedia",
-        "mozHasAudio",
-        "mozHasItem",
-        "mozHidden",
-        "mozImageSmoothingEnabled",
-        "mozIndexedDB",
-        "mozInnerScreenX",
-        "mozInnerScreenY",
-        "mozInputSource",
-        "mozIsTextField",
-        "mozItem",
-        "mozItemCount",
-        "mozItems",
-        "mozLength",
-        "mozLockOrientation",
-        "mozMatchesSelector",
-        "mozMovementX",
-        "mozMovementY",
-        "mozOpaque",
-        "mozOrientation",
-        "mozPaintCount",
-        "mozPaintedFrames",
-        "mozParsedFrames",
-        "mozPay",
-        "mozPointerLockElement",
-        "mozPresentedFrames",
-        "mozPreservesPitch",
-        "mozPressure",
-        "mozPrintCallback",
-        "mozRTCIceCandidate",
-        "mozRTCPeerConnection",
-        "mozRTCSessionDescription",
-        "mozRemove",
-        "mozRequestAnimationFrame",
-        "mozRequestFullScreen",
-        "mozRequestPointerLock",
-        "mozSetDataAt",
-        "mozSetImageElement",
-        "mozSourceNode",
-        "mozSrcObject",
-        "mozSystem",
-        "mozTCPSocket",
-        "mozTextStyle",
-        "mozTypesAt",
-        "mozUnlockOrientation",
-        "mozUserCancelled",
-        "mozVisibilityState",
-        "msAnimation",
-        "msAnimationDelay",
-        "msAnimationDirection",
-        "msAnimationDuration",
-        "msAnimationFillMode",
-        "msAnimationIterationCount",
-        "msAnimationName",
-        "msAnimationPlayState",
-        "msAnimationStartTime",
-        "msAnimationTimingFunction",
-        "msBackfaceVisibility",
-        "msBlockProgression",
-        "msCSSOMElementFloatMetrics",
-        "msCaching",
-        "msCachingEnabled",
-        "msCancelRequestAnimationFrame",
-        "msCapsLockWarningOff",
-        "msClearImmediate",
-        "msClose",
-        "msContentZoomChaining",
-        "msContentZoomFactor",
-        "msContentZoomLimit",
-        "msContentZoomLimitMax",
-        "msContentZoomLimitMin",
-        "msContentZoomSnap",
-        "msContentZoomSnapPoints",
-        "msContentZoomSnapType",
-        "msContentZooming",
-        "msConvertURL",
-        "msCrypto",
-        "msDoNotTrack",
-        "msElementsFromPoint",
-        "msElementsFromRect",
-        "msExitFullscreen",
-        "msExtendedCode",
-        "msFillRule",
-        "msFirstPaint",
-        "msFlex",
-        "msFlexAlign",
-        "msFlexDirection",
-        "msFlexFlow",
-        "msFlexItemAlign",
-        "msFlexLinePack",
-        "msFlexNegative",
-        "msFlexOrder",
-        "msFlexPack",
-        "msFlexPositive",
-        "msFlexPreferredSize",
-        "msFlexWrap",
-        "msFlowFrom",
-        "msFlowInto",
-        "msFontFeatureSettings",
-        "msFullscreenElement",
-        "msFullscreenEnabled",
-        "msGetInputContext",
-        "msGetRegionContent",
-        "msGetUntransformedBounds",
-        "msGraphicsTrustStatus",
-        "msGridColumn",
-        "msGridColumnAlign",
-        "msGridColumnSpan",
-        "msGridColumns",
-        "msGridRow",
-        "msGridRowAlign",
-        "msGridRowSpan",
-        "msGridRows",
-        "msHidden",
-        "msHighContrastAdjust",
-        "msHyphenateLimitChars",
-        "msHyphenateLimitLines",
-        "msHyphenateLimitZone",
-        "msHyphens",
-        "msImageSmoothingEnabled",
-        "msImeAlign",
-        "msIndexedDB",
-        "msInterpolationMode",
-        "msIsStaticHTML",
-        "msKeySystem",
-        "msKeys",
-        "msLaunchUri",
-        "msLockOrientation",
-        "msManipulationViewsEnabled",
-        "msMatchMedia",
-        "msMatchesSelector",
-        "msMaxTouchPoints",
-        "msOrientation",
-        "msOverflowStyle",
-        "msPerspective",
-        "msPerspectiveOrigin",
-        "msPlayToDisabled",
-        "msPlayToPreferredSourceUri",
-        "msPlayToPrimary",
-        "msPointerEnabled",
-        "msRegionOverflow",
-        "msReleasePointerCapture",
-        "msRequestAnimationFrame",
-        "msRequestFullscreen",
-        "msSaveBlob",
-        "msSaveOrOpenBlob",
-        "msScrollChaining",
-        "msScrollLimit",
-        "msScrollLimitXMax",
-        "msScrollLimitXMin",
-        "msScrollLimitYMax",
-        "msScrollLimitYMin",
-        "msScrollRails",
-        "msScrollSnapPointsX",
-        "msScrollSnapPointsY",
-        "msScrollSnapType",
-        "msScrollSnapX",
-        "msScrollSnapY",
-        "msScrollTranslation",
-        "msSetImmediate",
-        "msSetMediaKeys",
-        "msSetPointerCapture",
-        "msTextCombineHorizontal",
-        "msTextSizeAdjust",
-        "msToBlob",
-        "msTouchAction",
-        "msTouchSelect",
-        "msTraceAsyncCallbackCompleted",
-        "msTraceAsyncCallbackStarting",
-        "msTraceAsyncOperationCompleted",
-        "msTraceAsyncOperationStarting",
-        "msTransform",
-        "msTransformOrigin",
-        "msTransformStyle",
-        "msTransition",
-        "msTransitionDelay",
-        "msTransitionDuration",
-        "msTransitionProperty",
-        "msTransitionTimingFunction",
-        "msUnlockOrientation",
-        "msUpdateAsyncCallbackRelation",
-        "msUserSelect",
-        "msVisibilityState",
-        "msWrapFlow",
-        "msWrapMargin",
-        "msWrapThrough",
-        "msWriteProfilerMark",
-        "msZoom",
-        "msZoomTo",
-        "mt",
-        "multiEntry",
-        "multiSelectionObj",
-        "multiline",
-        "multiple",
-        "multiply",
-        "multiplySelf",
-        "mutableFile",
-        "muted",
-        "n",
-        "name",
-        "nameProp",
-        "namedItem",
-        "namedRecordset",
-        "names",
-        "namespaceURI",
-        "namespaces",
-        "naturalHeight",
-        "naturalWidth",
-        "navigate",
-        "navigation",
-        "navigationMode",
-        "navigationStart",
-        "navigator",
-        "near",
-        "nearestViewportElement",
-        "negative",
-        "netscape",
-        "networkState",
-        "newScale",
-        "newTranslate",
-        "newURL",
-        "newValue",
-        "newValueSpecifiedUnits",
-        "newVersion",
-        "newhome",
-        "next",
-        "nextElementSibling",
-        "nextNode",
-        "nextPage",
-        "nextSibling",
-        "nickname",
-        "noHref",
-        "noResize",
-        "noShade",
-        "noValidate",
-        "noWrap",
-        "nodeName",
-        "nodeType",
-        "nodeValue",
-        "normalize",
-        "normalizedPathSegList",
-        "notationName",
-        "notations",
-        "note",
-        "noteGrainOn",
-        "noteOff",
-        "noteOn",
-        "now",
-        "numOctaves",
-        "number",
-        "numberOfChannels",
-        "numberOfInputs",
-        "numberOfItems",
-        "numberOfOutputs",
-        "numberValue",
-        "oMatchesSelector",
-        "object",
-        "object-fit",
-        "object-position",
-        "objectFit",
-        "objectPosition",
-        "objectStore",
-        "objectStoreNames",
-        "observe",
-        "of",
-        "offscreenBuffering",
-        "offset",
-        "offsetHeight",
-        "offsetLeft",
-        "offsetNode",
-        "offsetParent",
-        "offsetTop",
-        "offsetWidth",
-        "offsetX",
-        "offsetY",
-        "ok",
-        "oldURL",
-        "oldValue",
-        "oldVersion",
-        "olderShadowRoot",
-        "onLine",
-        "onabort",
-        "onactivate",
-        "onactive",
-        "onaddstream",
-        "onaddtrack",
-        "onafterprint",
-        "onafterscriptexecute",
-        "onafterupdate",
-        "onaudioend",
-        "onaudioprocess",
-        "onaudiostart",
-        "onautocomplete",
-        "onautocompleteerror",
-        "onbeforeactivate",
-        "onbeforecopy",
-        "onbeforecut",
-        "onbeforedeactivate",
-        "onbeforeeditfocus",
-        "onbeforepaste",
-        "onbeforeprint",
-        "onbeforescriptexecute",
-        "onbeforeunload",
-        "onbeforeupdate",
-        "onblocked",
-        "onblur",
-        "onbounce",
-        "onboundary",
-        "oncached",
-        "oncancel",
-        "oncandidatewindowhide",
-        "oncandidatewindowshow",
-        "oncandidatewindowupdate",
-        "oncanplay",
-        "oncanplaythrough",
-        "oncellchange",
-        "onchange",
-        "onchargingchange",
-        "onchargingtimechange",
-        "onchecking",
-        "onclick",
-        "onclose",
-        "oncompassneedscalibration",
-        "oncomplete",
-        "oncontextmenu",
-        "oncontrolselect",
-        "oncopy",
-        "oncuechange",
-        "oncut",
-        "ondataavailable",
-        "ondatachannel",
-        "ondatasetchanged",
-        "ondatasetcomplete",
-        "ondblclick",
-        "ondeactivate",
-        "ondevicelight",
-        "ondevicemotion",
-        "ondeviceorientation",
-        "ondeviceproximity",
-        "ondischargingtimechange",
-        "ondisplay",
-        "ondownloading",
-        "ondrag",
-        "ondragend",
-        "ondragenter",
-        "ondragleave",
-        "ondragover",
-        "ondragstart",
-        "ondrop",
-        "ondurationchange",
-        "onemptied",
-        "onencrypted",
-        "onend",
-        "onended",
-        "onenter",
-        "onerror",
-        "onerrorupdate",
-        "onexit",
-        "onfilterchange",
-        "onfinish",
-        "onfocus",
-        "onfocusin",
-        "onfocusout",
-        "onfullscreenchange",
-        "onfullscreenerror",
-        "ongesturechange",
-        "ongestureend",
-        "ongesturestart",
-        "ongotpointercapture",
-        "onhashchange",
-        "onhelp",
-        "onicecandidate",
-        "oniceconnectionstatechange",
-        "oninactive",
-        "oninput",
-        "oninvalid",
-        "onkeydown",
-        "onkeypress",
-        "onkeyup",
-        "onlanguagechange",
-        "onlayoutcomplete",
-        "onlevelchange",
-        "onload",
-        "onloadeddata",
-        "onloadedmetadata",
-        "onloadend",
-        "onloadstart",
-        "onlosecapture",
-        "onlostpointercapture",
-        "only",
-        "onmark",
-        "onmessage",
-        "onmousedown",
-        "onmouseenter",
-        "onmouseleave",
-        "onmousemove",
-        "onmouseout",
-        "onmouseover",
-        "onmouseup",
-        "onmousewheel",
-        "onmove",
-        "onmoveend",
-        "onmovestart",
-        "onmozfullscreenchange",
-        "onmozfullscreenerror",
-        "onmozorientationchange",
-        "onmozpointerlockchange",
-        "onmozpointerlockerror",
-        "onmscontentzoom",
-        "onmsfullscreenchange",
-        "onmsfullscreenerror",
-        "onmsgesturechange",
-        "onmsgesturedoubletap",
-        "onmsgestureend",
-        "onmsgesturehold",
-        "onmsgesturestart",
-        "onmsgesturetap",
-        "onmsgotpointercapture",
-        "onmsinertiastart",
-        "onmslostpointercapture",
-        "onmsmanipulationstatechanged",
-        "onmsneedkey",
-        "onmsorientationchange",
-        "onmspointercancel",
-        "onmspointerdown",
-        "onmspointerenter",
-        "onmspointerhover",
-        "onmspointerleave",
-        "onmspointermove",
-        "onmspointerout",
-        "onmspointerover",
-        "onmspointerup",
-        "onmssitemodejumplistitemremoved",
-        "onmsthumbnailclick",
-        "onnegotiationneeded",
-        "onnomatch",
-        "onnoupdate",
-        "onobsolete",
-        "onoffline",
-        "ononline",
-        "onopen",
-        "onorientationchange",
-        "onpagechange",
-        "onpagehide",
-        "onpageshow",
-        "onpaste",
-        "onpause",
-        "onplay",
-        "onplaying",
-        "onpluginstreamstart",
-        "onpointercancel",
-        "onpointerdown",
-        "onpointerenter",
-        "onpointerleave",
-        "onpointerlockchange",
-        "onpointerlockerror",
-        "onpointermove",
-        "onpointerout",
-        "onpointerover",
-        "onpointerup",
-        "onpopstate",
-        "onprogress",
-        "onpropertychange",
-        "onratechange",
-        "onreadystatechange",
-        "onremovestream",
-        "onremovetrack",
-        "onreset",
-        "onresize",
-        "onresizeend",
-        "onresizestart",
-        "onresourcetimingbufferfull",
-        "onresult",
-        "onresume",
-        "onrowenter",
-        "onrowexit",
-        "onrowsdelete",
-        "onrowsinserted",
-        "onscroll",
-        "onsearch",
-        "onseeked",
-        "onseeking",
-        "onselect",
-        "onselectionchange",
-        "onselectstart",
-        "onshow",
-        "onsignalingstatechange",
-        "onsoundend",
-        "onsoundstart",
-        "onspeechend",
-        "onspeechstart",
-        "onstalled",
-        "onstart",
-        "onstatechange",
-        "onstop",
-        "onstorage",
-        "onstoragecommit",
-        "onsubmit",
-        "onsuccess",
-        "onsuspend",
-        "ontextinput",
-        "ontimeout",
-        "ontimeupdate",
-        "ontoggle",
-        "ontouchcancel",
-        "ontouchend",
-        "ontouchmove",
-        "ontouchstart",
-        "ontransitionend",
-        "onunload",
-        "onupdateready",
-        "onupgradeneeded",
-        "onuserproximity",
-        "onversionchange",
-        "onvoiceschanged",
-        "onvolumechange",
-        "onwaiting",
-        "onwarning",
-        "onwebkitanimationend",
-        "onwebkitanimationiteration",
-        "onwebkitanimationstart",
-        "onwebkitcurrentplaybacktargetiswirelesschanged",
-        "onwebkitfullscreenchange",
-        "onwebkitfullscreenerror",
-        "onwebkitkeyadded",
-        "onwebkitkeyerror",
-        "onwebkitkeymessage",
-        "onwebkitneedkey",
-        "onwebkitorientationchange",
-        "onwebkitplaybacktargetavailabilitychanged",
-        "onwebkitpointerlockchange",
-        "onwebkitpointerlockerror",
-        "onwebkitresourcetimingbufferfull",
-        "onwebkittransitionend",
-        "onwheel",
-        "onzoom",
-        "opacity",
-        "open",
-        "openCursor",
-        "openDatabase",
-        "openKeyCursor",
-        "opener",
-        "opera",
-        "operationType",
-        "operator",
-        "opr",
-        "optimum",
-        "options",
-        "order",
-        "orderX",
-        "orderY",
-        "ordered",
-        "org",
-        "orient",
-        "orientAngle",
-        "orientType",
-        "orientation",
-        "origin",
-        "originalTarget",
-        "orphans",
-        "oscpu",
-        "outerHTML",
-        "outerHeight",
-        "outerText",
-        "outerWidth",
-        "outline",
-        "outline-color",
-        "outline-offset",
-        "outline-style",
-        "outline-width",
-        "outlineColor",
-        "outlineOffset",
-        "outlineStyle",
-        "outlineWidth",
-        "outputBuffer",
-        "overflow",
-        "overflow-x",
-        "overflow-y",
-        "overflowX",
-        "overflowY",
-        "overrideMimeType",
-        "oversample",
-        "ownerDocument",
-        "ownerElement",
-        "ownerNode",
-        "ownerRule",
-        "ownerSVGElement",
-        "owningElement",
-        "p1",
-        "p2",
-        "p3",
-        "p4",
-        "pad",
-        "padding",
-        "padding-bottom",
-        "padding-left",
-        "padding-right",
-        "padding-top",
-        "paddingBottom",
-        "paddingLeft",
-        "paddingRight",
-        "paddingTop",
-        "page",
-        "page-break-after",
-        "page-break-before",
-        "page-break-inside",
-        "pageBreakAfter",
-        "pageBreakBefore",
-        "pageBreakInside",
-        "pageCount",
-        "pageX",
-        "pageXOffset",
-        "pageY",
-        "pageYOffset",
-        "pages",
-        "paint-order",
-        "paintOrder",
-        "paintRequests",
-        "paintType",
-        "palette",
-        "panningModel",
-        "parent",
-        "parentElement",
-        "parentNode",
-        "parentRule",
-        "parentStyleSheet",
-        "parentTextEdit",
-        "parentWindow",
-        "parse",
-        "parseFloat",
-        "parseFromString",
-        "parseInt",
-        "participants",
-        "password",
-        "pasteHTML",
-        "path",
-        "pathLength",
-        "pathSegList",
-        "pathSegType",
-        "pathSegTypeAsLetter",
-        "pathname",
-        "pattern",
-        "patternContentUnits",
-        "patternMismatch",
-        "patternTransform",
-        "patternUnits",
-        "pause",
-        "pauseAnimations",
-        "pauseOnExit",
-        "paused",
-        "pending",
-        "performance",
-        "permission",
-        "persisted",
-        "personalbar",
-        "perspective",
-        "perspective-origin",
-        "perspectiveOrigin",
-        "phoneticFamilyName",
-        "phoneticGivenName",
-        "photo",
-        "ping",
-        "pitch",
-        "pixelBottom",
-        "pixelDepth",
-        "pixelHeight",
-        "pixelLeft",
-        "pixelRight",
-        "pixelStorei",
-        "pixelTop",
-        "pixelUnitToMillimeterX",
-        "pixelUnitToMillimeterY",
-        "pixelWidth",
-        "placeholder",
-        "platform",
-        "play",
-        "playbackRate",
-        "playbackState",
-        "playbackTime",
-        "played",
-        "plugins",
-        "pluginspage",
-        "pname",
-        "pointer-events",
-        "pointerBeforeReferenceNode",
-        "pointerEnabled",
-        "pointerEvents",
-        "pointerId",
-        "pointerLockElement",
-        "pointerType",
-        "points",
-        "pointsAtX",
-        "pointsAtY",
-        "pointsAtZ",
-        "polygonOffset",
-        "pop",
-        "popupWindowFeatures",
-        "popupWindowName",
-        "popupWindowURI",
-        "port",
-        "port1",
-        "port2",
-        "ports",
-        "posBottom",
-        "posHeight",
-        "posLeft",
-        "posRight",
-        "posTop",
-        "posWidth",
-        "position",
-        "positionAlign",
-        "postError",
-        "postMessage",
-        "poster",
-        "pow",
-        "powerOff",
-        "preMultiplySelf",
-        "precision",
-        "preferredStyleSheetSet",
-        "preferredStylesheetSet",
-        "prefix",
-        "preload",
-        "preserveAlpha",
-        "preserveAspectRatio",
-        "preserveAspectRatioString",
-        "pressed",
-        "pressure",
-        "prevValue",
-        "preventDefault",
-        "preventExtensions",
-        "previousElementSibling",
-        "previousNode",
-        "previousPage",
-        "previousScale",
-        "previousSibling",
-        "previousTranslate",
-        "primaryKey",
-        "primitiveType",
-        "primitiveUnits",
-        "principals",
-        "print",
-        "privateKey",
-        "probablySupportsContext",
-        "process",
-        "processIceMessage",
-        "product",
-        "productSub",
-        "profile",
-        "profileEnd",
-        "profiles",
-        "prompt",
-        "properties",
-        "propertyIsEnumerable",
-        "propertyName",
-        "protocol",
-        "protocolLong",
-        "prototype",
-        "pseudoClass",
-        "pseudoElement",
-        "publicId",
-        "publicKey",
-        "published",
-        "push",
-        "pushNotification",
-        "pushState",
-        "put",
-        "putImageData",
-        "quadraticCurveTo",
-        "qualifier",
-        "queryCommandEnabled",
-        "queryCommandIndeterm",
-        "queryCommandState",
-        "queryCommandSupported",
-        "queryCommandText",
-        "queryCommandValue",
-        "querySelector",
-        "querySelectorAll",
-        "quote",
-        "quotes",
-        "r",
-        "r1",
-        "r2",
-        "race",
-        "radiogroup",
-        "radiusX",
-        "radiusY",
-        "random",
-        "range",
-        "rangeCount",
-        "rangeMax",
-        "rangeMin",
-        "rangeOffset",
-        "rangeOverflow",
-        "rangeParent",
-        "rangeUnderflow",
-        "rate",
-        "ratio",
-        "raw",
-        "read",
-        "readAsArrayBuffer",
-        "readAsBinaryString",
-        "readAsBlob",
-        "readAsDataURL",
-        "readAsText",
-        "readOnly",
-        "readPixels",
-        "readReportRequested",
-        "readyState",
-        "reason",
-        "reboot",
-        "receiver",
-        "receivers",
-        "recordNumber",
-        "recordset",
-        "rect",
-        "red",
-        "redirectCount",
-        "redirectEnd",
-        "redirectStart",
-        "reduce",
-        "reduceRight",
-        "reduction",
-        "refDistance",
-        "refX",
-        "refY",
-        "referenceNode",
-        "referrer",
-        "refresh",
-        "region",
-        "regionAnchorX",
-        "regionAnchorY",
-        "regionId",
-        "regions",
-        "register",
-        "registerContentHandler",
-        "registerElement",
-        "registerProtocolHandler",
-        "reject",
-        "rel",
-        "relList",
-        "relatedNode",
-        "relatedTarget",
-        "release",
-        "releaseCapture",
-        "releaseEvents",
-        "releasePointerCapture",
-        "releaseShaderCompiler",
-        "reliable",
-        "reload",
-        "remainingSpace",
-        "remoteDescription",
-        "remove",
-        "removeAllRanges",
-        "removeAttribute",
-        "removeAttributeNS",
-        "removeAttributeNode",
-        "removeBehavior",
-        "removeChild",
-        "removeCue",
-        "removeEventListener",
-        "removeFilter",
-        "removeImport",
-        "removeItem",
-        "removeListener",
-        "removeNamedItem",
-        "removeNamedItemNS",
-        "removeNode",
-        "removeParameter",
-        "removeProperty",
-        "removeRange",
-        "removeRegion",
-        "removeRule",
-        "removeSiteSpecificTrackingException",
-        "removeSourceBuffer",
-        "removeStream",
-        "removeTrack",
-        "removeVariable",
-        "removeWakeLockListener",
-        "removeWebWideTrackingException",
-        "removedNodes",
-        "renderbufferStorage",
-        "renderedBuffer",
-        "renderingMode",
-        "repeat",
-        "replace",
-        "replaceAdjacentText",
-        "replaceChild",
-        "replaceData",
-        "replaceId",
-        "replaceItem",
-        "replaceNode",
-        "replaceState",
-        "replaceTrack",
-        "replaceWholeText",
-        "reportValidity",
-        "requestAnimationFrame",
-        "requestAutocomplete",
-        "requestData",
-        "requestFullscreen",
-        "requestMediaKeySystemAccess",
-        "requestPermission",
-        "requestPointerLock",
-        "requestStart",
-        "requestingWindow",
-        "required",
-        "requiredExtensions",
-        "requiredFeatures",
-        "reset",
-        "resetTransform",
-        "resize",
-        "resizeBy",
-        "resizeTo",
-        "resolve",
-        "response",
-        "responseBody",
-        "responseEnd",
-        "responseStart",
-        "responseText",
-        "responseType",
-        "responseURL",
-        "responseXML",
-        "restore",
-        "result",
-        "resultType",
-        "resume",
-        "returnValue",
-        "rev",
-        "reverse",
-        "reversed",
-        "revocable",
-        "revokeObjectURL",
-        "rgbColor",
-        "right",
-        "rightContext",
-        "rightMargin",
-        "rolloffFactor",
-        "root",
-        "rootElement",
-        "rotate",
-        "rotateAxisAngle",
-        "rotateAxisAngleSelf",
-        "rotateFromVector",
-        "rotateFromVectorSelf",
-        "rotateSelf",
-        "rotation",
-        "rotationRate",
-        "round",
-        "rowIndex",
-        "rowSpan",
-        "rows",
-        "rubyAlign",
-        "rubyOverhang",
-        "rubyPosition",
-        "rules",
-        "runtime",
-        "runtimeStyle",
-        "rx",
-        "ry",
-        "safari",
-        "sampleCoverage",
-        "sampleRate",
-        "sandbox",
-        "save",
-        "scale",
-        "scale3d",
-        "scale3dSelf",
-        "scaleNonUniform",
-        "scaleNonUniformSelf",
-        "scaleSelf",
-        "scheme",
-        "scissor",
-        "scope",
-        "scopeName",
-        "scoped",
-        "screen",
-        "screenBrightness",
-        "screenEnabled",
-        "screenLeft",
-        "screenPixelToMillimeterX",
-        "screenPixelToMillimeterY",
-        "screenTop",
-        "screenX",
-        "screenY",
-        "scripts",
-        "scroll",
-        "scroll-behavior",
-        "scrollAmount",
-        "scrollBehavior",
-        "scrollBy",
-        "scrollByLines",
-        "scrollByPages",
-        "scrollDelay",
-        "scrollHeight",
-        "scrollIntoView",
-        "scrollIntoViewIfNeeded",
-        "scrollLeft",
-        "scrollLeftMax",
-        "scrollMaxX",
-        "scrollMaxY",
-        "scrollTo",
-        "scrollTop",
-        "scrollTopMax",
-        "scrollWidth",
-        "scrollX",
-        "scrollY",
-        "scrollbar3dLightColor",
-        "scrollbarArrowColor",
-        "scrollbarBaseColor",
-        "scrollbarDarkShadowColor",
-        "scrollbarFaceColor",
-        "scrollbarHighlightColor",
-        "scrollbarShadowColor",
-        "scrollbarTrackColor",
-        "scrollbars",
-        "scrolling",
-        "sdp",
-        "sdpMLineIndex",
-        "sdpMid",
-        "seal",
-        "search",
-        "searchBox",
-        "searchBoxJavaBridge_",
-        "searchParams",
-        "sectionRowIndex",
-        "secureConnectionStart",
-        "security",
-        "seed",
-        "seekable",
-        "seeking",
-        "select",
-        "selectAllChildren",
-        "selectNode",
-        "selectNodeContents",
-        "selectNodes",
-        "selectSingleNode",
-        "selectSubString",
-        "selected",
-        "selectedIndex",
-        "selectedOptions",
-        "selectedStyleSheetSet",
-        "selectedStylesheetSet",
-        "selection",
-        "selectionDirection",
-        "selectionEnd",
-        "selectionStart",
-        "selector",
-        "selectorText",
-        "self",
-        "send",
-        "sendAsBinary",
-        "sendBeacon",
-        "sender",
-        "sentTimestamp",
-        "separator",
-        "serializeToString",
-        "serviceWorker",
-        "sessionId",
-        "sessionStorage",
-        "set",
-        "setActive",
-        "setAlpha",
-        "setAttribute",
-        "setAttributeNS",
-        "setAttributeNode",
-        "setAttributeNodeNS",
-        "setBaseAndExtent",
-        "setBingCurrentSearchDefault",
-        "setCapture",
-        "setColor",
-        "setCompositeOperation",
-        "setCurrentTime",
-        "setCustomValidity",
-        "setData",
-        "setDate",
-        "setDragImage",
-        "setEnd",
-        "setEndAfter",
-        "setEndBefore",
-        "setEndPoint",
-        "setFillColor",
-        "setFilterRes",
-        "setFloat32",
-        "setFloat64",
-        "setFloatValue",
-        "setFullYear",
-        "setHours",
-        "setImmediate",
-        "setInt16",
-        "setInt32",
-        "setInt8",
-        "setInterval",
-        "setItem",
-        "setLineCap",
-        "setLineDash",
-        "setLineJoin",
-        "setLineWidth",
-        "setLocalDescription",
-        "setMatrix",
-        "setMatrixValue",
-        "setMediaKeys",
-        "setMilliseconds",
-        "setMinutes",
-        "setMiterLimit",
-        "setMonth",
-        "setNamedItem",
-        "setNamedItemNS",
-        "setNonUserCodeExceptions",
-        "setOrientToAngle",
-        "setOrientToAuto",
-        "setOrientation",
-        "setOverrideHistoryNavigationMode",
-        "setPaint",
-        "setParameter",
-        "setPeriodicWave",
-        "setPointerCapture",
-        "setPosition",
-        "setPreference",
-        "setProperty",
-        "setPrototypeOf",
-        "setRGBColor",
-        "setRGBColorICCColor",
-        "setRadius",
-        "setRangeText",
-        "setRemoteDescription",
-        "setRequestHeader",
-        "setResizable",
-        "setResourceTimingBufferSize",
-        "setRotate",
-        "setScale",
-        "setSeconds",
-        "setSelectionRange",
-        "setServerCertificate",
-        "setShadow",
-        "setSkewX",
-        "setSkewY",
-        "setStart",
-        "setStartAfter",
-        "setStartBefore",
-        "setStdDeviation",
-        "setStringValue",
-        "setStrokeColor",
-        "setSuggestResult",
-        "setTargetAtTime",
-        "setTargetValueAtTime",
-        "setTime",
-        "setTimeout",
-        "setTransform",
-        "setTranslate",
-        "setUTCDate",
-        "setUTCFullYear",
-        "setUTCHours",
-        "setUTCMilliseconds",
-        "setUTCMinutes",
-        "setUTCMonth",
-        "setUTCSeconds",
-        "setUint16",
-        "setUint32",
-        "setUint8",
-        "setUri",
-        "setValueAtTime",
-        "setValueCurveAtTime",
-        "setVariable",
-        "setVelocity",
-        "setVersion",
-        "setYear",
-        "settingName",
-        "settingValue",
-        "sex",
-        "shaderSource",
-        "shadowBlur",
-        "shadowColor",
-        "shadowOffsetX",
-        "shadowOffsetY",
-        "shadowRoot",
-        "shape",
-        "shape-rendering",
-        "shapeRendering",
-        "sheet",
-        "shift",
-        "shiftKey",
-        "shiftLeft",
-        "show",
-        "showHelp",
-        "showModal",
-        "showModalDialog",
-        "showModelessDialog",
-        "showNotification",
-        "sidebar",
-        "sign",
-        "signalingState",
-        "sin",
-        "singleNodeValue",
-        "sinh",
-        "size",
-        "sizeToContent",
-        "sizes",
-        "skewX",
-        "skewXSelf",
-        "skewY",
-        "skewYSelf",
-        "slice",
-        "slope",
-        "small",
-        "smil",
-        "smoothingTimeConstant",
-        "snapToLines",
-        "snapshotItem",
-        "snapshotLength",
-        "some",
-        "sort",
-        "source",
-        "sourceBuffer",
-        "sourceBuffers",
-        "sourceIndex",
-        "spacing",
-        "span",
-        "speakAs",
-        "speaking",
-        "specified",
-        "specularConstant",
-        "specularExponent",
-        "speechSynthesis",
-        "speed",
-        "speedOfSound",
-        "spellcheck",
-        "splice",
-        "split",
-        "splitText",
-        "spreadMethod",
-        "sqrt",
-        "src",
-        "srcElement",
-        "srcFilter",
-        "srcUrn",
-        "srcdoc",
-        "srclang",
-        "srcset",
-        "stack",
-        "stackTraceLimit",
-        "stacktrace",
-        "standalone",
-        "standby",
-        "start",
-        "startContainer",
-        "startIce",
-        "startOffset",
-        "startRendering",
-        "startTime",
-        "startsWith",
-        "state",
-        "status",
-        "statusMessage",
-        "statusText",
-        "statusbar",
-        "stdDeviationX",
-        "stdDeviationY",
-        "stencilFunc",
-        "stencilFuncSeparate",
-        "stencilMask",
-        "stencilMaskSeparate",
-        "stencilOp",
-        "stencilOpSeparate",
-        "step",
-        "stepDown",
-        "stepMismatch",
-        "stepUp",
-        "sticky",
-        "stitchTiles",
-        "stop",
-        "stop-color",
-        "stop-opacity",
-        "stopColor",
-        "stopImmediatePropagation",
-        "stopOpacity",
-        "stopPropagation",
-        "storageArea",
-        "storageName",
-        "storageStatus",
-        "storeSiteSpecificTrackingException",
-        "storeWebWideTrackingException",
-        "stpVersion",
-        "stream",
-        "strike",
-        "stringValue",
-        "stringify",
-        "stroke",
-        "stroke-dasharray",
-        "stroke-dashoffset",
-        "stroke-linecap",
-        "stroke-linejoin",
-        "stroke-miterlimit",
-        "stroke-opacity",
-        "stroke-width",
-        "strokeDasharray",
-        "strokeDashoffset",
-        "strokeLinecap",
-        "strokeLinejoin",
-        "strokeMiterlimit",
-        "strokeOpacity",
-        "strokeRect",
-        "strokeStyle",
-        "strokeText",
-        "strokeWidth",
-        "style",
-        "styleFloat",
-        "styleMedia",
-        "styleSheet",
-        "styleSheetSets",
-        "styleSheets",
-        "sub",
-        "subarray",
-        "subject",
-        "submit",
-        "subscribe",
-        "substr",
-        "substring",
-        "substringData",
-        "subtle",
-        "suffix",
-        "suffixes",
-        "summary",
-        "sup",
-        "supports",
-        "surfaceScale",
-        "surroundContents",
-        "suspend",
-        "suspendRedraw",
-        "swapCache",
-        "swapNode",
-        "sweepFlag",
-        "symbols",
-        "system",
-        "systemCode",
-        "systemId",
-        "systemLanguage",
-        "systemXDPI",
-        "systemYDPI",
-        "tBodies",
-        "tFoot",
-        "tHead",
-        "tabIndex",
-        "table",
-        "table-layout",
-        "tableLayout",
-        "tableValues",
-        "tag",
-        "tagName",
-        "tagUrn",
-        "tags",
-        "taintEnabled",
-        "takeRecords",
-        "tan",
-        "tanh",
-        "target",
-        "targetElement",
-        "targetTouches",
-        "targetX",
-        "targetY",
-        "tel",
-        "terminate",
-        "test",
-        "texImage2D",
-        "texParameterf",
-        "texParameteri",
-        "texSubImage2D",
-        "text",
-        "text-align",
-        "text-anchor",
-        "text-decoration",
-        "text-decoration-color",
-        "text-decoration-line",
-        "text-decoration-style",
-        "text-indent",
-        "text-overflow",
-        "text-rendering",
-        "text-shadow",
-        "text-transform",
-        "textAlign",
-        "textAlignLast",
-        "textAnchor",
-        "textAutospace",
-        "textBaseline",
-        "textContent",
-        "textDecoration",
-        "textDecorationBlink",
-        "textDecorationColor",
-        "textDecorationLine",
-        "textDecorationLineThrough",
-        "textDecorationNone",
-        "textDecorationOverline",
-        "textDecorationStyle",
-        "textDecorationUnderline",
-        "textIndent",
-        "textJustify",
-        "textJustifyTrim",
-        "textKashida",
-        "textKashidaSpace",
-        "textLength",
-        "textOverflow",
-        "textRendering",
-        "textShadow",
-        "textTracks",
-        "textTransform",
-        "textUnderlinePosition",
-        "then",
-        "threadId",
-        "threshold",
-        "tiltX",
-        "tiltY",
-        "time",
-        "timeEnd",
-        "timeStamp",
-        "timeout",
-        "timestamp",
-        "timestampOffset",
-        "timing",
-        "title",
-        "toArray",
-        "toBlob",
-        "toDataURL",
-        "toDateString",
-        "toElement",
-        "toExponential",
-        "toFixed",
-        "toFloat32Array",
-        "toFloat64Array",
-        "toGMTString",
-        "toISOString",
-        "toJSON",
-        "toLocaleDateString",
-        "toLocaleFormat",
-        "toLocaleLowerCase",
-        "toLocaleString",
-        "toLocaleTimeString",
-        "toLocaleUpperCase",
-        "toLowerCase",
-        "toMethod",
-        "toPrecision",
-        "toSdp",
-        "toSource",
-        "toStaticHTML",
-        "toString",
-        "toStringTag",
-        "toTimeString",
-        "toUTCString",
-        "toUpperCase",
-        "toggle",
-        "toggleLongPressEnabled",
-        "tooLong",
-        "toolbar",
-        "top",
-        "topMargin",
-        "total",
-        "totalFrameDelay",
-        "totalVideoFrames",
-        "touchAction",
-        "touches",
-        "trace",
-        "track",
-        "transaction",
-        "transactions",
-        "transform",
-        "transform-origin",
-        "transform-style",
-        "transformOrigin",
-        "transformPoint",
-        "transformString",
-        "transformStyle",
-        "transformToDocument",
-        "transformToFragment",
-        "transition",
-        "transition-delay",
-        "transition-duration",
-        "transition-property",
-        "transition-timing-function",
-        "transitionDelay",
-        "transitionDuration",
-        "transitionProperty",
-        "transitionTimingFunction",
-        "translate",
-        "translateSelf",
-        "translationX",
-        "translationY",
-        "trim",
-        "trimLeft",
-        "trimRight",
-        "trueSpeed",
-        "trunc",
-        "truncate",
-        "type",
-        "typeDetail",
-        "typeMismatch",
-        "typeMustMatch",
-        "types",
-        "ubound",
-        "undefined",
-        "unescape",
-        "uneval",
-        "unicode-bidi",
-        "unicodeBidi",
-        "uniform1f",
-        "uniform1fv",
-        "uniform1i",
-        "uniform1iv",
-        "uniform2f",
-        "uniform2fv",
-        "uniform2i",
-        "uniform2iv",
-        "uniform3f",
-        "uniform3fv",
-        "uniform3i",
-        "uniform3iv",
-        "uniform4f",
-        "uniform4fv",
-        "uniform4i",
-        "uniform4iv",
-        "uniformMatrix2fv",
-        "uniformMatrix3fv",
-        "uniformMatrix4fv",
-        "unique",
-        "uniqueID",
-        "uniqueNumber",
-        "unitType",
-        "units",
-        "unloadEventEnd",
-        "unloadEventStart",
-        "unlock",
-        "unmount",
-        "unobserve",
-        "unpause",
-        "unpauseAnimations",
-        "unreadCount",
-        "unregister",
-        "unregisterContentHandler",
-        "unregisterProtocolHandler",
-        "unscopables",
-        "unselectable",
-        "unshift",
-        "unsubscribe",
-        "unsuspendRedraw",
-        "unsuspendRedrawAll",
-        "unwatch",
-        "unwrapKey",
-        "update",
-        "updateCommands",
-        "updateIce",
-        "updateInterval",
-        "updateSettings",
-        "updated",
-        "updating",
-        "upload",
-        "upper",
-        "upperBound",
-        "upperOpen",
-        "uri",
-        "url",
-        "urn",
-        "urns",
-        "usages",
-        "useCurrentView",
-        "useMap",
-        "useProgram",
-        "usedSpace",
-        "userAgent",
-        "userLanguage",
-        "username",
-        "v8BreakIterator",
-        "vAlign",
-        "vLink",
-        "valid",
-        "validateProgram",
-        "validationMessage",
-        "validity",
-        "value",
-        "valueAsDate",
-        "valueAsNumber",
-        "valueAsString",
-        "valueInSpecifiedUnits",
-        "valueMissing",
-        "valueOf",
-        "valueText",
-        "valueType",
-        "values",
-        "vector-effect",
-        "vectorEffect",
-        "velocityAngular",
-        "velocityExpansion",
-        "velocityX",
-        "velocityY",
-        "vendor",
-        "vendorSub",
-        "verify",
-        "version",
-        "vertexAttrib1f",
-        "vertexAttrib1fv",
-        "vertexAttrib2f",
-        "vertexAttrib2fv",
-        "vertexAttrib3f",
-        "vertexAttrib3fv",
-        "vertexAttrib4f",
-        "vertexAttrib4fv",
-        "vertexAttribDivisorANGLE",
-        "vertexAttribPointer",
-        "vertical",
-        "vertical-align",
-        "verticalAlign",
-        "verticalOverflow",
-        "vibrate",
-        "videoHeight",
-        "videoTracks",
-        "videoWidth",
-        "view",
-        "viewBox",
-        "viewBoxString",
-        "viewTarget",
-        "viewTargetString",
-        "viewport",
-        "viewportAnchorX",
-        "viewportAnchorY",
-        "viewportElement",
-        "visibility",
-        "visibilityState",
-        "visible",
-        "vlinkColor",
-        "voice",
-        "volume",
-        "vrml",
-        "vspace",
-        "w",
-        "wand",
-        "warn",
-        "wasClean",
-        "watch",
-        "watchPosition",
-        "webdriver",
-        "webkitAddKey",
-        "webkitAnimation",
-        "webkitAnimationDelay",
-        "webkitAnimationDirection",
-        "webkitAnimationDuration",
-        "webkitAnimationFillMode",
-        "webkitAnimationIterationCount",
-        "webkitAnimationName",
-        "webkitAnimationPlayState",
-        "webkitAnimationTimingFunction",
-        "webkitAppearance",
-        "webkitAudioContext",
-        "webkitAudioDecodedByteCount",
-        "webkitAudioPannerNode",
-        "webkitBackfaceVisibility",
-        "webkitBackground",
-        "webkitBackgroundAttachment",
-        "webkitBackgroundClip",
-        "webkitBackgroundColor",
-        "webkitBackgroundImage",
-        "webkitBackgroundOrigin",
-        "webkitBackgroundPosition",
-        "webkitBackgroundPositionX",
-        "webkitBackgroundPositionY",
-        "webkitBackgroundRepeat",
-        "webkitBackgroundSize",
-        "webkitBackingStorePixelRatio",
-        "webkitBorderImage",
-        "webkitBorderImageOutset",
-        "webkitBorderImageRepeat",
-        "webkitBorderImageSlice",
-        "webkitBorderImageSource",
-        "webkitBorderImageWidth",
-        "webkitBoxAlign",
-        "webkitBoxDirection",
-        "webkitBoxFlex",
-        "webkitBoxOrdinalGroup",
-        "webkitBoxOrient",
-        "webkitBoxPack",
-        "webkitBoxSizing",
-        "webkitCancelAnimationFrame",
-        "webkitCancelFullScreen",
-        "webkitCancelKeyRequest",
-        "webkitCancelRequestAnimationFrame",
-        "webkitClearResourceTimings",
-        "webkitClosedCaptionsVisible",
-        "webkitConvertPointFromNodeToPage",
-        "webkitConvertPointFromPageToNode",
-        "webkitCreateShadowRoot",
-        "webkitCurrentFullScreenElement",
-        "webkitCurrentPlaybackTargetIsWireless",
-        "webkitDirectionInvertedFromDevice",
-        "webkitDisplayingFullscreen",
-        "webkitEnterFullScreen",
-        "webkitEnterFullscreen",
-        "webkitExitFullScreen",
-        "webkitExitFullscreen",
-        "webkitExitPointerLock",
-        "webkitFullScreenKeyboardInputAllowed",
-        "webkitFullscreenElement",
-        "webkitFullscreenEnabled",
-        "webkitGenerateKeyRequest",
-        "webkitGetAsEntry",
-        "webkitGetDatabaseNames",
-        "webkitGetEntries",
-        "webkitGetEntriesByName",
-        "webkitGetEntriesByType",
-        "webkitGetFlowByName",
-        "webkitGetGamepads",
-        "webkitGetImageDataHD",
-        "webkitGetNamedFlows",
-        "webkitGetRegionFlowRanges",
-        "webkitGetUserMedia",
-        "webkitHasClosedCaptions",
-        "webkitHidden",
-        "webkitIDBCursor",
-        "webkitIDBDatabase",
-        "webkitIDBDatabaseError",
-        "webkitIDBDatabaseException",
-        "webkitIDBFactory",
-        "webkitIDBIndex",
-        "webkitIDBKeyRange",
-        "webkitIDBObjectStore",
-        "webkitIDBRequest",
-        "webkitIDBTransaction",
-        "webkitImageSmoothingEnabled",
-        "webkitIndexedDB",
-        "webkitInitMessageEvent",
-        "webkitIsFullScreen",
-        "webkitKeys",
-        "webkitLineDashOffset",
-        "webkitLockOrientation",
-        "webkitMatchesSelector",
-        "webkitMediaStream",
-        "webkitNotifications",
-        "webkitOfflineAudioContext",
-        "webkitOrientation",
-        "webkitPeerConnection00",
-        "webkitPersistentStorage",
-        "webkitPointerLockElement",
-        "webkitPostMessage",
-        "webkitPreservesPitch",
-        "webkitPutImageDataHD",
-        "webkitRTCPeerConnection",
-        "webkitRegionOverset",
-        "webkitRequestAnimationFrame",
-        "webkitRequestFileSystem",
-        "webkitRequestFullScreen",
-        "webkitRequestFullscreen",
-        "webkitRequestPointerLock",
-        "webkitResolveLocalFileSystemURL",
-        "webkitSetMediaKeys",
-        "webkitSetResourceTimingBufferSize",
-        "webkitShadowRoot",
-        "webkitShowPlaybackTargetPicker",
-        "webkitSlice",
-        "webkitSpeechGrammar",
-        "webkitSpeechGrammarList",
-        "webkitSpeechRecognition",
-        "webkitSpeechRecognitionError",
-        "webkitSpeechRecognitionEvent",
-        "webkitStorageInfo",
-        "webkitSupportsFullscreen",
-        "webkitTemporaryStorage",
-        "webkitTextSizeAdjust",
-        "webkitTransform",
-        "webkitTransformOrigin",
-        "webkitTransition",
-        "webkitTransitionDelay",
-        "webkitTransitionDuration",
-        "webkitTransitionProperty",
-        "webkitTransitionTimingFunction",
-        "webkitURL",
-        "webkitUnlockOrientation",
-        "webkitUserSelect",
-        "webkitVideoDecodedByteCount",
-        "webkitVisibilityState",
-        "webkitWirelessVideoPlaybackDisabled",
-        "webkitdropzone",
-        "webstore",
-        "weight",
-        "whatToShow",
-        "wheelDelta",
-        "wheelDeltaX",
-        "wheelDeltaY",
-        "which",
-        "white-space",
-        "whiteSpace",
-        "wholeText",
-        "widows",
-        "width",
-        "will-change",
-        "willChange",
-        "willValidate",
-        "window",
-        "withCredentials",
-        "word-break",
-        "word-spacing",
-        "word-wrap",
-        "wordBreak",
-        "wordSpacing",
-        "wordWrap",
-        "wrap",
-        "wrapKey",
-        "write",
-        "writeln",
-        "writingMode",
-        "x",
-        "x1",
-        "x2",
-        "xChannelSelector",
-        "xmlEncoding",
-        "xmlStandalone",
-        "xmlVersion",
-        "xmlbase",
-        "xmllang",
-        "xmlspace",
-        "y",
-        "y1",
-        "y2",
-        "yChannelSelector",
-        "yandex",
-        "z",
-        "z-index",
-        "zIndex",
-        "zoom",
-        "zoomAndPan",
-        "zoomRectScreen"
-    ]
-}
+[
+    "$&",
+    "$'",
+    "$*",
+    "$+",
+    "$1",
+    "$2",
+    "$3",
+    "$4",
+    "$5",
+    "$6",
+    "$7",
+    "$8",
+    "$9",
+    "$_",
+    "$`",
+    "$input",
+    "@@iterator",
+    "ABORT_ERR",
+    "ACTIVE",
+    "ACTIVE_ATTRIBUTES",
+    "ACTIVE_TEXTURE",
+    "ACTIVE_UNIFORMS",
+    "ADDITION",
+    "ALIASED_LINE_WIDTH_RANGE",
+    "ALIASED_POINT_SIZE_RANGE",
+    "ALLOW_KEYBOARD_INPUT",
+    "ALLPASS",
+    "ALPHA",
+    "ALPHA_BITS",
+    "ALT_MASK",
+    "ALWAYS",
+    "ANY_TYPE",
+    "ANY_UNORDERED_NODE_TYPE",
+    "ARRAY_BUFFER",
+    "ARRAY_BUFFER_BINDING",
+    "ATTACHED_SHADERS",
+    "ATTRIBUTE_NODE",
+    "AT_TARGET",
+    "AddSearchProvider",
+    "AnalyserNode",
+    "AnimationEvent",
+    "AnonXMLHttpRequest",
+    "ApplicationCache",
+    "ApplicationCacheErrorEvent",
+    "Array",
+    "ArrayBuffer",
+    "Attr",
+    "Audio",
+    "AudioBuffer",
+    "AudioBufferSourceNode",
+    "AudioContext",
+    "AudioDestinationNode",
+    "AudioListener",
+    "AudioNode",
+    "AudioParam",
+    "AudioProcessingEvent",
+    "AudioStreamTrack",
+    "AutocompleteErrorEvent",
+    "BACK",
+    "BAD_BOUNDARYPOINTS_ERR",
+    "BANDPASS",
+    "BLEND",
+    "BLEND_COLOR",
+    "BLEND_DST_ALPHA",
+    "BLEND_DST_RGB",
+    "BLEND_EQUATION",
+    "BLEND_EQUATION_ALPHA",
+    "BLEND_EQUATION_RGB",
+    "BLEND_SRC_ALPHA",
+    "BLEND_SRC_RGB",
+    "BLUE_BITS",
+    "BLUR",
+    "BOOL",
+    "BOOLEAN_TYPE",
+    "BOOL_VEC2",
+    "BOOL_VEC3",
+    "BOOL_VEC4",
+    "BOTH",
+    "BROWSER_DEFAULT_WEBGL",
+    "BUBBLING_PHASE",
+    "BUFFER_SIZE",
+    "BUFFER_USAGE",
+    "BYTE",
+    "BYTES_PER_ELEMENT",
+    "BarProp",
+    "BaseHref",
+    "BatteryManager",
+    "BeforeLoadEvent",
+    "BeforeUnloadEvent",
+    "BiquadFilterNode",
+    "Blob",
+    "BlobEvent",
+    "Boolean",
+    "CAPTURING_PHASE",
+    "CCW",
+    "CDATASection",
+    "CDATA_SECTION_NODE",
+    "CHANGE",
+    "CHARSET_RULE",
+    "CHECKING",
+    "CLAMP_TO_EDGE",
+    "CLICK",
+    "CLOSED",
+    "CLOSING",
+    "COLOR_ATTACHMENT0",
+    "COLOR_BUFFER_BIT",
+    "COLOR_CLEAR_VALUE",
+    "COLOR_WRITEMASK",
+    "COMMENT_NODE",
+    "COMPILE_STATUS",
+    "COMPRESSED_RGBA_S3TC_DXT1_EXT",
+    "COMPRESSED_RGBA_S3TC_DXT3_EXT",
+    "COMPRESSED_RGBA_S3TC_DXT5_EXT",
+    "COMPRESSED_RGB_S3TC_DXT1_EXT",
+    "COMPRESSED_TEXTURE_FORMATS",
+    "CONNECTING",
+    "CONSTANT_ALPHA",
+    "CONSTANT_COLOR",
+    "CONSTRAINT_ERR",
+    "CONTEXT_LOST_WEBGL",
+    "CONTROL_MASK",
+    "COUNTER_STYLE_RULE",
+    "CSS",
+    "CSS2Properties",
+    "CSSCharsetRule",
+    "CSSConditionRule",
+    "CSSCounterStyleRule",
+    "CSSFontFaceRule",
+    "CSSFontFeatureValuesRule",
+    "CSSGroupingRule",
+    "CSSImportRule",
+    "CSSKeyframeRule",
+    "CSSKeyframesRule",
+    "CSSMediaRule",
+    "CSSMozDocumentRule",
+    "CSSNameSpaceRule",
+    "CSSPageRule",
+    "CSSPrimitiveValue",
+    "CSSRule",
+    "CSSRuleList",
+    "CSSStyleDeclaration",
+    "CSSStyleRule",
+    "CSSStyleSheet",
+    "CSSSupportsRule",
+    "CSSUnknownRule",
+    "CSSValue",
+    "CSSValueList",
+    "CSSVariablesDeclaration",
+    "CSSVariablesRule",
+    "CSSViewportRule",
+    "CSS_ATTR",
+    "CSS_CM",
+    "CSS_COUNTER",
+    "CSS_CUSTOM",
+    "CSS_DEG",
+    "CSS_DIMENSION",
+    "CSS_EMS",
+    "CSS_EXS",
+    "CSS_FILTER_BLUR",
+    "CSS_FILTER_BRIGHTNESS",
+    "CSS_FILTER_CONTRAST",
+    "CSS_FILTER_CUSTOM",
+    "CSS_FILTER_DROP_SHADOW",
+    "CSS_FILTER_GRAYSCALE",
+    "CSS_FILTER_HUE_ROTATE",
+    "CSS_FILTER_INVERT",
+    "CSS_FILTER_OPACITY",
+    "CSS_FILTER_REFERENCE",
+    "CSS_FILTER_SATURATE",
+    "CSS_FILTER_SEPIA",
+    "CSS_GRAD",
+    "CSS_HZ",
+    "CSS_IDENT",
+    "CSS_IN",
+    "CSS_INHERIT",
+    "CSS_KHZ",
+    "CSS_MATRIX",
+    "CSS_MATRIX3D",
+    "CSS_MM",
+    "CSS_MS",
+    "CSS_NUMBER",
+    "CSS_PC",
+    "CSS_PERCENTAGE",
+    "CSS_PERSPECTIVE",
+    "CSS_PRIMITIVE_VALUE",
+    "CSS_PT",
+    "CSS_PX",
+    "CSS_RAD",
+    "CSS_RECT",
+    "CSS_RGBCOLOR",
+    "CSS_ROTATE",
+    "CSS_ROTATE3D",
+    "CSS_ROTATEX",
+    "CSS_ROTATEY",
+    "CSS_ROTATEZ",
+    "CSS_S",
+    "CSS_SCALE",
+    "CSS_SCALE3D",
+    "CSS_SCALEX",
+    "CSS_SCALEY",
+    "CSS_SCALEZ",
+    "CSS_SKEW",
+    "CSS_SKEWX",
+    "CSS_SKEWY",
+    "CSS_STRING",
+    "CSS_TRANSLATE",
+    "CSS_TRANSLATE3D",
+    "CSS_TRANSLATEX",
+    "CSS_TRANSLATEY",
+    "CSS_TRANSLATEZ",
+    "CSS_UNKNOWN",
+    "CSS_URI",
+    "CSS_VALUE_LIST",
+    "CSS_VH",
+    "CSS_VMAX",
+    "CSS_VMIN",
+    "CSS_VW",
+    "CULL_FACE",
+    "CULL_FACE_MODE",
+    "CURRENT_PROGRAM",
+    "CURRENT_VERTEX_ATTRIB",
+    "CUSTOM",
+    "CW",
+    "CanvasGradient",
+    "CanvasPattern",
+    "CanvasRenderingContext2D",
+    "CaretPosition",
+    "ChannelMergerNode",
+    "ChannelSplitterNode",
+    "CharacterData",
+    "ClientRect",
+    "ClientRectList",
+    "Clipboard",
+    "ClipboardEvent",
+    "CloseEvent",
+    "Collator",
+    "CommandEvent",
+    "Comment",
+    "CompositionEvent",
+    "Console",
+    "Controllers",
+    "ConvolverNode",
+    "Counter",
+    "Crypto",
+    "CryptoKey",
+    "CustomEvent",
+    "DATABASE_ERR",
+    "DATA_CLONE_ERR",
+    "DATA_ERR",
+    "DBLCLICK",
+    "DECR",
+    "DECR_WRAP",
+    "DELETE_STATUS",
+    "DEPTH_ATTACHMENT",
+    "DEPTH_BITS",
+    "DEPTH_BUFFER_BIT",
+    "DEPTH_CLEAR_VALUE",
+    "DEPTH_COMPONENT",
+    "DEPTH_COMPONENT16",
+    "DEPTH_FUNC",
+    "DEPTH_RANGE",
+    "DEPTH_STENCIL",
+    "DEPTH_STENCIL_ATTACHMENT",
+    "DEPTH_TEST",
+    "DEPTH_WRITEMASK",
+    "DIRECTION_DOWN",
+    "DIRECTION_LEFT",
+    "DIRECTION_RIGHT",
+    "DIRECTION_UP",
+    "DISABLED",
+    "DISPATCH_REQUEST_ERR",
+    "DITHER",
+    "DOCUMENT_FRAGMENT_NODE",
+    "DOCUMENT_NODE",
+    "DOCUMENT_POSITION_CONTAINED_BY",
+    "DOCUMENT_POSITION_CONTAINS",
+    "DOCUMENT_POSITION_DISCONNECTED",
+    "DOCUMENT_POSITION_FOLLOWING",
+    "DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC",
+    "DOCUMENT_POSITION_PRECEDING",
+    "DOCUMENT_TYPE_NODE",
+    "DOMCursor",
+    "DOMError",
+    "DOMException",
+    "DOMImplementation",
+    "DOMImplementationLS",
+    "DOMMatrix",
+    "DOMMatrixReadOnly",
+    "DOMParser",
+    "DOMPoint",
+    "DOMPointReadOnly",
+    "DOMQuad",
+    "DOMRect",
+    "DOMRectList",
+    "DOMRectReadOnly",
+    "DOMRequest",
+    "DOMSTRING_SIZE_ERR",
+    "DOMSettableTokenList",
+    "DOMStringList",
+    "DOMStringMap",
+    "DOMTokenList",
+    "DOMTransactionEvent",
+    "DOM_DELTA_LINE",
+    "DOM_DELTA_PAGE",
+    "DOM_DELTA_PIXEL",
+    "DOM_INPUT_METHOD_DROP",
+    "DOM_INPUT_METHOD_HANDWRITING",
+    "DOM_INPUT_METHOD_IME",
+    "DOM_INPUT_METHOD_KEYBOARD",
+    "DOM_INPUT_METHOD_MULTIMODAL",
+    "DOM_INPUT_METHOD_OPTION",
+    "DOM_INPUT_METHOD_PASTE",
+    "DOM_INPUT_METHOD_SCRIPT",
+    "DOM_INPUT_METHOD_UNKNOWN",
+    "DOM_INPUT_METHOD_VOICE",
+    "DOM_KEY_LOCATION_JOYSTICK",
+    "DOM_KEY_LOCATION_LEFT",
+    "DOM_KEY_LOCATION_MOBILE",
+    "DOM_KEY_LOCATION_NUMPAD",
+    "DOM_KEY_LOCATION_RIGHT",
+    "DOM_KEY_LOCATION_STANDARD",
+    "DOM_VK_0",
+    "DOM_VK_1",
+    "DOM_VK_2",
+    "DOM_VK_3",
+    "DOM_VK_4",
+    "DOM_VK_5",
+    "DOM_VK_6",
+    "DOM_VK_7",
+    "DOM_VK_8",
+    "DOM_VK_9",
+    "DOM_VK_A",
+    "DOM_VK_ACCEPT",
+    "DOM_VK_ADD",
+    "DOM_VK_ALT",
+    "DOM_VK_ALTGR",
+    "DOM_VK_AMPERSAND",
+    "DOM_VK_ASTERISK",
+    "DOM_VK_AT",
+    "DOM_VK_ATTN",
+    "DOM_VK_B",
+    "DOM_VK_BACKSPACE",
+    "DOM_VK_BACK_QUOTE",
+    "DOM_VK_BACK_SLASH",
+    "DOM_VK_BACK_SPACE",
+    "DOM_VK_C",
+    "DOM_VK_CANCEL",
+    "DOM_VK_CAPS_LOCK",
+    "DOM_VK_CIRCUMFLEX",
+    "DOM_VK_CLEAR",
+    "DOM_VK_CLOSE_BRACKET",
+    "DOM_VK_CLOSE_CURLY_BRACKET",
+    "DOM_VK_CLOSE_PAREN",
+    "DOM_VK_COLON",
+    "DOM_VK_COMMA",
+    "DOM_VK_CONTEXT_MENU",
+    "DOM_VK_CONTROL",
+    "DOM_VK_CONVERT",
+    "DOM_VK_CRSEL",
+    "DOM_VK_CTRL",
+    "DOM_VK_D",
+    "DOM_VK_DECIMAL",
+    "DOM_VK_DELETE",
+    "DOM_VK_DIVIDE",
+    "DOM_VK_DOLLAR",
+    "DOM_VK_DOUBLE_QUOTE",
+    "DOM_VK_DOWN",
+    "DOM_VK_E",
+    "DOM_VK_EISU",
+    "DOM_VK_END",
+    "DOM_VK_ENTER",
+    "DOM_VK_EQUALS",
+    "DOM_VK_EREOF",
+    "DOM_VK_ESCAPE",
+    "DOM_VK_EXCLAMATION",
+    "DOM_VK_EXECUTE",
+    "DOM_VK_EXSEL",
+    "DOM_VK_F",
+    "DOM_VK_F1",
+    "DOM_VK_F10",
+    "DOM_VK_F11",
+    "DOM_VK_F12",
+    "DOM_VK_F13",
+    "DOM_VK_F14",
+    "DOM_VK_F15",
+    "DOM_VK_F16",
+    "DOM_VK_F17",
+    "DOM_VK_F18",
+    "DOM_VK_F19",
+    "DOM_VK_F2",
+    "DOM_VK_F20",
+    "DOM_VK_F21",
+    "DOM_VK_F22",
+    "DOM_VK_F23",
+    "DOM_VK_F24",
+    "DOM_VK_F25",
+    "DOM_VK_F26",
+    "DOM_VK_F27",
+    "DOM_VK_F28",
+    "DOM_VK_F29",
+    "DOM_VK_F3",
+    "DOM_VK_F30",
+    "DOM_VK_F31",
+    "DOM_VK_F32",
+    "DOM_VK_F33",
+    "DOM_VK_F34",
+    "DOM_VK_F35",
+    "DOM_VK_F36",
+    "DOM_VK_F4",
+    "DOM_VK_F5",
+    "DOM_VK_F6",
+    "DOM_VK_F7",
+    "DOM_VK_F8",
+    "DOM_VK_F9",
+    "DOM_VK_FINAL",
+    "DOM_VK_FRONT",
+    "DOM_VK_G",
+    "DOM_VK_GREATER_THAN",
+    "DOM_VK_H",
+    "DOM_VK_HANGUL",
+    "DOM_VK_HANJA",
+    "DOM_VK_HASH",
+    "DOM_VK_HELP",
+    "DOM_VK_HK_TOGGLE",
+    "DOM_VK_HOME",
+    "DOM_VK_HYPHEN_MINUS",
+    "DOM_VK_I",
+    "DOM_VK_INSERT",
+    "DOM_VK_J",
+    "DOM_VK_JUNJA",
+    "DOM_VK_K",
+    "DOM_VK_KANA",
+    "DOM_VK_KANJI",
+    "DOM_VK_L",
+    "DOM_VK_LEFT",
+    "DOM_VK_LEFT_TAB",
+    "DOM_VK_LESS_THAN",
+    "DOM_VK_M",
+    "DOM_VK_META",
+    "DOM_VK_MODECHANGE",
+    "DOM_VK_MULTIPLY",
+    "DOM_VK_N",
+    "DOM_VK_NONCONVERT",
+    "DOM_VK_NUMPAD0",
+    "DOM_VK_NUMPAD1",
+    "DOM_VK_NUMPAD2",
+    "DOM_VK_NUMPAD3",
+    "DOM_VK_NUMPAD4",
+    "DOM_VK_NUMPAD5",
+    "DOM_VK_NUMPAD6",
+    "DOM_VK_NUMPAD7",
+    "DOM_VK_NUMPAD8",
+    "DOM_VK_NUMPAD9",
+    "DOM_VK_NUM_LOCK",
+    "DOM_VK_O",
+    "DOM_VK_OEM_1",
+    "DOM_VK_OEM_102",
+    "DOM_VK_OEM_2",
+    "DOM_VK_OEM_3",
+    "DOM_VK_OEM_4",
+    "DOM_VK_OEM_5",
+    "DOM_VK_OEM_6",
+    "DOM_VK_OEM_7",
+    "DOM_VK_OEM_8",
+    "DOM_VK_OEM_COMMA",
+    "DOM_VK_OEM_MINUS",
+    "DOM_VK_OEM_PERIOD",
+    "DOM_VK_OEM_PLUS",
+    "DOM_VK_OPEN_BRACKET",
+    "DOM_VK_OPEN_CURLY_BRACKET",
+    "DOM_VK_OPEN_PAREN",
+    "DOM_VK_P",
+    "DOM_VK_PA1",
+    "DOM_VK_PAGEDOWN",
+    "DOM_VK_PAGEUP",
+    "DOM_VK_PAGE_DOWN",
+    "DOM_VK_PAGE_UP",
+    "DOM_VK_PAUSE",
+    "DOM_VK_PERCENT",
+    "DOM_VK_PERIOD",
+    "DOM_VK_PIPE",
+    "DOM_VK_PLAY",
+    "DOM_VK_PLUS",
+    "DOM_VK_PRINT",
+    "DOM_VK_PRINTSCREEN",
+    "DOM_VK_PROCESSKEY",
+    "DOM_VK_PROPERITES",
+    "DOM_VK_Q",
+    "DOM_VK_QUESTION_MARK",
+    "DOM_VK_QUOTE",
+    "DOM_VK_R",
+    "DOM_VK_REDO",
+    "DOM_VK_RETURN",
+    "DOM_VK_RIGHT",
+    "DOM_VK_S",
+    "DOM_VK_SCROLL_LOCK",
+    "DOM_VK_SELECT",
+    "DOM_VK_SEMICOLON",
+    "DOM_VK_SEPARATOR",
+    "DOM_VK_SHIFT",
+    "DOM_VK_SLASH",
+    "DOM_VK_SLEEP",
+    "DOM_VK_SPACE",
+    "DOM_VK_SUBTRACT",
+    "DOM_VK_T",
+    "DOM_VK_TAB",
+    "DOM_VK_TILDE",
+    "DOM_VK_U",
+    "DOM_VK_UNDERSCORE",
+    "DOM_VK_UNDO",
+    "DOM_VK_UNICODE",
+    "DOM_VK_UP",
+    "DOM_VK_V",
+    "DOM_VK_VOLUME_DOWN",
+    "DOM_VK_VOLUME_MUTE",
+    "DOM_VK_VOLUME_UP",
+    "DOM_VK_W",
+    "DOM_VK_WIN",
+    "DOM_VK_WINDOW",
+    "DOM_VK_WIN_ICO_00",
+    "DOM_VK_WIN_ICO_CLEAR",
+    "DOM_VK_WIN_ICO_HELP",
+    "DOM_VK_WIN_OEM_ATTN",
+    "DOM_VK_WIN_OEM_AUTO",
+    "DOM_VK_WIN_OEM_BACKTAB",
+    "DOM_VK_WIN_OEM_CLEAR",
+    "DOM_VK_WIN_OEM_COPY",
+    "DOM_VK_WIN_OEM_CUSEL",
+    "DOM_VK_WIN_OEM_ENLW",
+    "DOM_VK_WIN_OEM_FINISH",
+    "DOM_VK_WIN_OEM_FJ_JISHO",
+    "DOM_VK_WIN_OEM_FJ_LOYA",
+    "DOM_VK_WIN_OEM_FJ_MASSHOU",
+    "DOM_VK_WIN_OEM_FJ_ROYA",
+    "DOM_VK_WIN_OEM_FJ_TOUROKU",
+    "DOM_VK_WIN_OEM_JUMP",
+    "DOM_VK_WIN_OEM_PA1",
+    "DOM_VK_WIN_OEM_PA2",
+    "DOM_VK_WIN_OEM_PA3",
+    "DOM_VK_WIN_OEM_RESET",
+    "DOM_VK_WIN_OEM_WSCTRL",
+    "DOM_VK_X",
+    "DOM_VK_XF86XK_ADD_FAVORITE",
+    "DOM_VK_XF86XK_APPLICATION_LEFT",
+    "DOM_VK_XF86XK_APPLICATION_RIGHT",
+    "DOM_VK_XF86XK_AUDIO_CYCLE_TRACK",
+    "DOM_VK_XF86XK_AUDIO_FORWARD",
+    "DOM_VK_XF86XK_AUDIO_LOWER_VOLUME",
+    "DOM_VK_XF86XK_AUDIO_MEDIA",
+    "DOM_VK_XF86XK_AUDIO_MUTE",
+    "DOM_VK_XF86XK_AUDIO_NEXT",
+    "DOM_VK_XF86XK_AUDIO_PAUSE",
+    "DOM_VK_XF86XK_AUDIO_PLAY",
+    "DOM_VK_XF86XK_AUDIO_PREV",
+    "DOM_VK_XF86XK_AUDIO_RAISE_VOLUME",
+    "DOM_VK_XF86XK_AUDIO_RANDOM_PLAY",
+    "DOM_VK_XF86XK_AUDIO_RECORD",
+    "DOM_VK_XF86XK_AUDIO_REPEAT",
+    "DOM_VK_XF86XK_AUDIO_REWIND",
+    "DOM_VK_XF86XK_AUDIO_STOP",
+    "DOM_VK_XF86XK_AWAY",
+    "DOM_VK_XF86XK_BACK",
+    "DOM_VK_XF86XK_BACK_FORWARD",
+    "DOM_VK_XF86XK_BATTERY",
+    "DOM_VK_XF86XK_BLUE",
+    "DOM_VK_XF86XK_BLUETOOTH",
+    "DOM_VK_XF86XK_BOOK",
+    "DOM_VK_XF86XK_BRIGHTNESS_ADJUST",
+    "DOM_VK_XF86XK_CALCULATOR",
+    "DOM_VK_XF86XK_CALENDAR",
+    "DOM_VK_XF86XK_CD",
+    "DOM_VK_XF86XK_CLOSE",
+    "DOM_VK_XF86XK_COMMUNITY",
+    "DOM_VK_XF86XK_CONTRAST_ADJUST",
+    "DOM_VK_XF86XK_COPY",
+    "DOM_VK_XF86XK_CUT",
+    "DOM_VK_XF86XK_CYCLE_ANGLE",
+    "DOM_VK_XF86XK_DISPLAY",
+    "DOM_VK_XF86XK_DOCUMENTS",
+    "DOM_VK_XF86XK_DOS",
+    "DOM_VK_XF86XK_EJECT",
+    "DOM_VK_XF86XK_EXCEL",
+    "DOM_VK_XF86XK_EXPLORER",
+    "DOM_VK_XF86XK_FAVORITES",
+    "DOM_VK_XF86XK_FINANCE",
+    "DOM_VK_XF86XK_FORWARD",
+    "DOM_VK_XF86XK_FRAME_BACK",
+    "DOM_VK_XF86XK_FRAME_FORWARD",
+    "DOM_VK_XF86XK_GAME",
+    "DOM_VK_XF86XK_GO",
+    "DOM_VK_XF86XK_GREEN",
+    "DOM_VK_XF86XK_HIBERNATE",
+    "DOM_VK_XF86XK_HISTORY",
+    "DOM_VK_XF86XK_HOME_PAGE",
+    "DOM_VK_XF86XK_HOT_LINKS",
+    "DOM_VK_XF86XK_I_TOUCH",
+    "DOM_VK_XF86XK_KBD_BRIGHTNESS_DOWN",
+    "DOM_VK_XF86XK_KBD_BRIGHTNESS_UP",
+    "DOM_VK_XF86XK_KBD_LIGHT_ON_OFF",
+    "DOM_VK_XF86XK_LAUNCH0",
+    "DOM_VK_XF86XK_LAUNCH1",
+    "DOM_VK_XF86XK_LAUNCH2",
+    "DOM_VK_XF86XK_LAUNCH3",
+    "DOM_VK_XF86XK_LAUNCH4",
+    "DOM_VK_XF86XK_LAUNCH5",
+    "DOM_VK_XF86XK_LAUNCH6",
+    "DOM_VK_XF86XK_LAUNCH7",
+    "DOM_VK_XF86XK_LAUNCH8",
+    "DOM_VK_XF86XK_LAUNCH9",
+    "DOM_VK_XF86XK_LAUNCH_A",
+    "DOM_VK_XF86XK_LAUNCH_B",
+    "DOM_VK_XF86XK_LAUNCH_C",
+    "DOM_VK_XF86XK_LAUNCH_D",
+    "DOM_VK_XF86XK_LAUNCH_E",
+    "DOM_VK_XF86XK_LAUNCH_F",
+    "DOM_VK_XF86XK_LIGHT_BULB",
+    "DOM_VK_XF86XK_LOG_OFF",
+    "DOM_VK_XF86XK_MAIL",
+    "DOM_VK_XF86XK_MAIL_FORWARD",
+    "DOM_VK_XF86XK_MARKET",
+    "DOM_VK_XF86XK_MEETING",
+    "DOM_VK_XF86XK_MEMO",
+    "DOM_VK_XF86XK_MENU_KB",
+    "DOM_VK_XF86XK_MENU_PB",
+    "DOM_VK_XF86XK_MESSENGER",
+    "DOM_VK_XF86XK_MON_BRIGHTNESS_DOWN",
+    "DOM_VK_XF86XK_MON_BRIGHTNESS_UP",
+    "DOM_VK_XF86XK_MUSIC",
+    "DOM_VK_XF86XK_MY_COMPUTER",
+    "DOM_VK_XF86XK_MY_SITES",
+    "DOM_VK_XF86XK_NEW",
+    "DOM_VK_XF86XK_NEWS",
+    "DOM_VK_XF86XK_OFFICE_HOME",
+    "DOM_VK_XF86XK_OPEN",
+    "DOM_VK_XF86XK_OPEN_URL",
+    "DOM_VK_XF86XK_OPTION",
+    "DOM_VK_XF86XK_PASTE",
+    "DOM_VK_XF86XK_PHONE",
+    "DOM_VK_XF86XK_PICTURES",
+    "DOM_VK_XF86XK_POWER_DOWN",
+    "DOM_VK_XF86XK_POWER_OFF",
+    "DOM_VK_XF86XK_RED",
+    "DOM_VK_XF86XK_REFRESH",
+    "DOM_VK_XF86XK_RELOAD",
+    "DOM_VK_XF86XK_REPLY",
+    "DOM_VK_XF86XK_ROCKER_DOWN",
+    "DOM_VK_XF86XK_ROCKER_ENTER",
+    "DOM_VK_XF86XK_ROCKER_UP",
+    "DOM_VK_XF86XK_ROTATE_WINDOWS",
+    "DOM_VK_XF86XK_ROTATION_KB",
+    "DOM_VK_XF86XK_ROTATION_PB",
+    "DOM_VK_XF86XK_SAVE",
+    "DOM_VK_XF86XK_SCREEN_SAVER",
+    "DOM_VK_XF86XK_SCROLL_CLICK",
+    "DOM_VK_XF86XK_SCROLL_DOWN",
+    "DOM_VK_XF86XK_SCROLL_UP",
+    "DOM_VK_XF86XK_SEARCH",
+    "DOM_VK_XF86XK_SEND",
+    "DOM_VK_XF86XK_SHOP",
+    "DOM_VK_XF86XK_SPELL",
+    "DOM_VK_XF86XK_SPLIT_SCREEN",
+    "DOM_VK_XF86XK_STANDBY",
+    "DOM_VK_XF86XK_START",
+    "DOM_VK_XF86XK_STOP",
+    "DOM_VK_XF86XK_SUBTITLE",
+    "DOM_VK_XF86XK_SUPPORT",
+    "DOM_VK_XF86XK_SUSPEND",
+    "DOM_VK_XF86XK_TASK_PANE",
+    "DOM_VK_XF86XK_TERMINAL",
+    "DOM_VK_XF86XK_TIME",
+    "DOM_VK_XF86XK_TOOLS",
+    "DOM_VK_XF86XK_TOP_MENU",
+    "DOM_VK_XF86XK_TO_DO_LIST",
+    "DOM_VK_XF86XK_TRAVEL",
+    "DOM_VK_XF86XK_USER1KB",
+    "DOM_VK_XF86XK_USER2KB",
+    "DOM_VK_XF86XK_USER_PB",
+    "DOM_VK_XF86XK_UWB",
+    "DOM_VK_XF86XK_VENDOR_HOME",
+    "DOM_VK_XF86XK_VIDEO",
+    "DOM_VK_XF86XK_VIEW",
+    "DOM_VK_XF86XK_WAKE_UP",
+    "DOM_VK_XF86XK_WEB_CAM",
+    "DOM_VK_XF86XK_WHEEL_BUTTON",
+    "DOM_VK_XF86XK_WLAN",
+    "DOM_VK_XF86XK_WORD",
+    "DOM_VK_XF86XK_WWW",
+    "DOM_VK_XF86XK_XFER",
+    "DOM_VK_XF86XK_YELLOW",
+    "DOM_VK_XF86XK_ZOOM_IN",
+    "DOM_VK_XF86XK_ZOOM_OUT",
+    "DOM_VK_Y",
+    "DOM_VK_Z",
+    "DOM_VK_ZOOM",
+    "DONE",
+    "DONT_CARE",
+    "DOWNLOADING",
+    "DRAGDROP",
+    "DST_ALPHA",
+    "DST_COLOR",
+    "DYNAMIC_DRAW",
+    "DataChannel",
+    "DataTransfer",
+    "DataTransferItem",
+    "DataTransferItemList",
+    "DataView",
+    "Date",
+    "DateTimeFormat",
+    "DelayNode",
+    "DesktopNotification",
+    "DesktopNotificationCenter",
+    "DeviceLightEvent",
+    "DeviceMotionEvent",
+    "DeviceOrientationEvent",
+    "DeviceProximityEvent",
+    "DeviceStorage",
+    "DeviceStorageChangeEvent",
+    "Document",
+    "DocumentFragment",
+    "DocumentType",
+    "DragEvent",
+    "DynamicsCompressorNode",
+    "E",
+    "ELEMENT_ARRAY_BUFFER",
+    "ELEMENT_ARRAY_BUFFER_BINDING",
+    "ELEMENT_NODE",
+    "EMPTY",
+    "ENCODING_ERR",
+    "ENDED",
+    "END_TO_END",
+    "END_TO_START",
+    "ENTITY_NODE",
+    "ENTITY_REFERENCE_NODE",
+    "EPSILON",
+    "EQUAL",
+    "EQUALPOWER",
+    "ERROR",
+    "EXPONENTIAL_DISTANCE",
+    "Element",
+    "ElementQuery",
+    "Entity",
+    "EntityReference",
+    "Error",
+    "ErrorEvent",
+    "EvalError",
+    "Event",
+    "EventException",
+    "EventSource",
+    "EventTarget",
+    "External",
+    "FASTEST",
+    "FIDOSDK",
+    "FILTER_ACCEPT",
+    "FILTER_INTERRUPT",
+    "FILTER_REJECT",
+    "FILTER_SKIP",
+    "FINISHED_STATE",
+    "FIRST_ORDERED_NODE_TYPE",
+    "FLOAT",
+    "FLOAT_MAT2",
+    "FLOAT_MAT3",
+    "FLOAT_MAT4",
+    "FLOAT_VEC2",
+    "FLOAT_VEC3",
+    "FLOAT_VEC4",
+    "FOCUS",
+    "FONT_FACE_RULE",
+    "FONT_FEATURE_VALUES_RULE",
+    "FRAGMENT_SHADER",
+    "FRAGMENT_SHADER_DERIVATIVE_HINT_OES",
+    "FRAMEBUFFER",
+    "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",
+    "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",
+    "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",
+    "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",
+    "FRAMEBUFFER_BINDING",
+    "FRAMEBUFFER_COMPLETE",
+    "FRAMEBUFFER_INCOMPLETE_ATTACHMENT",
+    "FRAMEBUFFER_INCOMPLETE_DIMENSIONS",
+    "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",
+    "FRAMEBUFFER_UNSUPPORTED",
+    "FRONT",
+    "FRONT_AND_BACK",
+    "FRONT_FACE",
+    "FUNC_ADD",
+    "FUNC_REVERSE_SUBTRACT",
+    "FUNC_SUBTRACT",
+    "Feed",
+    "FeedEntry",
+    "File",
+    "FileError",
+    "FileList",
+    "FileReader",
+    "FindInPage",
+    "Float32Array",
+    "Float64Array",
+    "FocusEvent",
+    "FontFace",
+    "FormData",
+    "Function",
+    "GENERATE_MIPMAP_HINT",
+    "GEQUAL",
+    "GREATER",
+    "GREEN_BITS",
+    "GainNode",
+    "Gamepad",
+    "GamepadButton",
+    "GamepadEvent",
+    "GestureEvent",
+    "HAVE_CURRENT_DATA",
+    "HAVE_ENOUGH_DATA",
+    "HAVE_FUTURE_DATA",
+    "HAVE_METADATA",
+    "HAVE_NOTHING",
+    "HEADERS_RECEIVED",
+    "HIDDEN",
+    "HIERARCHY_REQUEST_ERR",
+    "HIGHPASS",
+    "HIGHSHELF",
+    "HIGH_FLOAT",
+    "HIGH_INT",
+    "HORIZONTAL",
+    "HORIZONTAL_AXIS",
+    "HRTF",
+    "HTMLAllCollection",
+    "HTMLAnchorElement",
+    "HTMLAppletElement",
+    "HTMLAreaElement",
+    "HTMLAudioElement",
+    "HTMLBRElement",
+    "HTMLBaseElement",
+    "HTMLBaseFontElement",
+    "HTMLBlockquoteElement",
+    "HTMLBodyElement",
+    "HTMLButtonElement",
+    "HTMLCanvasElement",
+    "HTMLCollection",
+    "HTMLCommandElement",
+    "HTMLContentElement",
+    "HTMLDListElement",
+    "HTMLDataElement",
+    "HTMLDataListElement",
+    "HTMLDetailsElement",
+    "HTMLDialogElement",
+    "HTMLDirectoryElement",
+    "HTMLDivElement",
+    "HTMLDocument",
+    "HTMLElement",
+    "HTMLEmbedElement",
+    "HTMLFieldSetElement",
+    "HTMLFontElement",
+    "HTMLFormControlsCollection",
+    "HTMLFormElement",
+    "HTMLFrameElement",
+    "HTMLFrameSetElement",
+    "HTMLHRElement",
+    "HTMLHeadElement",
+    "HTMLHeadingElement",
+    "HTMLHtmlElement",
+    "HTMLIFrameElement",
+    "HTMLImageElement",
+    "HTMLInputElement",
+    "HTMLIsIndexElement",
+    "HTMLKeygenElement",
+    "HTMLLIElement",
+    "HTMLLabelElement",
+    "HTMLLegendElement",
+    "HTMLLinkElement",
+    "HTMLMapElement",
+    "HTMLMarqueeElement",
+    "HTMLMediaElement",
+    "HTMLMenuElement",
+    "HTMLMenuItemElement",
+    "HTMLMetaElement",
+    "HTMLMeterElement",
+    "HTMLModElement",
+    "HTMLOListElement",
+    "HTMLObjectElement",
+    "HTMLOptGroupElement",
+    "HTMLOptionElement",
+    "HTMLOptionsCollection",
+    "HTMLOutputElement",
+    "HTMLParagraphElement",
+    "HTMLParamElement",
+    "HTMLPictureElement",
+    "HTMLPreElement",
+    "HTMLProgressElement",
+    "HTMLPropertiesCollection",
+    "HTMLQuoteElement",
+    "HTMLScriptElement",
+    "HTMLSelectElement",
+    "HTMLShadowElement",
+    "HTMLSourceElement",
+    "HTMLSpanElement",
+    "HTMLStyleElement",
+    "HTMLTableCaptionElement",
+    "HTMLTableCellElement",
+    "HTMLTableColElement",
+    "HTMLTableElement",
+    "HTMLTableRowElement",
+    "HTMLTableSectionElement",
+    "HTMLTemplateElement",
+    "HTMLTextAreaElement",
+    "HTMLTimeElement",
+    "HTMLTitleElement",
+    "HTMLTrackElement",
+    "HTMLUListElement",
+    "HTMLUnknownElement",
+    "HTMLVideoElement",
+    "HashChangeEvent",
+    "Headers",
+    "History",
+    "ICE_CHECKING",
+    "ICE_CLOSED",
+    "ICE_COMPLETED",
+    "ICE_CONNECTED",
+    "ICE_FAILED",
+    "ICE_GATHERING",
+    "ICE_WAITING",
+    "IDBCursor",
+    "IDBCursorWithValue",
+    "IDBDatabase",
+    "IDBDatabaseException",
+    "IDBFactory",
+    "IDBFileHandle",
+    "IDBFileRequest",
+    "IDBIndex",
+    "IDBKeyRange",
+    "IDBMutableFile",
+    "IDBObjectStore",
+    "IDBOpenDBRequest",
+    "IDBRequest",
+    "IDBTransaction",
+    "IDBVersionChangeEvent",
+    "IDLE",
+    "IMPLEMENTATION_COLOR_READ_FORMAT",
+    "IMPLEMENTATION_COLOR_READ_TYPE",
+    "IMPORT_RULE",
+    "INCR",
+    "INCR_WRAP",
+    "INDEX_SIZE_ERR",
+    "INT",
+    "INT_VEC2",
+    "INT_VEC3",
+    "INT_VEC4",
+    "INUSE_ATTRIBUTE_ERR",
+    "INVALID_ACCESS_ERR",
+    "INVALID_CHARACTER_ERR",
+    "INVALID_ENUM",
+    "INVALID_EXPRESSION_ERR",
+    "INVALID_FRAMEBUFFER_OPERATION",
+    "INVALID_MODIFICATION_ERR",
+    "INVALID_NODE_TYPE_ERR",
+    "INVALID_OPERATION",
+    "INVALID_STATE_ERR",
+    "INVALID_VALUE",
+    "INVERSE_DISTANCE",
+    "INVERT",
+    "IceCandidate",
+    "Image",
+    "ImageBitmap",
+    "ImageData",
+    "Infinity",
+    "InputEvent",
+    "InputMethodContext",
+    "InstallTrigger",
+    "Int16Array",
+    "Int32Array",
+    "Int8Array",
+    "Intent",
+    "InternalError",
+    "Intl",
+    "IsSearchProviderInstalled",
+    "Iterator",
+    "JSON",
+    "KEEP",
+    "KEYDOWN",
+    "KEYFRAMES_RULE",
+    "KEYFRAME_RULE",
+    "KEYPRESS",
+    "KEYUP",
+    "KeyEvent",
+    "KeyboardEvent",
+    "LENGTHADJUST_SPACING",
+    "LENGTHADJUST_SPACINGANDGLYPHS",
+    "LENGTHADJUST_UNKNOWN",
+    "LEQUAL",
+    "LESS",
+    "LINEAR",
+    "LINEAR_DISTANCE",
+    "LINEAR_MIPMAP_LINEAR",
+    "LINEAR_MIPMAP_NEAREST",
+    "LINES",
+    "LINE_LOOP",
+    "LINE_STRIP",
+    "LINE_WIDTH",
+    "LINK_STATUS",
+    "LIVE",
+    "LN10",
+    "LN2",
+    "LOADED",
+    "LOADING",
+    "LOG10E",
+    "LOG2E",
+    "LOWPASS",
+    "LOWSHELF",
+    "LOW_FLOAT",
+    "LOW_INT",
+    "LSException",
+    "LSParserFilter",
+    "LUMINANCE",
+    "LUMINANCE_ALPHA",
+    "LocalMediaStream",
+    "Location",
+    "MAX_COMBINED_TEXTURE_IMAGE_UNITS",
+    "MAX_CUBE_MAP_TEXTURE_SIZE",
+    "MAX_FRAGMENT_UNIFORM_VECTORS",
+    "MAX_RENDERBUFFER_SIZE",
+    "MAX_SAFE_INTEGER",
+    "MAX_TEXTURE_IMAGE_UNITS",
+    "MAX_TEXTURE_MAX_ANISOTROPY_EXT",
+    "MAX_TEXTURE_SIZE",
+    "MAX_VALUE",
+    "MAX_VARYING_VECTORS",
+    "MAX_VERTEX_ATTRIBS",
+    "MAX_VERTEX_TEXTURE_IMAGE_UNITS",
+    "MAX_VERTEX_UNIFORM_VECTORS",
+    "MAX_VIEWPORT_DIMS",
+    "MEDIA_ERR_ABORTED",
+    "MEDIA_ERR_DECODE",
+    "MEDIA_ERR_ENCRYPTED",
+    "MEDIA_ERR_NETWORK",
+    "MEDIA_ERR_SRC_NOT_SUPPORTED",
+    "MEDIA_KEYERR_CLIENT",
+    "MEDIA_KEYERR_DOMAIN",
+    "MEDIA_KEYERR_HARDWARECHANGE",
+    "MEDIA_KEYERR_OUTPUT",
+    "MEDIA_KEYERR_SERVICE",
+    "MEDIA_KEYERR_UNKNOWN",
+    "MEDIA_RULE",
+    "MEDIUM_FLOAT",
+    "MEDIUM_INT",
+    "META_MASK",
+    "MIN_SAFE_INTEGER",
+    "MIN_VALUE",
+    "MIRRORED_REPEAT",
+    "MODE_ASYNCHRONOUS",
+    "MODE_SYNCHRONOUS",
+    "MODIFICATION",
+    "MOUSEDOWN",
+    "MOUSEDRAG",
+    "MOUSEMOVE",
+    "MOUSEOUT",
+    "MOUSEOVER",
+    "MOUSEUP",
+    "MOZ_KEYFRAMES_RULE",
+    "MOZ_KEYFRAME_RULE",
+    "MOZ_SOURCE_CURSOR",
+    "MOZ_SOURCE_ERASER",
+    "MOZ_SOURCE_KEYBOARD",
+    "MOZ_SOURCE_MOUSE",
+    "MOZ_SOURCE_PEN",
+    "MOZ_SOURCE_TOUCH",
+    "MOZ_SOURCE_UNKNOWN",
+    "MSGESTURE_FLAG_BEGIN",
+    "MSGESTURE_FLAG_CANCEL",
+    "MSGESTURE_FLAG_END",
+    "MSGESTURE_FLAG_INERTIA",
+    "MSGESTURE_FLAG_NONE",
+    "MSPOINTER_TYPE_MOUSE",
+    "MSPOINTER_TYPE_PEN",
+    "MSPOINTER_TYPE_TOUCH",
+    "MS_ASYNC_CALLBACK_STATUS_ASSIGN_DELEGATE",
+    "MS_ASYNC_CALLBACK_STATUS_CANCEL",
+    "MS_ASYNC_CALLBACK_STATUS_CHOOSEANY",
+    "MS_ASYNC_CALLBACK_STATUS_ERROR",
+    "MS_ASYNC_CALLBACK_STATUS_JOIN",
+    "MS_ASYNC_OP_STATUS_CANCELED",
+    "MS_ASYNC_OP_STATUS_ERROR",
+    "MS_ASYNC_OP_STATUS_SUCCESS",
+    "MS_MANIPULATION_STATE_ACTIVE",
+    "MS_MANIPULATION_STATE_CANCELLED",
+    "MS_MANIPULATION_STATE_COMMITTED",
+    "MS_MANIPULATION_STATE_DRAGGING",
+    "MS_MANIPULATION_STATE_INERTIA",
+    "MS_MANIPULATION_STATE_PRESELECT",
+    "MS_MANIPULATION_STATE_SELECTING",
+    "MS_MANIPULATION_STATE_STOPPED",
+    "MS_MEDIA_ERR_ENCRYPTED",
+    "MS_MEDIA_KEYERR_CLIENT",
+    "MS_MEDIA_KEYERR_DOMAIN",
+    "MS_MEDIA_KEYERR_HARDWARECHANGE",
+    "MS_MEDIA_KEYERR_OUTPUT",
+    "MS_MEDIA_KEYERR_SERVICE",
+    "MS_MEDIA_KEYERR_UNKNOWN",
+    "Map",
+    "Math",
+    "MediaController",
+    "MediaDevices",
+    "MediaElementAudioSourceNode",
+    "MediaEncryptedEvent",
+    "MediaError",
+    "MediaKeyError",
+    "MediaKeyEvent",
+    "MediaKeyMessageEvent",
+    "MediaKeyNeededEvent",
+    "MediaKeySession",
+    "MediaKeyStatusMap",
+    "MediaKeySystemAccess",
+    "MediaKeys",
+    "MediaList",
+    "MediaQueryList",
+    "MediaQueryListEvent",
+    "MediaRecorder",
+    "MediaSource",
+    "MediaStream",
+    "MediaStreamAudioDestinationNode",
+    "MediaStreamAudioSourceNode",
+    "MediaStreamEvent",
+    "MediaStreamTrack",
+    "MediaStreamTrackEvent",
+    "MessageChannel",
+    "MessageEvent",
+    "MessagePort",
+    "Methods",
+    "MimeType",
+    "MimeTypeArray",
+    "MouseEvent",
+    "MouseScrollEvent",
+    "MozAnimation",
+    "MozAnimationDelay",
+    "MozAnimationDirection",
+    "MozAnimationDuration",
+    "MozAnimationFillMode",
+    "MozAnimationIterationCount",
+    "MozAnimationName",
+    "MozAnimationPlayState",
+    "MozAnimationTimingFunction",
+    "MozAppearance",
+    "MozBackfaceVisibility",
+    "MozBinding",
+    "MozBorderBottomColors",
+    "MozBorderEnd",
+    "MozBorderEndColor",
+    "MozBorderEndStyle",
+    "MozBorderEndWidth",
+    "MozBorderImage",
+    "MozBorderLeftColors",
+    "MozBorderRightColors",
+    "MozBorderStart",
+    "MozBorderStartColor",
+    "MozBorderStartStyle",
+    "MozBorderStartWidth",
+    "MozBorderTopColors",
+    "MozBoxAlign",
+    "MozBoxDirection",
+    "MozBoxFlex",
+    "MozBoxOrdinalGroup",
+    "MozBoxOrient",
+    "MozBoxPack",
+    "MozBoxSizing",
+    "MozCSSKeyframeRule",
+    "MozCSSKeyframesRule",
+    "MozColumnCount",
+    "MozColumnFill",
+    "MozColumnGap",
+    "MozColumnRule",
+    "MozColumnRuleColor",
+    "MozColumnRuleStyle",
+    "MozColumnRuleWidth",
+    "MozColumnWidth",
+    "MozColumns",
+    "MozContactChangeEvent",
+    "MozFloatEdge",
+    "MozFontFeatureSettings",
+    "MozFontLanguageOverride",
+    "MozForceBrokenImageIcon",
+    "MozHyphens",
+    "MozImageRegion",
+    "MozMarginEnd",
+    "MozMarginStart",
+    "MozMmsEvent",
+    "MozMmsMessage",
+    "MozMobileMessageThread",
+    "MozOSXFontSmoothing",
+    "MozOrient",
+    "MozOutlineRadius",
+    "MozOutlineRadiusBottomleft",
+    "MozOutlineRadiusBottomright",
+    "MozOutlineRadiusTopleft",
+    "MozOutlineRadiusTopright",
+    "MozPaddingEnd",
+    "MozPaddingStart",
+    "MozPerspective",
+    "MozPerspectiveOrigin",
+    "MozPowerManager",
+    "MozSettingsEvent",
+    "MozSmsEvent",
+    "MozSmsMessage",
+    "MozStackSizing",
+    "MozTabSize",
+    "MozTextAlignLast",
+    "MozTextDecorationColor",
+    "MozTextDecorationLine",
+    "MozTextDecorationStyle",
+    "MozTextSizeAdjust",
+    "MozTransform",
+    "MozTransformOrigin",
+    "MozTransformStyle",
+    "MozTransition",
+    "MozTransitionDelay",
+    "MozTransitionDuration",
+    "MozTransitionProperty",
+    "MozTransitionTimingFunction",
+    "MozUserFocus",
+    "MozUserInput",
+    "MozUserModify",
+    "MozUserSelect",
+    "MozWindowDragging",
+    "MozWindowShadow",
+    "MutationEvent",
+    "MutationObserver",
+    "MutationRecord",
+    "NAMESPACE_ERR",
+    "NAMESPACE_RULE",
+    "NEAREST",
+    "NEAREST_MIPMAP_LINEAR",
+    "NEAREST_MIPMAP_NEAREST",
+    "NEGATIVE_INFINITY",
+    "NETWORK_EMPTY",
+    "NETWORK_ERR",
+    "NETWORK_IDLE",
+    "NETWORK_LOADED",
+    "NETWORK_LOADING",
+    "NETWORK_NO_SOURCE",
+    "NEVER",
+    "NEW",
+    "NEXT",
+    "NEXT_NO_DUPLICATE",
+    "NICEST",
+    "NODE_AFTER",
+    "NODE_BEFORE",
+    "NODE_BEFORE_AND_AFTER",
+    "NODE_INSIDE",
+    "NONE",
+    "NON_TRANSIENT_ERR",
+    "NOTATION_NODE",
+    "NOTCH",
+    "NOTEQUAL",
+    "NOT_ALLOWED_ERR",
+    "NOT_FOUND_ERR",
+    "NOT_READABLE_ERR",
+    "NOT_SUPPORTED_ERR",
+    "NO_DATA_ALLOWED_ERR",
+    "NO_ERR",
+    "NO_ERROR",
+    "NO_MODIFICATION_ALLOWED_ERR",
+    "NUMBER_TYPE",
+    "NUM_COMPRESSED_TEXTURE_FORMATS",
+    "NaN",
+    "NamedNodeMap",
+    "Navigator",
+    "NearbyLinks",
+    "NetworkInformation",
+    "Node",
+    "NodeFilter",
+    "NodeIterator",
+    "NodeList",
+    "Notation",
+    "Notification",
+    "NotifyPaintEvent",
+    "Number",
+    "NumberFormat",
+    "OBSOLETE",
+    "ONE",
+    "ONE_MINUS_CONSTANT_ALPHA",
+    "ONE_MINUS_CONSTANT_COLOR",
+    "ONE_MINUS_DST_ALPHA",
+    "ONE_MINUS_DST_COLOR",
+    "ONE_MINUS_SRC_ALPHA",
+    "ONE_MINUS_SRC_COLOR",
+    "OPEN",
+    "OPENED",
+    "OPENING",
+    "ORDERED_NODE_ITERATOR_TYPE",
+    "ORDERED_NODE_SNAPSHOT_TYPE",
+    "OUT_OF_MEMORY",
+    "Object",
+    "OfflineAudioCompletionEvent",
+    "OfflineAudioContext",
+    "OfflineResourceList",
+    "Option",
+    "OscillatorNode",
+    "OverflowEvent",
+    "PACK_ALIGNMENT",
+    "PAGE_RULE",
+    "PARSE_ERR",
+    "PATHSEG_ARC_ABS",
+    "PATHSEG_ARC_REL",
+    "PATHSEG_CLOSEPATH",
+    "PATHSEG_CURVETO_CUBIC_ABS",
+    "PATHSEG_CURVETO_CUBIC_REL",
+    "PATHSEG_CURVETO_CUBIC_SMOOTH_ABS",
+    "PATHSEG_CURVETO_CUBIC_SMOOTH_REL",
+    "PATHSEG_CURVETO_QUADRATIC_ABS",
+    "PATHSEG_CURVETO_QUADRATIC_REL",
+    "PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS",
+    "PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL",
+    "PATHSEG_LINETO_ABS",
+    "PATHSEG_LINETO_HORIZONTAL_ABS",
+    "PATHSEG_LINETO_HORIZONTAL_REL",
+    "PATHSEG_LINETO_REL",
+    "PATHSEG_LINETO_VERTICAL_ABS",
+    "PATHSEG_LINETO_VERTICAL_REL",
+    "PATHSEG_MOVETO_ABS",
+    "PATHSEG_MOVETO_REL",
+    "PATHSEG_UNKNOWN",
+    "PATH_EXISTS_ERR",
+    "PEAKING",
+    "PERMISSION_DENIED",
+    "PERSISTENT",
+    "PI",
+    "PLAYING_STATE",
+    "POINTS",
+    "POLYGON_OFFSET_FACTOR",
+    "POLYGON_OFFSET_FILL",
+    "POLYGON_OFFSET_UNITS",
+    "POSITION_UNAVAILABLE",
+    "POSITIVE_INFINITY",
+    "PREV",
+    "PREV_NO_DUPLICATE",
+    "PROCESSING_INSTRUCTION_NODE",
+    "PageChangeEvent",
+    "PageTransitionEvent",
+    "PaintRequest",
+    "PaintRequestList",
+    "PannerNode",
+    "Path2D",
+    "Performance",
+    "PerformanceEntry",
+    "PerformanceMark",
+    "PerformanceMeasure",
+    "PerformanceNavigation",
+    "PerformanceResourceTiming",
+    "PerformanceTiming",
+    "PeriodicWave",
+    "Plugin",
+    "PluginArray",
+    "PopStateEvent",
+    "PopupBlockedEvent",
+    "ProcessingInstruction",
+    "ProgressEvent",
+    "Promise",
+    "PropertyNodeList",
+    "Proxy",
+    "PushManager",
+    "PushSubscription",
+    "Q",
+    "QUOTA_ERR",
+    "QUOTA_EXCEEDED_ERR",
+    "QueryInterface",
+    "READ_ONLY",
+    "READ_ONLY_ERR",
+    "READ_WRITE",
+    "RED_BITS",
+    "REMOVAL",
+    "RENDERBUFFER",
+    "RENDERBUFFER_ALPHA_SIZE",
+    "RENDERBUFFER_BINDING",
+    "RENDERBUFFER_BLUE_SIZE",
+    "RENDERBUFFER_DEPTH_SIZE",
+    "RENDERBUFFER_GREEN_SIZE",
+    "RENDERBUFFER_HEIGHT",
+    "RENDERBUFFER_INTERNAL_FORMAT",
+    "RENDERBUFFER_RED_SIZE",
+    "RENDERBUFFER_STENCIL_SIZE",
+    "RENDERBUFFER_WIDTH",
+    "RENDERER",
+    "RENDERING_INTENT_ABSOLUTE_COLORIMETRIC",
+    "RENDERING_INTENT_AUTO",
+    "RENDERING_INTENT_PERCEPTUAL",
+    "RENDERING_INTENT_RELATIVE_COLORIMETRIC",
+    "RENDERING_INTENT_SATURATION",
+    "RENDERING_INTENT_UNKNOWN",
+    "REPEAT",
+    "REPLACE",
+    "RGB",
+    "RGB565",
+    "RGB5_A1",
+    "RGBA",
+    "RGBA4",
+    "RGBColor",
+    "ROTATION_CLOCKWISE",
+    "ROTATION_COUNTERCLOCKWISE",
+    "RTCDataChannelEvent",
+    "RTCIceCandidate",
+    "RTCPeerConnectionIceEvent",
+    "RTCRtpReceiver",
+    "RTCRtpSender",
+    "RTCSessionDescription",
+    "RTCStatsReport",
+    "RadioNodeList",
+    "Range",
+    "RangeError",
+    "RangeException",
+    "RecordErrorEvent",
+    "Rect",
+    "ReferenceError",
+    "RegExp",
+    "Request",
+    "Response",
+    "SAMPLER_2D",
+    "SAMPLER_CUBE",
+    "SAMPLES",
+    "SAMPLE_ALPHA_TO_COVERAGE",
+    "SAMPLE_BUFFERS",
+    "SAMPLE_COVERAGE",
+    "SAMPLE_COVERAGE_INVERT",
+    "SAMPLE_COVERAGE_VALUE",
+    "SAWTOOTH",
+    "SCHEDULED_STATE",
+    "SCISSOR_BOX",
+    "SCISSOR_TEST",
+    "SCROLL_PAGE_DOWN",
+    "SCROLL_PAGE_UP",
+    "SDP_ANSWER",
+    "SDP_OFFER",
+    "SDP_PRANSWER",
+    "SECURITY_ERR",
+    "SELECT",
+    "SERIALIZE_ERR",
+    "SEVERITY_ERROR",
+    "SEVERITY_FATAL_ERROR",
+    "SEVERITY_WARNING",
+    "SHADER_COMPILER",
+    "SHADER_TYPE",
+    "SHADING_LANGUAGE_VERSION",
+    "SHIFT_MASK",
+    "SHORT",
+    "SHOWING",
+    "SHOW_ALL",
+    "SHOW_ATTRIBUTE",
+    "SHOW_CDATA_SECTION",
+    "SHOW_COMMENT",
+    "SHOW_DOCUMENT",
+    "SHOW_DOCUMENT_FRAGMENT",
+    "SHOW_DOCUMENT_TYPE",
+    "SHOW_ELEMENT",
+    "SHOW_ENTITY",
+    "SHOW_ENTITY_REFERENCE",
+    "SHOW_NOTATION",
+    "SHOW_PROCESSING_INSTRUCTION",
+    "SHOW_TEXT",
+    "SINE",
+    "SOUNDFIELD",
+    "SQLException",
+    "SQRT1_2",
+    "SQRT2",
+    "SQUARE",
+    "SRC_ALPHA",
+    "SRC_ALPHA_SATURATE",
+    "SRC_COLOR",
+    "START_TO_END",
+    "START_TO_START",
+    "STATIC_DRAW",
+    "STENCIL_ATTACHMENT",
+    "STENCIL_BACK_FAIL",
+    "STENCIL_BACK_FUNC",
+    "STENCIL_BACK_PASS_DEPTH_FAIL",
+    "STENCIL_BACK_PASS_DEPTH_PASS",
+    "STENCIL_BACK_REF",
+    "STENCIL_BACK_VALUE_MASK",
+    "STENCIL_BACK_WRITEMASK",
+    "STENCIL_BITS",
+    "STENCIL_BUFFER_BIT",
+    "STENCIL_CLEAR_VALUE",
+    "STENCIL_FAIL",
+    "STENCIL_FUNC",
+    "STENCIL_INDEX",
+    "STENCIL_INDEX8",
+    "STENCIL_PASS_DEPTH_FAIL",
+    "STENCIL_PASS_DEPTH_PASS",
+    "STENCIL_REF",
+    "STENCIL_TEST",
+    "STENCIL_VALUE_MASK",
+    "STENCIL_WRITEMASK",
+    "STREAM_DRAW",
+    "STRING_TYPE",
+    "STYLE_RULE",
+    "SUBPIXEL_BITS",
+    "SUPPORTS_RULE",
+    "SVGAElement",
+    "SVGAltGlyphDefElement",
+    "SVGAltGlyphElement",
+    "SVGAltGlyphItemElement",
+    "SVGAngle",
+    "SVGAnimateColorElement",
+    "SVGAnimateElement",
+    "SVGAnimateMotionElement",
+    "SVGAnimateTransformElement",
+    "SVGAnimatedAngle",
+    "SVGAnimatedBoolean",
+    "SVGAnimatedEnumeration",
+    "SVGAnimatedInteger",
+    "SVGAnimatedLength",
+    "SVGAnimatedLengthList",
+    "SVGAnimatedNumber",
+    "SVGAnimatedNumberList",
+    "SVGAnimatedPreserveAspectRatio",
+    "SVGAnimatedRect",
+    "SVGAnimatedString",
+    "SVGAnimatedTransformList",
+    "SVGAnimationElement",
+    "SVGCircleElement",
+    "SVGClipPathElement",
+    "SVGColor",
+    "SVGComponentTransferFunctionElement",
+    "SVGCursorElement",
+    "SVGDefsElement",
+    "SVGDescElement",
+    "SVGDiscardElement",
+    "SVGDocument",
+    "SVGElement",
+    "SVGElementInstance",
+    "SVGElementInstanceList",
+    "SVGEllipseElement",
+    "SVGException",
+    "SVGFEBlendElement",
+    "SVGFEColorMatrixElement",
+    "SVGFEComponentTransferElement",
+    "SVGFECompositeElement",
+    "SVGFEConvolveMatrixElement",
+    "SVGFEDiffuseLightingElement",
+    "SVGFEDisplacementMapElement",
+    "SVGFEDistantLightElement",
+    "SVGFEDropShadowElement",
+    "SVGFEFloodElement",
+    "SVGFEFuncAElement",
+    "SVGFEFuncBElement",
+    "SVGFEFuncGElement",
+    "SVGFEFuncRElement",
+    "SVGFEGaussianBlurElement",
+    "SVGFEImageElement",
+    "SVGFEMergeElement",
+    "SVGFEMergeNodeElement",
+    "SVGFEMorphologyElement",
+    "SVGFEOffsetElement",
+    "SVGFEPointLightElement",
+    "SVGFESpecularLightingElement",
+    "SVGFESpotLightElement",
+    "SVGFETileElement",
+    "SVGFETurbulenceElement",
+    "SVGFilterElement",
+    "SVGFontElement",
+    "SVGFontFaceElement",
+    "SVGFontFaceFormatElement",
+    "SVGFontFaceNameElement",
+    "SVGFontFaceSrcElement",
+    "SVGFontFaceUriElement",
+    "SVGForeignObjectElement",
+    "SVGGElement",
+    "SVGGeometryElement",
+    "SVGGlyphElement",
+    "SVGGlyphRefElement",
+    "SVGGradientElement",
+    "SVGGraphicsElement",
+    "SVGHKernElement",
+    "SVGImageElement",
+    "SVGLength",
+    "SVGLengthList",
+    "SVGLineElement",
+    "SVGLinearGradientElement",
+    "SVGMPathElement",
+    "SVGMarkerElement",
+    "SVGMaskElement",
+    "SVGMatrix",
+    "SVGMetadataElement",
+    "SVGMissingGlyphElement",
+    "SVGNumber",
+    "SVGNumberList",
+    "SVGPaint",
+    "SVGPathElement",
+    "SVGPathSeg",
+    "SVGPathSegArcAbs",
+    "SVGPathSegArcRel",
+    "SVGPathSegClosePath",
+    "SVGPathSegCurvetoCubicAbs",
+    "SVGPathSegCurvetoCubicRel",
+    "SVGPathSegCurvetoCubicSmoothAbs",
+    "SVGPathSegCurvetoCubicSmoothRel",
+    "SVGPathSegCurvetoQuadraticAbs",
+    "SVGPathSegCurvetoQuadraticRel",
+    "SVGPathSegCurvetoQuadraticSmoothAbs",
+    "SVGPathSegCurvetoQuadraticSmoothRel",
+    "SVGPathSegLinetoAbs",
+    "SVGPathSegLinetoHorizontalAbs",
+    "SVGPathSegLinetoHorizontalRel",
+    "SVGPathSegLinetoRel",
+    "SVGPathSegLinetoVerticalAbs",
+    "SVGPathSegLinetoVerticalRel",
+    "SVGPathSegList",
+    "SVGPathSegMovetoAbs",
+    "SVGPathSegMovetoRel",
+    "SVGPatternElement",
+    "SVGPoint",
+    "SVGPointList",
+    "SVGPolygonElement",
+    "SVGPolylineElement",
+    "SVGPreserveAspectRatio",
+    "SVGRadialGradientElement",
+    "SVGRect",
+    "SVGRectElement",
+    "SVGRenderingIntent",
+    "SVGSVGElement",
+    "SVGScriptElement",
+    "SVGSetElement",
+    "SVGStopElement",
+    "SVGStringList",
+    "SVGStyleElement",
+    "SVGSwitchElement",
+    "SVGSymbolElement",
+    "SVGTRefElement",
+    "SVGTSpanElement",
+    "SVGTextContentElement",
+    "SVGTextElement",
+    "SVGTextPathElement",
+    "SVGTextPositioningElement",
+    "SVGTitleElement",
+    "SVGTransform",
+    "SVGTransformList",
+    "SVGUnitTypes",
+    "SVGUseElement",
+    "SVGVKernElement",
+    "SVGViewElement",
+    "SVGViewSpec",
+    "SVGZoomAndPan",
+    "SVGZoomEvent",
+    "SVG_ANGLETYPE_DEG",
+    "SVG_ANGLETYPE_GRAD",
+    "SVG_ANGLETYPE_RAD",
+    "SVG_ANGLETYPE_UNKNOWN",
+    "SVG_ANGLETYPE_UNSPECIFIED",
+    "SVG_CHANNEL_A",
+    "SVG_CHANNEL_B",
+    "SVG_CHANNEL_G",
+    "SVG_CHANNEL_R",
+    "SVG_CHANNEL_UNKNOWN",
+    "SVG_COLORTYPE_CURRENTCOLOR",
+    "SVG_COLORTYPE_RGBCOLOR",
+    "SVG_COLORTYPE_RGBCOLOR_ICCCOLOR",
+    "SVG_COLORTYPE_UNKNOWN",
+    "SVG_EDGEMODE_DUPLICATE",
+    "SVG_EDGEMODE_NONE",
+    "SVG_EDGEMODE_UNKNOWN",
+    "SVG_EDGEMODE_WRAP",
+    "SVG_FEBLEND_MODE_COLOR",
+    "SVG_FEBLEND_MODE_COLOR_BURN",
+    "SVG_FEBLEND_MODE_COLOR_DODGE",
+    "SVG_FEBLEND_MODE_DARKEN",
+    "SVG_FEBLEND_MODE_DIFFERENCE",
+    "SVG_FEBLEND_MODE_EXCLUSION",
+    "SVG_FEBLEND_MODE_HARD_LIGHT",
+    "SVG_FEBLEND_MODE_HUE",
+    "SVG_FEBLEND_MODE_LIGHTEN",
+    "SVG_FEBLEND_MODE_LUMINOSITY",
+    "SVG_FEBLEND_MODE_MULTIPLY",
+    "SVG_FEBLEND_MODE_NORMAL",
+    "SVG_FEBLEND_MODE_OVERLAY",
+    "SVG_FEBLEND_MODE_SATURATION",
+    "SVG_FEBLEND_MODE_SCREEN",
+    "SVG_FEBLEND_MODE_SOFT_LIGHT",
+    "SVG_FEBLEND_MODE_UNKNOWN",
+    "SVG_FECOLORMATRIX_TYPE_HUEROTATE",
+    "SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA",
+    "SVG_FECOLORMATRIX_TYPE_MATRIX",
+    "SVG_FECOLORMATRIX_TYPE_SATURATE",
+    "SVG_FECOLORMATRIX_TYPE_UNKNOWN",
+    "SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE",
+    "SVG_FECOMPONENTTRANSFER_TYPE_GAMMA",
+    "SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY",
+    "SVG_FECOMPONENTTRANSFER_TYPE_LINEAR",
+    "SVG_FECOMPONENTTRANSFER_TYPE_TABLE",
+    "SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN",
+    "SVG_FECOMPOSITE_OPERATOR_ARITHMETIC",
+    "SVG_FECOMPOSITE_OPERATOR_ATOP",
+    "SVG_FECOMPOSITE_OPERATOR_IN",
+    "SVG_FECOMPOSITE_OPERATOR_OUT",
+    "SVG_FECOMPOSITE_OPERATOR_OVER",
+    "SVG_FECOMPOSITE_OPERATOR_UNKNOWN",
+    "SVG_FECOMPOSITE_OPERATOR_XOR",
+    "SVG_INVALID_VALUE_ERR",
+    "SVG_LENGTHTYPE_CM",
+    "SVG_LENGTHTYPE_EMS",
+    "SVG_LENGTHTYPE_EXS",
+    "SVG_LENGTHTYPE_IN",
+    "SVG_LENGTHTYPE_MM",
+    "SVG_LENGTHTYPE_NUMBER",
+    "SVG_LENGTHTYPE_PC",
+    "SVG_LENGTHTYPE_PERCENTAGE",
+    "SVG_LENGTHTYPE_PT",
+    "SVG_LENGTHTYPE_PX",
+    "SVG_LENGTHTYPE_UNKNOWN",
+    "SVG_MARKERUNITS_STROKEWIDTH",
+    "SVG_MARKERUNITS_UNKNOWN",
+    "SVG_MARKERUNITS_USERSPACEONUSE",
+    "SVG_MARKER_ORIENT_ANGLE",
+    "SVG_MARKER_ORIENT_AUTO",
+    "SVG_MARKER_ORIENT_UNKNOWN",
+    "SVG_MASKTYPE_ALPHA",
+    "SVG_MASKTYPE_LUMINANCE",
+    "SVG_MATRIX_NOT_INVERTABLE",
+    "SVG_MEETORSLICE_MEET",
+    "SVG_MEETORSLICE_SLICE",
+    "SVG_MEETORSLICE_UNKNOWN",
+    "SVG_MORPHOLOGY_OPERATOR_DILATE",
+    "SVG_MORPHOLOGY_OPERATOR_ERODE",
+    "SVG_MORPHOLOGY_OPERATOR_UNKNOWN",
+    "SVG_PAINTTYPE_CURRENTCOLOR",
+    "SVG_PAINTTYPE_NONE",
+    "SVG_PAINTTYPE_RGBCOLOR",
+    "SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR",
+    "SVG_PAINTTYPE_UNKNOWN",
+    "SVG_PAINTTYPE_URI",
+    "SVG_PAINTTYPE_URI_CURRENTCOLOR",
+    "SVG_PAINTTYPE_URI_NONE",
+    "SVG_PAINTTYPE_URI_RGBCOLOR",
+    "SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR",
+    "SVG_PRESERVEASPECTRATIO_NONE",
+    "SVG_PRESERVEASPECTRATIO_UNKNOWN",
+    "SVG_PRESERVEASPECTRATIO_XMAXYMAX",
+    "SVG_PRESERVEASPECTRATIO_XMAXYMID",
+    "SVG_PRESERVEASPECTRATIO_XMAXYMIN",
+    "SVG_PRESERVEASPECTRATIO_XMIDYMAX",
+    "SVG_PRESERVEASPECTRATIO_XMIDYMID",
+    "SVG_PRESERVEASPECTRATIO_XMIDYMIN",
+    "SVG_PRESERVEASPECTRATIO_XMINYMAX",
+    "SVG_PRESERVEASPECTRATIO_XMINYMID",
+    "SVG_PRESERVEASPECTRATIO_XMINYMIN",
+    "SVG_SPREADMETHOD_PAD",
+    "SVG_SPREADMETHOD_REFLECT",
+    "SVG_SPREADMETHOD_REPEAT",
+    "SVG_SPREADMETHOD_UNKNOWN",
+    "SVG_STITCHTYPE_NOSTITCH",
+    "SVG_STITCHTYPE_STITCH",
+    "SVG_STITCHTYPE_UNKNOWN",
+    "SVG_TRANSFORM_MATRIX",
+    "SVG_TRANSFORM_ROTATE",
+    "SVG_TRANSFORM_SCALE",
+    "SVG_TRANSFORM_SKEWX",
+    "SVG_TRANSFORM_SKEWY",
+    "SVG_TRANSFORM_TRANSLATE",
+    "SVG_TRANSFORM_UNKNOWN",
+    "SVG_TURBULENCE_TYPE_FRACTALNOISE",
+    "SVG_TURBULENCE_TYPE_TURBULENCE",
+    "SVG_TURBULENCE_TYPE_UNKNOWN",
+    "SVG_UNIT_TYPE_OBJECTBOUNDINGBOX",
+    "SVG_UNIT_TYPE_UNKNOWN",
+    "SVG_UNIT_TYPE_USERSPACEONUSE",
+    "SVG_WRONG_TYPE_ERR",
+    "SVG_ZOOMANDPAN_DISABLE",
+    "SVG_ZOOMANDPAN_MAGNIFY",
+    "SVG_ZOOMANDPAN_UNKNOWN",
+    "SYNTAX_ERR",
+    "SavedPages",
+    "Screen",
+    "ScreenOrientation",
+    "Script",
+    "ScriptProcessorNode",
+    "ScrollAreaEvent",
+    "SecurityPolicyViolationEvent",
+    "Selection",
+    "ServiceWorker",
+    "ServiceWorkerContainer",
+    "ServiceWorkerRegistration",
+    "SessionDescription",
+    "Set",
+    "ShadowRoot",
+    "SharedWorker",
+    "SimpleGestureEvent",
+    "SpeechSynthesisEvent",
+    "SpeechSynthesisUtterance",
+    "StopIteration",
+    "Storage",
+    "StorageEvent",
+    "String",
+    "StyleSheet",
+    "StyleSheetList",
+    "SubtleCrypto",
+    "Symbol",
+    "SyntaxError",
+    "TEMPORARY",
+    "TEXTPATH_METHODTYPE_ALIGN",
+    "TEXTPATH_METHODTYPE_STRETCH",
+    "TEXTPATH_METHODTYPE_UNKNOWN",
+    "TEXTPATH_SPACINGTYPE_AUTO",
+    "TEXTPATH_SPACINGTYPE_EXACT",
+    "TEXTPATH_SPACINGTYPE_UNKNOWN",
+    "TEXTURE",
+    "TEXTURE0",
+    "TEXTURE1",
+    "TEXTURE10",
+    "TEXTURE11",
+    "TEXTURE12",
+    "TEXTURE13",
+    "TEXTURE14",
+    "TEXTURE15",
+    "TEXTURE16",
+    "TEXTURE17",
+    "TEXTURE18",
+    "TEXTURE19",
+    "TEXTURE2",
+    "TEXTURE20",
+    "TEXTURE21",
+    "TEXTURE22",
+    "TEXTURE23",
+    "TEXTURE24",
+    "TEXTURE25",
+    "TEXTURE26",
+    "TEXTURE27",
+    "TEXTURE28",
+    "TEXTURE29",
+    "TEXTURE3",
+    "TEXTURE30",
+    "TEXTURE31",
+    "TEXTURE4",
+    "TEXTURE5",
+    "TEXTURE6",
+    "TEXTURE7",
+    "TEXTURE8",
+    "TEXTURE9",
+    "TEXTURE_2D",
+    "TEXTURE_BINDING_2D",
+    "TEXTURE_BINDING_CUBE_MAP",
+    "TEXTURE_CUBE_MAP",
+    "TEXTURE_CUBE_MAP_NEGATIVE_X",
+    "TEXTURE_CUBE_MAP_NEGATIVE_Y",
+    "TEXTURE_CUBE_MAP_NEGATIVE_Z",
+    "TEXTURE_CUBE_MAP_POSITIVE_X",
+    "TEXTURE_CUBE_MAP_POSITIVE_Y",
+    "TEXTURE_CUBE_MAP_POSITIVE_Z",
+    "TEXTURE_MAG_FILTER",
+    "TEXTURE_MAX_ANISOTROPY_EXT",
+    "TEXTURE_MIN_FILTER",
+    "TEXTURE_WRAP_S",
+    "TEXTURE_WRAP_T",
+    "TEXT_NODE",
+    "TIMEOUT",
+    "TIMEOUT_ERR",
+    "TOO_LARGE_ERR",
+    "TRANSACTION_INACTIVE_ERR",
+    "TRIANGLE",
+    "TRIANGLES",
+    "TRIANGLE_FAN",
+    "TRIANGLE_STRIP",
+    "TYPE_BACK_FORWARD",
+    "TYPE_ERR",
+    "TYPE_MISMATCH_ERR",
+    "TYPE_NAVIGATE",
+    "TYPE_RELOAD",
+    "TYPE_RESERVED",
+    "Text",
+    "TextDecoder",
+    "TextEncoder",
+    "TextEvent",
+    "TextMetrics",
+    "TextTrack",
+    "TextTrackCue",
+    "TextTrackCueList",
+    "TextTrackList",
+    "TimeEvent",
+    "TimeRanges",
+    "Touch",
+    "TouchEvent",
+    "TouchList",
+    "TrackEvent",
+    "TransitionEvent",
+    "TreeWalker",
+    "TypeError",
+    "UIEvent",
+    "UNCACHED",
+    "UNKNOWN_ERR",
+    "UNKNOWN_RULE",
+    "UNMASKED_RENDERER_WEBGL",
+    "UNMASKED_VENDOR_WEBGL",
+    "UNORDERED_NODE_ITERATOR_TYPE",
+    "UNORDERED_NODE_SNAPSHOT_TYPE",
+    "UNPACK_ALIGNMENT",
+    "UNPACK_COLORSPACE_CONVERSION_WEBGL",
+    "UNPACK_FLIP_Y_WEBGL",
+    "UNPACK_PREMULTIPLY_ALPHA_WEBGL",
+    "UNSCHEDULED_STATE",
+    "UNSENT",
+    "UNSIGNED_BYTE",
+    "UNSIGNED_INT",
+    "UNSIGNED_SHORT",
+    "UNSIGNED_SHORT_4_4_4_4",
+    "UNSIGNED_SHORT_5_5_5_1",
+    "UNSIGNED_SHORT_5_6_5",
+    "UNSPECIFIED_EVENT_TYPE_ERR",
+    "UPDATEREADY",
+    "URIError",
+    "URL",
+    "URLSearchParams",
+    "URLUnencoded",
+    "URL_MISMATCH_ERR",
+    "UTC",
+    "Uint16Array",
+    "Uint32Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "UserMessageHandler",
+    "UserMessageHandlersNamespace",
+    "UserProximityEvent",
+    "VALIDATE_STATUS",
+    "VALIDATION_ERR",
+    "VARIABLES_RULE",
+    "VENDOR",
+    "VERSION",
+    "VERSION_CHANGE",
+    "VERSION_ERR",
+    "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",
+    "VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE",
+    "VERTEX_ATTRIB_ARRAY_ENABLED",
+    "VERTEX_ATTRIB_ARRAY_NORMALIZED",
+    "VERTEX_ATTRIB_ARRAY_POINTER",
+    "VERTEX_ATTRIB_ARRAY_SIZE",
+    "VERTEX_ATTRIB_ARRAY_STRIDE",
+    "VERTEX_ATTRIB_ARRAY_TYPE",
+    "VERTEX_SHADER",
+    "VERTICAL",
+    "VERTICAL_AXIS",
+    "VER_ERR",
+    "VIEWPORT",
+    "VIEWPORT_RULE",
+    "VTTCue",
+    "VTTRegion",
+    "ValidityState",
+    "VideoStreamTrack",
+    "WEBKIT_FILTER_RULE",
+    "WEBKIT_KEYFRAMES_RULE",
+    "WEBKIT_KEYFRAME_RULE",
+    "WEBKIT_REGION_RULE",
+    "WRONG_DOCUMENT_ERR",
+    "WaveShaperNode",
+    "WeakMap",
+    "WeakSet",
+    "WebGLActiveInfo",
+    "WebGLBuffer",
+    "WebGLContextEvent",
+    "WebGLFramebuffer",
+    "WebGLProgram",
+    "WebGLRenderbuffer",
+    "WebGLRenderingContext",
+    "WebGLShader",
+    "WebGLShaderPrecisionFormat",
+    "WebGLTexture",
+    "WebGLUniformLocation",
+    "WebGLVertexArray",
+    "WebKitAnimationEvent",
+    "WebKitBlobBuilder",
+    "WebKitCSSFilterRule",
+    "WebKitCSSFilterValue",
+    "WebKitCSSKeyframeRule",
+    "WebKitCSSKeyframesRule",
+    "WebKitCSSMatrix",
+    "WebKitCSSRegionRule",
+    "WebKitCSSTransformValue",
+    "WebKitDataCue",
+    "WebKitGamepad",
+    "WebKitMediaKeyError",
+    "WebKitMediaKeyMessageEvent",
+    "WebKitMediaKeySession",
+    "WebKitMediaKeys",
+    "WebKitMediaSource",
+    "WebKitMutationObserver",
+    "WebKitNamespace",
+    "WebKitPlaybackTargetAvailabilityEvent",
+    "WebKitPoint",
+    "WebKitShadowRoot",
+    "WebKitSourceBuffer",
+    "WebKitSourceBufferList",
+    "WebKitTransitionEvent",
+    "WebSocket",
+    "WheelEvent",
+    "Window",
+    "Worker",
+    "XMLDocument",
+    "XMLHttpRequest",
+    "XMLHttpRequestEventTarget",
+    "XMLHttpRequestException",
+    "XMLHttpRequestProgressEvent",
+    "XMLHttpRequestUpload",
+    "XMLSerializer",
+    "XMLStylesheetProcessingInstruction",
+    "XPathEvaluator",
+    "XPathException",
+    "XPathExpression",
+    "XPathNSResolver",
+    "XPathResult",
+    "XSLTProcessor",
+    "ZERO",
+    "_XD0M_",
+    "_YD0M_",
+    "__defineGetter__",
+    "__defineSetter__",
+    "__lookupGetter__",
+    "__lookupSetter__",
+    "__opera",
+    "__proto__",
+    "_browserjsran",
+    "a",
+    "aLink",
+    "abbr",
+    "abort",
+    "abs",
+    "absolute",
+    "acceleration",
+    "accelerationIncludingGravity",
+    "accelerator",
+    "accept",
+    "acceptCharset",
+    "acceptNode",
+    "accessKey",
+    "accessKeyLabel",
+    "accuracy",
+    "acos",
+    "acosh",
+    "action",
+    "actionURL",
+    "active",
+    "activeCues",
+    "activeElement",
+    "activeSourceBuffers",
+    "activeSourceCount",
+    "activeTexture",
+    "add",
+    "addBehavior",
+    "addCandidate",
+    "addColorStop",
+    "addCue",
+    "addElement",
+    "addEventListener",
+    "addFilter",
+    "addFromString",
+    "addFromUri",
+    "addIceCandidate",
+    "addImport",
+    "addListener",
+    "addNamed",
+    "addPageRule",
+    "addPath",
+    "addPointer",
+    "addRange",
+    "addRegion",
+    "addRule",
+    "addSearchEngine",
+    "addSourceBuffer",
+    "addStream",
+    "addTextTrack",
+    "addTrack",
+    "addWakeLockListener",
+    "addedNodes",
+    "additionalName",
+    "additiveSymbols",
+    "addons",
+    "adoptNode",
+    "adr",
+    "advance",
+    "alert",
+    "algorithm",
+    "align",
+    "align-content",
+    "align-items",
+    "align-self",
+    "alignContent",
+    "alignItems",
+    "alignSelf",
+    "alignmentBaseline",
+    "alinkColor",
+    "all",
+    "allowFullscreen",
+    "allowedDirections",
+    "alpha",
+    "alt",
+    "altGraphKey",
+    "altHtml",
+    "altKey",
+    "altLeft",
+    "altitude",
+    "altitudeAccuracy",
+    "amplitude",
+    "ancestorOrigins",
+    "anchor",
+    "anchorNode",
+    "anchorOffset",
+    "anchors",
+    "angle",
+    "animVal",
+    "animate",
+    "animatedInstanceRoot",
+    "animatedNormalizedPathSegList",
+    "animatedPathSegList",
+    "animatedPoints",
+    "animation",
+    "animation-delay",
+    "animation-direction",
+    "animation-duration",
+    "animation-fill-mode",
+    "animation-iteration-count",
+    "animation-name",
+    "animation-play-state",
+    "animation-timing-function",
+    "animationDelay",
+    "animationDirection",
+    "animationDuration",
+    "animationFillMode",
+    "animationIterationCount",
+    "animationName",
+    "animationPlayState",
+    "animationStartTime",
+    "animationTimingFunction",
+    "animationsPaused",
+    "anniversary",
+    "app",
+    "appCodeName",
+    "appMinorVersion",
+    "appName",
+    "appNotifications",
+    "appVersion",
+    "append",
+    "appendBuffer",
+    "appendChild",
+    "appendData",
+    "appendItem",
+    "appendMedium",
+    "appendNamed",
+    "appendRule",
+    "appendStream",
+    "appendWindowEnd",
+    "appendWindowStart",
+    "applets",
+    "applicationCache",
+    "apply",
+    "applyElement",
+    "arc",
+    "arcTo",
+    "archive",
+    "areas",
+    "arguments",
+    "arrayBuffer",
+    "asin",
+    "asinh",
+    "assert",
+    "assign",
+    "async",
+    "atEnd",
+    "atan",
+    "atan2",
+    "atanh",
+    "atob",
+    "attachEvent",
+    "attachShader",
+    "attachments",
+    "attack",
+    "attrChange",
+    "attrName",
+    "attributeName",
+    "attributeNamespace",
+    "attributes",
+    "audioTracks",
+    "autoIncrement",
+    "autobuffer",
+    "autocapitalize",
+    "autocomplete",
+    "autocorrect",
+    "autofocus",
+    "autoplay",
+    "availHeight",
+    "availLeft",
+    "availTop",
+    "availWidth",
+    "availability",
+    "available",
+    "aversion",
+    "axes",
+    "axis",
+    "azimuth",
+    "b",
+    "back",
+    "backface-visibility",
+    "backfaceVisibility",
+    "background",
+    "background-attachment",
+    "background-blend-mode",
+    "background-clip",
+    "background-color",
+    "background-image",
+    "background-origin",
+    "background-position",
+    "background-repeat",
+    "background-size",
+    "backgroundAttachment",
+    "backgroundBlendMode",
+    "backgroundClip",
+    "backgroundColor",
+    "backgroundImage",
+    "backgroundOrigin",
+    "backgroundPosition",
+    "backgroundPositionX",
+    "backgroundPositionY",
+    "backgroundRepeat",
+    "backgroundSize",
+    "badInput",
+    "balance",
+    "baseFrequencyX",
+    "baseFrequencyY",
+    "baseNode",
+    "baseOffset",
+    "baseURI",
+    "baseVal",
+    "baselineShift",
+    "battery",
+    "bday",
+    "beginElement",
+    "beginElementAt",
+    "beginPath",
+    "behavior",
+    "behaviorCookie",
+    "behaviorPart",
+    "behaviorUrns",
+    "beta",
+    "bezierCurveTo",
+    "bgColor",
+    "bgProperties",
+    "bias",
+    "big",
+    "binaryType",
+    "bind",
+    "bindAttribLocation",
+    "bindBuffer",
+    "bindFramebuffer",
+    "bindRenderbuffer",
+    "bindTexture",
+    "blendColor",
+    "blendEquation",
+    "blendEquationSeparate",
+    "blendFunc",
+    "blendFuncSeparate",
+    "blink",
+    "blob",
+    "blockDirection",
+    "blue",
+    "blur",
+    "body",
+    "bodyUsed",
+    "bold",
+    "bookmarks",
+    "booleanValue",
+    "border",
+    "border-bottom",
+    "border-bottom-color",
+    "border-bottom-left-radius",
+    "border-bottom-right-radius",
+    "border-bottom-style",
+    "border-bottom-width",
+    "border-collapse",
+    "border-color",
+    "border-image",
+    "border-image-outset",
+    "border-image-repeat",
+    "border-image-slice",
+    "border-image-source",
+    "border-image-width",
+    "border-left",
+    "border-left-color",
+    "border-left-style",
+    "border-left-width",
+    "border-radius",
+    "border-right",
+    "border-right-color",
+    "border-right-style",
+    "border-right-width",
+    "border-spacing",
+    "border-style",
+    "border-top",
+    "border-top-color",
+    "border-top-left-radius",
+    "border-top-right-radius",
+    "border-top-style",
+    "border-top-width",
+    "border-width",
+    "borderBottom",
+    "borderBottomColor",
+    "borderBottomLeftRadius",
+    "borderBottomRightRadius",
+    "borderBottomStyle",
+    "borderBottomWidth",
+    "borderCollapse",
+    "borderColor",
+    "borderColorDark",
+    "borderColorLight",
+    "borderImage",
+    "borderImageOutset",
+    "borderImageRepeat",
+    "borderImageSlice",
+    "borderImageSource",
+    "borderImageWidth",
+    "borderLeft",
+    "borderLeftColor",
+    "borderLeftStyle",
+    "borderLeftWidth",
+    "borderRadius",
+    "borderRight",
+    "borderRightColor",
+    "borderRightStyle",
+    "borderRightWidth",
+    "borderSpacing",
+    "borderStyle",
+    "borderTop",
+    "borderTopColor",
+    "borderTopLeftRadius",
+    "borderTopRightRadius",
+    "borderTopStyle",
+    "borderTopWidth",
+    "borderWidth",
+    "bottom",
+    "bottomMargin",
+    "bound",
+    "boundElements",
+    "boundingClientRect",
+    "boundingHeight",
+    "boundingLeft",
+    "boundingTop",
+    "boundingWidth",
+    "bounds",
+    "box-decoration-break",
+    "box-shadow",
+    "box-sizing",
+    "boxDecorationBreak",
+    "boxShadow",
+    "boxSizing",
+    "breakAfter",
+    "breakBefore",
+    "breakInside",
+    "browserLanguage",
+    "btoa",
+    "bubbles",
+    "buffer",
+    "bufferData",
+    "bufferDepth",
+    "bufferSize",
+    "bufferSubData",
+    "buffered",
+    "bufferedAmount",
+    "buildID",
+    "buildNumber",
+    "button",
+    "buttonID",
+    "buttons",
+    "byteLength",
+    "byteOffset",
+    "c",
+    "call",
+    "caller",
+    "canBeFormatted",
+    "canBeMounted",
+    "canBeShared",
+    "canHaveChildren",
+    "canHaveHTML",
+    "canPlayType",
+    "cancel",
+    "cancelAnimationFrame",
+    "cancelBubble",
+    "cancelScheduledValues",
+    "cancelable",
+    "candidate",
+    "canvas",
+    "caption",
+    "caption-side",
+    "captionSide",
+    "captureEvents",
+    "captureStackTrace",
+    "caretPositionFromPoint",
+    "caretRangeFromPoint",
+    "cast",
+    "catch",
+    "category",
+    "cbrt",
+    "cd",
+    "ceil",
+    "cellIndex",
+    "cellPadding",
+    "cellSpacing",
+    "cells",
+    "ch",
+    "chOff",
+    "chain",
+    "challenge",
+    "changedTouches",
+    "channel",
+    "channelCount",
+    "channelCountMode",
+    "channelInterpretation",
+    "char",
+    "charAt",
+    "charCode",
+    "charCodeAt",
+    "charIndex",
+    "characterSet",
+    "charging",
+    "chargingTime",
+    "charset",
+    "checkEnclosure",
+    "checkFramebufferStatus",
+    "checkIntersection",
+    "checkValidity",
+    "checked",
+    "childElementCount",
+    "childNodes",
+    "children",
+    "chrome",
+    "ciphertext",
+    "cite",
+    "classList",
+    "className",
+    "classid",
+    "clear",
+    "clearAttributes",
+    "clearColor",
+    "clearData",
+    "clearDepth",
+    "clearImmediate",
+    "clearInterval",
+    "clearMarks",
+    "clearMeasures",
+    "clearParameters",
+    "clearRect",
+    "clearResourceTimings",
+    "clearShadow",
+    "clearStencil",
+    "clearTimeout",
+    "clearWatch",
+    "click",
+    "clickCount",
+    "clientHeight",
+    "clientInformation",
+    "clientLeft",
+    "clientRect",
+    "clientRects",
+    "clientTop",
+    "clientWidth",
+    "clientX",
+    "clientY",
+    "clip",
+    "clip-path",
+    "clip-rule",
+    "clipBottom",
+    "clipLeft",
+    "clipPath",
+    "clipPathUnits",
+    "clipRight",
+    "clipRule",
+    "clipTop",
+    "clipboardData",
+    "clone",
+    "cloneContents",
+    "cloneNode",
+    "cloneRange",
+    "close",
+    "closePath",
+    "closed",
+    "closest",
+    "clz",
+    "clz32",
+    "cmp",
+    "code",
+    "codeBase",
+    "codePointAt",
+    "codeType",
+    "colSpan",
+    "collapse",
+    "collapseToEnd",
+    "collapseToStart",
+    "collapsed",
+    "collect",
+    "colno",
+    "color",
+    "color-interpolation",
+    "color-interpolation-filters",
+    "colorDepth",
+    "colorInterpolation",
+    "colorInterpolationFilters",
+    "colorMask",
+    "colorType",
+    "cols",
+    "columnCount",
+    "columnFill",
+    "columnGap",
+    "columnNumber",
+    "columnRule",
+    "columnRuleColor",
+    "columnRuleStyle",
+    "columnRuleWidth",
+    "columnSpan",
+    "columnWidth",
+    "columns",
+    "command",
+    "commitPreferences",
+    "commonAncestorContainer",
+    "compact",
+    "compareBoundaryPoints",
+    "compareDocumentPosition",
+    "compareEndPoints",
+    "compareNode",
+    "comparePoint",
+    "compatMode",
+    "compatible",
+    "compile",
+    "compileShader",
+    "complete",
+    "componentFromPoint",
+    "compositionEndOffset",
+    "compositionStartOffset",
+    "compressedTexImage2D",
+    "compressedTexSubImage2D",
+    "concat",
+    "conditionText",
+    "coneInnerAngle",
+    "coneOuterAngle",
+    "coneOuterGain",
+    "confirm",
+    "confirmComposition",
+    "confirmSiteSpecificTrackingException",
+    "confirmWebWideTrackingException",
+    "connect",
+    "connectEnd",
+    "connectStart",
+    "connected",
+    "connection",
+    "connectionSpeed",
+    "console",
+    "consolidate",
+    "constrictionActive",
+    "constructor",
+    "contactID",
+    "contains",
+    "containsNode",
+    "content",
+    "contentDocument",
+    "contentEditable",
+    "contentOverflow",
+    "contentScriptType",
+    "contentStyleType",
+    "contentType",
+    "contentWindow",
+    "context",
+    "contextMenu",
+    "contextmenu",
+    "continue",
+    "continuous",
+    "control",
+    "controller",
+    "controls",
+    "convertToSpecifiedUnits",
+    "cookie",
+    "cookieEnabled",
+    "coords",
+    "copyFromChannel",
+    "copyTexImage2D",
+    "copyTexSubImage2D",
+    "copyToChannel",
+    "copyWithin",
+    "correspondingElement",
+    "correspondingUseElement",
+    "cos",
+    "cosh",
+    "count",
+    "counter-increment",
+    "counter-reset",
+    "counterIncrement",
+    "counterReset",
+    "cpuClass",
+    "cpuSleepAllowed",
+    "create",
+    "createAnalyser",
+    "createAnswer",
+    "createAttribute",
+    "createAttributeNS",
+    "createBiquadFilter",
+    "createBuffer",
+    "createBufferSource",
+    "createCDATASection",
+    "createCSSStyleSheet",
+    "createCaption",
+    "createChannelMerger",
+    "createChannelSplitter",
+    "createComment",
+    "createContextualFragment",
+    "createControlRange",
+    "createConvolver",
+    "createDTMFSender",
+    "createDataChannel",
+    "createDelay",
+    "createDelayNode",
+    "createDocument",
+    "createDocumentFragment",
+    "createDocumentType",
+    "createDynamicsCompressor",
+    "createElement",
+    "createElementNS",
+    "createEntityReference",
+    "createEvent",
+    "createEventObject",
+    "createExpression",
+    "createFramebuffer",
+    "createFunction",
+    "createGain",
+    "createGainNode",
+    "createHTMLDocument",
+    "createImageBitmap",
+    "createImageData",
+    "createIndex",
+    "createJavaScriptNode",
+    "createLinearGradient",
+    "createMediaElementSource",
+    "createMediaKeys",
+    "createMediaStreamDestination",
+    "createMediaStreamSource",
+    "createMutableFile",
+    "createNSResolver",
+    "createNodeIterator",
+    "createNotification",
+    "createObjectStore",
+    "createObjectURL",
+    "createOffer",
+    "createOscillator",
+    "createPanner",
+    "createPattern",
+    "createPeriodicWave",
+    "createPopup",
+    "createProcessingInstruction",
+    "createProgram",
+    "createRadialGradient",
+    "createRange",
+    "createRangeCollection",
+    "createRenderbuffer",
+    "createSVGAngle",
+    "createSVGLength",
+    "createSVGMatrix",
+    "createSVGNumber",
+    "createSVGPathSegArcAbs",
+    "createSVGPathSegArcRel",
+    "createSVGPathSegClosePath",
+    "createSVGPathSegCurvetoCubicAbs",
+    "createSVGPathSegCurvetoCubicRel",
+    "createSVGPathSegCurvetoCubicSmoothAbs",
+    "createSVGPathSegCurvetoCubicSmoothRel",
+    "createSVGPathSegCurvetoQuadraticAbs",
+    "createSVGPathSegCurvetoQuadraticRel",
+    "createSVGPathSegCurvetoQuadraticSmoothAbs",
+    "createSVGPathSegCurvetoQuadraticSmoothRel",
+    "createSVGPathSegLinetoAbs",
+    "createSVGPathSegLinetoHorizontalAbs",
+    "createSVGPathSegLinetoHorizontalRel",
+    "createSVGPathSegLinetoRel",
+    "createSVGPathSegLinetoVerticalAbs",
+    "createSVGPathSegLinetoVerticalRel",
+    "createSVGPathSegMovetoAbs",
+    "createSVGPathSegMovetoRel",
+    "createSVGPoint",
+    "createSVGRect",
+    "createSVGTransform",
+    "createSVGTransformFromMatrix",
+    "createScriptProcessor",
+    "createSession",
+    "createShader",
+    "createShadowRoot",
+    "createStereoPanner",
+    "createStyleSheet",
+    "createTBody",
+    "createTFoot",
+    "createTHead",
+    "createTextNode",
+    "createTextRange",
+    "createTexture",
+    "createTouch",
+    "createTouchList",
+    "createTreeWalker",
+    "createWaveShaper",
+    "creationTime",
+    "crossOrigin",
+    "crypto",
+    "csi",
+    "cssFloat",
+    "cssRules",
+    "cssText",
+    "cssValueType",
+    "ctrlKey",
+    "ctrlLeft",
+    "cues",
+    "cullFace",
+    "currentNode",
+    "currentPage",
+    "currentScale",
+    "currentScript",
+    "currentSrc",
+    "currentState",
+    "currentStyle",
+    "currentTarget",
+    "currentTime",
+    "currentTranslate",
+    "currentView",
+    "cursor",
+    "curve",
+    "customError",
+    "cx",
+    "cy",
+    "d",
+    "data",
+    "dataFld",
+    "dataFormatAs",
+    "dataPageSize",
+    "dataSrc",
+    "dataTransfer",
+    "database",
+    "dataset",
+    "dateTime",
+    "db",
+    "debug",
+    "debuggerEnabled",
+    "declare",
+    "decode",
+    "decodeAudioData",
+    "decodeURI",
+    "decodeURIComponent",
+    "decrypt",
+    "default",
+    "defaultCharset",
+    "defaultChecked",
+    "defaultMuted",
+    "defaultPlaybackRate",
+    "defaultPrevented",
+    "defaultSelected",
+    "defaultStatus",
+    "defaultURL",
+    "defaultValue",
+    "defaultView",
+    "defaultstatus",
+    "defer",
+    "defineMagicFunction",
+    "defineMagicVariable",
+    "defineProperties",
+    "defineProperty",
+    "delayTime",
+    "delete",
+    "deleteBuffer",
+    "deleteCaption",
+    "deleteCell",
+    "deleteContents",
+    "deleteData",
+    "deleteDatabase",
+    "deleteFramebuffer",
+    "deleteFromDocument",
+    "deleteIndex",
+    "deleteMedium",
+    "deleteObjectStore",
+    "deleteProgram",
+    "deleteRenderbuffer",
+    "deleteRow",
+    "deleteRule",
+    "deleteShader",
+    "deleteTFoot",
+    "deleteTHead",
+    "deleteTexture",
+    "deliverChangeRecords",
+    "delivery",
+    "deliveryInfo",
+    "deliveryStatus",
+    "deliveryTimestamp",
+    "delta",
+    "deltaMode",
+    "deltaX",
+    "deltaY",
+    "deltaZ",
+    "depthFunc",
+    "depthMask",
+    "depthRange",
+    "deriveBits",
+    "deriveKey",
+    "description",
+    "deselectAll",
+    "designMode",
+    "destination",
+    "destinationURL",
+    "detach",
+    "detachEvent",
+    "detachShader",
+    "detail",
+    "detune",
+    "devicePixelRatio",
+    "deviceXDPI",
+    "deviceYDPI",
+    "diffuseConstant",
+    "digest",
+    "dimensions",
+    "dir",
+    "dirName",
+    "direction",
+    "dirxml",
+    "disable",
+    "disableVertexAttribArray",
+    "disabled",
+    "dischargingTime",
+    "disconnect",
+    "dispatchEvent",
+    "display",
+    "distanceModel",
+    "divisor",
+    "djsapi",
+    "djsproxy",
+    "doImport",
+    "doNotTrack",
+    "doScroll",
+    "doctype",
+    "document",
+    "documentElement",
+    "documentMode",
+    "documentURI",
+    "dolphin",
+    "dolphinGameCenter",
+    "dolphininfo",
+    "dolphinmeta",
+    "domComplete",
+    "domContentLoadedEventEnd",
+    "domContentLoadedEventStart",
+    "domInteractive",
+    "domLoading",
+    "domain",
+    "domainLookupEnd",
+    "domainLookupStart",
+    "dominant-baseline",
+    "dominantBaseline",
+    "done",
+    "dopplerFactor",
+    "download",
+    "dragDrop",
+    "draggable",
+    "drawArrays",
+    "drawArraysInstancedANGLE",
+    "drawCustomFocusRing",
+    "drawElements",
+    "drawElementsInstancedANGLE",
+    "drawFocusIfNeeded",
+    "drawImage",
+    "drawImageFromRect",
+    "drawSystemFocusRing",
+    "drawingBufferHeight",
+    "drawingBufferWidth",
+    "dropEffect",
+    "droppedVideoFrames",
+    "dropzone",
+    "dump",
+    "duplicate",
+    "duration",
+    "dvname",
+    "dvnum",
+    "dx",
+    "dy",
+    "dynsrc",
+    "e",
+    "edgeMode",
+    "effectAllowed",
+    "elapsedTime",
+    "elementFromPoint",
+    "elements",
+    "elevation",
+    "ellipse",
+    "email",
+    "embeds",
+    "empty",
+    "empty-cells",
+    "emptyCells",
+    "enable",
+    "enableBackground",
+    "enableStyleSheetsForSet",
+    "enableVertexAttribArray",
+    "enabled",
+    "enabledPlugin",
+    "encode",
+    "encodeURI",
+    "encodeURIComponent",
+    "encoding",
+    "encrypt",
+    "enctype",
+    "end",
+    "endContainer",
+    "endElement",
+    "endElementAt",
+    "endOfStream",
+    "endOffset",
+    "endTime",
+    "ended",
+    "endsWith",
+    "entities",
+    "entries",
+    "entryType",
+    "enumerate",
+    "enumerateEditable",
+    "error",
+    "errorCode",
+    "escape",
+    "eval",
+    "evaluate",
+    "event",
+    "eventPhase",
+    "every",
+    "exception",
+    "exec",
+    "execCommand",
+    "execCommandShowHelp",
+    "execScript",
+    "exitFullscreen",
+    "exitPointerLock",
+    "exp",
+    "expand",
+    "expandEntityReferences",
+    "expando",
+    "expansion",
+    "expiryDate",
+    "explicitOriginalTarget",
+    "expm1",
+    "exponent",
+    "exponentialRampToValueAtTime",
+    "exportKey",
+    "extend",
+    "extensions",
+    "extentNode",
+    "extentOffset",
+    "external",
+    "externalResourcesRequired",
+    "extractContents",
+    "extractable",
+    "f",
+    "face",
+    "factoryReset",
+    "fallback",
+    "familyName",
+    "farthestViewportElement",
+    "fastSeek",
+    "fatal",
+    "fetch",
+    "fetchStart",
+    "fftSize",
+    "fgColor",
+    "fileCreatedDate",
+    "fileHandle",
+    "fileModifiedDate",
+    "fileName",
+    "fileSize",
+    "fileUpdatedDate",
+    "filename",
+    "files",
+    "fill",
+    "fill-opacity",
+    "fill-rule",
+    "fillOpacity",
+    "fillRect",
+    "fillRule",
+    "fillStyle",
+    "fillText",
+    "filter",
+    "filterResX",
+    "filterResY",
+    "filterUnits",
+    "filters",
+    "find",
+    "findIndex",
+    "findRule",
+    "findText",
+    "finish",
+    "fireEvent",
+    "firstChild",
+    "firstElementChild",
+    "firstPage",
+    "fixed",
+    "flex",
+    "flex-basis",
+    "flex-direction",
+    "flex-flow",
+    "flex-grow",
+    "flex-shrink",
+    "flex-wrap",
+    "flexBasis",
+    "flexDirection",
+    "flexFlow",
+    "flexGrow",
+    "flexShrink",
+    "flexWrap",
+    "flipX",
+    "flipY",
+    "float",
+    "flood-color",
+    "flood-opacity",
+    "floodColor",
+    "floodOpacity",
+    "floor",
+    "flush",
+    "focus",
+    "focusNode",
+    "focusOffset",
+    "font",
+    "font-family",
+    "font-feature-settings",
+    "font-kerning",
+    "font-language-override",
+    "font-size",
+    "font-size-adjust",
+    "font-stretch",
+    "font-style",
+    "font-synthesis",
+    "font-variant",
+    "font-variant-alternates",
+    "font-variant-caps",
+    "font-variant-east-asian",
+    "font-variant-ligatures",
+    "font-variant-numeric",
+    "font-variant-position",
+    "font-weight",
+    "fontFamily",
+    "fontFeatureSettings",
+    "fontKerning",
+    "fontLanguageOverride",
+    "fontSize",
+    "fontSizeAdjust",
+    "fontSmoothingEnabled",
+    "fontStretch",
+    "fontStyle",
+    "fontSynthesis",
+    "fontVariant",
+    "fontVariantAlternates",
+    "fontVariantCaps",
+    "fontVariantEastAsian",
+    "fontVariantLigatures",
+    "fontVariantNumeric",
+    "fontVariantPosition",
+    "fontWeight",
+    "fontcolor",
+    "fonts",
+    "fontsize",
+    "for",
+    "forEach",
+    "forceRedraw",
+    "form",
+    "formAction",
+    "formEnctype",
+    "formMethod",
+    "formNoValidate",
+    "formTarget",
+    "format",
+    "forms",
+    "forward",
+    "fr",
+    "frame",
+    "frameBorder",
+    "frameElement",
+    "frameSpacing",
+    "framebufferRenderbuffer",
+    "framebufferTexture2D",
+    "frames",
+    "freeSpace",
+    "freeze",
+    "frequency",
+    "frequencyBinCount",
+    "from",
+    "fromCharCode",
+    "fromCodePoint",
+    "fromElement",
+    "frontFace",
+    "fround",
+    "fullScreen",
+    "fullscreenElement",
+    "fullscreenEnabled",
+    "fx",
+    "fy",
+    "gain",
+    "gamepad",
+    "gamma",
+    "genderIdentity",
+    "generateKey",
+    "generateMipmap",
+    "generateRequest",
+    "geolocation",
+    "gestureObject",
+    "get",
+    "getActiveAttrib",
+    "getActiveUniform",
+    "getAdjacentText",
+    "getAll",
+    "getAllResponseHeaders",
+    "getAsFile",
+    "getAsString",
+    "getAttachedShaders",
+    "getAttribLocation",
+    "getAttribute",
+    "getAttributeNS",
+    "getAttributeNode",
+    "getAttributeNodeNS",
+    "getAudioTracks",
+    "getBBox",
+    "getBattery",
+    "getBlob",
+    "getBookmark",
+    "getBoundingClientRect",
+    "getBufferParameter",
+    "getByteFrequencyData",
+    "getByteTimeDomainData",
+    "getCSSCanvasContext",
+    "getCTM",
+    "getCandidateWindowClientRect",
+    "getChannelData",
+    "getCharNumAtPosition",
+    "getClientRect",
+    "getClientRects",
+    "getCompositionAlternatives",
+    "getComputedStyle",
+    "getComputedTextLength",
+    "getConfiguration",
+    "getContext",
+    "getContextAttributes",
+    "getCounterValue",
+    "getCueAsHTML",
+    "getCueById",
+    "getCurrentPosition",
+    "getCurrentTime",
+    "getData",
+    "getDatabaseNames",
+    "getDate",
+    "getDay",
+    "getDefaultComputedStyle",
+    "getDestinationInsertionPoints",
+    "getDistributedNodes",
+    "getEditable",
+    "getElementById",
+    "getElementsByClassName",
+    "getElementsByName",
+    "getElementsByTagName",
+    "getElementsByTagNameNS",
+    "getEnclosureList",
+    "getEndPositionOfChar",
+    "getEntries",
+    "getEntriesByName",
+    "getEntriesByType",
+    "getError",
+    "getExtension",
+    "getExtentOfChar",
+    "getFeature",
+    "getFile",
+    "getFloat32",
+    "getFloat64",
+    "getFloatFrequencyData",
+    "getFloatTimeDomainData",
+    "getFloatValue",
+    "getFramebufferAttachmentParameter",
+    "getFrequencyResponse",
+    "getFullYear",
+    "getGamepads",
+    "getHours",
+    "getImageData",
+    "getInt16",
+    "getInt32",
+    "getInt8",
+    "getIntersectionList",
+    "getItem",
+    "getItems",
+    "getKey",
+    "getLineDash",
+    "getLocalStreams",
+    "getMarks",
+    "getMatchedCSSRules",
+    "getMeasures",
+    "getMetadata",
+    "getMilliseconds",
+    "getMinutes",
+    "getModifierState",
+    "getMonth",
+    "getNamedItem",
+    "getNamedItemNS",
+    "getNotifier",
+    "getNumberOfChars",
+    "getOverrideHistoryNavigationMode",
+    "getOverrideStyle",
+    "getOwnPropertyDescriptor",
+    "getOwnPropertyNames",
+    "getOwnPropertySymbols",
+    "getParameter",
+    "getPathSegAtLength",
+    "getPointAtLength",
+    "getPreference",
+    "getPreferenceDefault",
+    "getPresentationAttribute",
+    "getPreventDefault",
+    "getProgramInfoLog",
+    "getProgramParameter",
+    "getPropertyCSSValue",
+    "getPropertyPriority",
+    "getPropertyShorthand",
+    "getPropertyValue",
+    "getPrototypeOf",
+    "getRGBColorValue",
+    "getRandomValues",
+    "getRangeAt",
+    "getReceivers",
+    "getRectValue",
+    "getRegistration",
+    "getRemoteStreams",
+    "getRenderbufferParameter",
+    "getResponseHeader",
+    "getRoot",
+    "getRotationOfChar",
+    "getSVGDocument",
+    "getScreenCTM",
+    "getSeconds",
+    "getSelection",
+    "getSenders",
+    "getShaderInfoLog",
+    "getShaderParameter",
+    "getShaderPrecisionFormat",
+    "getShaderSource",
+    "getSimpleDuration",
+    "getSiteIcons",
+    "getSources",
+    "getSpeculativeParserUrls",
+    "getStartPositionOfChar",
+    "getStartTime",
+    "getStats",
+    "getStorageUpdates",
+    "getStreamById",
+    "getStringValue",
+    "getSubStringLength",
+    "getSubscription",
+    "getSupportedExtensions",
+    "getTexParameter",
+    "getTime",
+    "getTimezoneOffset",
+    "getTotalLength",
+    "getTrackById",
+    "getTracks",
+    "getTransformToElement",
+    "getUTCDate",
+    "getUTCDay",
+    "getUTCFullYear",
+    "getUTCHours",
+    "getUTCMilliseconds",
+    "getUTCMinutes",
+    "getUTCMonth",
+    "getUTCSeconds",
+    "getUint16",
+    "getUint32",
+    "getUint8",
+    "getUniform",
+    "getUniformLocation",
+    "getUserMedia",
+    "getValues",
+    "getVarDate",
+    "getVariableValue",
+    "getVertexAttrib",
+    "getVertexAttribOffset",
+    "getVideoPlaybackQuality",
+    "getVideoTracks",
+    "getWakeLockState",
+    "getYear",
+    "givenName",
+    "global",
+    "globalAlpha",
+    "globalCompositeOperation",
+    "glyphOrientationHorizontal",
+    "glyphOrientationVertical",
+    "glyphRef",
+    "go",
+    "gradientTransform",
+    "gradientUnits",
+    "grammars",
+    "green",
+    "group",
+    "groupCollapsed",
+    "groupEnd",
+    "hardwareConcurrency",
+    "has",
+    "hasAttribute",
+    "hasAttributeNS",
+    "hasAttributes",
+    "hasChildNodes",
+    "hasComposition",
+    "hasExtension",
+    "hasFeature",
+    "hasFocus",
+    "hasLayout",
+    "hasOwnProperty",
+    "hash",
+    "head",
+    "headers",
+    "heading",
+    "height",
+    "hidden",
+    "hide",
+    "hideFocus",
+    "high",
+    "hint",
+    "history",
+    "honorificPrefix",
+    "honorificSuffix",
+    "horizontalOverflow",
+    "host",
+    "hostname",
+    "href",
+    "hreflang",
+    "hspace",
+    "html5TagCheckInerface",
+    "htmlFor",
+    "htmlText",
+    "httpEquiv",
+    "hwTimestamp",
+    "hypot",
+    "iccId",
+    "iceConnectionState",
+    "iceGatheringState",
+    "icon",
+    "id",
+    "identifier",
+    "identity",
+    "ignoreBOM",
+    "ignoreCase",
+    "image-orientation",
+    "image-rendering",
+    "imageOrientation",
+    "imageRendering",
+    "images",
+    "ime-mode",
+    "imeMode",
+    "implementation",
+    "importKey",
+    "importNode",
+    "importStylesheet",
+    "imports",
+    "impp",
+    "imul",
+    "in1",
+    "in2",
+    "inBandMetadataTrackDispatchType",
+    "inRange",
+    "includes",
+    "incremental",
+    "indeterminate",
+    "index",
+    "indexNames",
+    "indexOf",
+    "indexedDB",
+    "inertiaDestinationX",
+    "inertiaDestinationY",
+    "info",
+    "init",
+    "initAnimationEvent",
+    "initBeforeLoadEvent",
+    "initClipboardEvent",
+    "initCloseEvent",
+    "initCommandEvent",
+    "initCompositionEvent",
+    "initCustomEvent",
+    "initData",
+    "initDeviceMotionEvent",
+    "initDeviceOrientationEvent",
+    "initDragEvent",
+    "initErrorEvent",
+    "initEvent",
+    "initFocusEvent",
+    "initGestureEvent",
+    "initHashChangeEvent",
+    "initKeyEvent",
+    "initKeyboardEvent",
+    "initMSManipulationEvent",
+    "initMessageEvent",
+    "initMouseEvent",
+    "initMouseScrollEvent",
+    "initMouseWheelEvent",
+    "initMutationEvent",
+    "initNSMouseEvent",
+    "initOverflowEvent",
+    "initPageEvent",
+    "initPageTransitionEvent",
+    "initPointerEvent",
+    "initPopStateEvent",
+    "initProgressEvent",
+    "initScrollAreaEvent",
+    "initSimpleGestureEvent",
+    "initStorageEvent",
+    "initTextEvent",
+    "initTimeEvent",
+    "initTouchEvent",
+    "initTransitionEvent",
+    "initUIEvent",
+    "initWebKitAnimationEvent",
+    "initWebKitTransitionEvent",
+    "initWebKitWheelEvent",
+    "initWheelEvent",
+    "initialTime",
+    "initialize",
+    "initiatorType",
+    "inner",
+    "innerHTML",
+    "innerHeight",
+    "innerText",
+    "innerWidth",
+    "input",
+    "inputBuffer",
+    "inputEncoding",
+    "inputMethod",
+    "insertAdjacentElement",
+    "insertAdjacentHTML",
+    "insertAdjacentText",
+    "insertBefore",
+    "insertCell",
+    "insertData",
+    "insertItemBefore",
+    "insertNode",
+    "insertRow",
+    "insertRule",
+    "instanceRoot",
+    "intercept",
+    "interimResults",
+    "internalSubset",
+    "intersectsNode",
+    "interval",
+    "invalidIteratorState",
+    "inverse",
+    "invertSelf",
+    "is",
+    "is2D",
+    "isAlternate",
+    "isArray",
+    "isBingCurrentSearchDefault",
+    "isBuffer",
+    "isCandidateWindowVisible",
+    "isChar",
+    "isCollapsed",
+    "isComposing",
+    "isContentEditable",
+    "isContentHandlerRegistered",
+    "isContextLost",
+    "isDefaultNamespace",
+    "isDisabled",
+    "isEnabled",
+    "isEqual",
+    "isEqualNode",
+    "isExtensible",
+    "isFinite",
+    "isFramebuffer",
+    "isFrozen",
+    "isGenerator",
+    "isId",
+    "isInjected",
+    "isInteger",
+    "isMap",
+    "isMultiLine",
+    "isNaN",
+    "isOpen",
+    "isPointInFill",
+    "isPointInPath",
+    "isPointInRange",
+    "isPointInStroke",
+    "isPrefAlternate",
+    "isPrimary",
+    "isProgram",
+    "isPropertyImplicit",
+    "isProtocolHandlerRegistered",
+    "isPrototypeOf",
+    "isRenderbuffer",
+    "isSafeInteger",
+    "isSameNode",
+    "isSealed",
+    "isShader",
+    "isSupported",
+    "isTextEdit",
+    "isTexture",
+    "isTrusted",
+    "isTypeSupported",
+    "isView",
+    "isolation",
+    "italics",
+    "item",
+    "itemId",
+    "itemProp",
+    "itemRef",
+    "itemScope",
+    "itemType",
+    "itemValue",
+    "iterateNext",
+    "iterator",
+    "javaEnabled",
+    "jobTitle",
+    "join",
+    "json",
+    "justify-content",
+    "justifyContent",
+    "k1",
+    "k2",
+    "k3",
+    "k4",
+    "kernelMatrix",
+    "kernelUnitLengthX",
+    "kernelUnitLengthY",
+    "kerning",
+    "key",
+    "keyCode",
+    "keyFor",
+    "keyIdentifier",
+    "keyLightEnabled",
+    "keyLocation",
+    "keyPath",
+    "keySystem",
+    "keyText",
+    "keyUsage",
+    "keys",
+    "keytype",
+    "kind",
+    "knee",
+    "label",
+    "labels",
+    "lang",
+    "language",
+    "languages",
+    "largeArcFlag",
+    "lastChild",
+    "lastElementChild",
+    "lastEventId",
+    "lastIndex",
+    "lastIndexOf",
+    "lastMatch",
+    "lastMessageSubject",
+    "lastMessageType",
+    "lastModified",
+    "lastModifiedDate",
+    "lastPage",
+    "lastParen",
+    "lastState",
+    "lastStyleSheetSet",
+    "latitude",
+    "layerX",
+    "layerY",
+    "layoutFlow",
+    "layoutGrid",
+    "layoutGridChar",
+    "layoutGridLine",
+    "layoutGridMode",
+    "layoutGridType",
+    "lbound",
+    "left",
+    "leftContext",
+    "leftMargin",
+    "length",
+    "lengthAdjust",
+    "lengthComputable",
+    "letter-spacing",
+    "letterSpacing",
+    "level",
+    "lighting-color",
+    "lightingColor",
+    "limitingConeAngle",
+    "line",
+    "line-height",
+    "lineAlign",
+    "lineBreak",
+    "lineCap",
+    "lineDashOffset",
+    "lineHeight",
+    "lineJoin",
+    "lineNumber",
+    "lineTo",
+    "lineWidth",
+    "linearRampToValueAtTime",
+    "lineno",
+    "link",
+    "linkColor",
+    "linkProgram",
+    "links",
+    "list",
+    "list-style",
+    "list-style-image",
+    "list-style-position",
+    "list-style-type",
+    "listStyle",
+    "listStyleImage",
+    "listStylePosition",
+    "listStyleType",
+    "listener",
+    "load",
+    "loadEventEnd",
+    "loadEventStart",
+    "loadTimes",
+    "loaded",
+    "localDescription",
+    "localName",
+    "localStorage",
+    "locale",
+    "localeCompare",
+    "location",
+    "locationbar",
+    "lock",
+    "lockedFile",
+    "log",
+    "log10",
+    "log1p",
+    "log2",
+    "logicalXDPI",
+    "logicalYDPI",
+    "longDesc",
+    "longitude",
+    "lookupNamespaceURI",
+    "lookupPrefix",
+    "loop",
+    "loopEnd",
+    "loopStart",
+    "looping",
+    "low",
+    "lower",
+    "lowerBound",
+    "lowerOpen",
+    "lowsrc",
+    "m11",
+    "m12",
+    "m13",
+    "m14",
+    "m21",
+    "m22",
+    "m23",
+    "m24",
+    "m31",
+    "m32",
+    "m33",
+    "m34",
+    "m41",
+    "m42",
+    "m43",
+    "m44",
+    "manifest",
+    "map",
+    "mapping",
+    "margin",
+    "margin-bottom",
+    "margin-left",
+    "margin-right",
+    "margin-top",
+    "marginBottom",
+    "marginHeight",
+    "marginLeft",
+    "marginRight",
+    "marginTop",
+    "marginWidth",
+    "mark",
+    "marker",
+    "marker-end",
+    "marker-mid",
+    "marker-offset",
+    "marker-start",
+    "markerEnd",
+    "markerHeight",
+    "markerMid",
+    "markerOffset",
+    "markerStart",
+    "markerUnits",
+    "markerWidth",
+    "marks",
+    "mask",
+    "mask-type",
+    "maskContentUnits",
+    "maskType",
+    "maskUnits",
+    "match",
+    "matchMedia",
+    "matchMedium",
+    "matches",
+    "matrix",
+    "matrixTransform",
+    "max",
+    "max-height",
+    "max-width",
+    "maxAlternatives",
+    "maxChannelCount",
+    "maxConnectionsPerServer",
+    "maxDecibels",
+    "maxDistance",
+    "maxHeight",
+    "maxLength",
+    "maxTouchPoints",
+    "maxValue",
+    "maxWidth",
+    "measure",
+    "measureText",
+    "media",
+    "mediaDevices",
+    "mediaElement",
+    "mediaGroup",
+    "mediaKeys",
+    "mediaText",
+    "meetOrSlice",
+    "memory",
+    "menubar",
+    "mergeAttributes",
+    "message",
+    "messageClass",
+    "messageHandlers",
+    "metaKey",
+    "method",
+    "mimeType",
+    "mimeTypes",
+    "min",
+    "min-height",
+    "min-width",
+    "minDecibels",
+    "minHeight",
+    "minValue",
+    "minWidth",
+    "miterLimit",
+    "mix-blend-mode",
+    "mixBlendMode",
+    "mode",
+    "modify",
+    "mount",
+    "move",
+    "moveBy",
+    "moveEnd",
+    "moveFirst",
+    "moveFocusDown",
+    "moveFocusLeft",
+    "moveFocusRight",
+    "moveFocusUp",
+    "moveNext",
+    "moveRow",
+    "moveStart",
+    "moveTo",
+    "moveToBookmark",
+    "moveToElementText",
+    "moveToPoint",
+    "mozAdd",
+    "mozAnimationStartTime",
+    "mozAnon",
+    "mozApps",
+    "mozAudioCaptured",
+    "mozAudioChannelType",
+    "mozAutoplayEnabled",
+    "mozCancelAnimationFrame",
+    "mozCancelFullScreen",
+    "mozCancelRequestAnimationFrame",
+    "mozCaptureStream",
+    "mozCaptureStreamUntilEnded",
+    "mozClearDataAt",
+    "mozContact",
+    "mozContacts",
+    "mozCreateFileHandle",
+    "mozCurrentTransform",
+    "mozCurrentTransformInverse",
+    "mozCursor",
+    "mozDash",
+    "mozDashOffset",
+    "mozDecodedFrames",
+    "mozExitPointerLock",
+    "mozFillRule",
+    "mozFragmentEnd",
+    "mozFrameDelay",
+    "mozFullScreen",
+    "mozFullScreenElement",
+    "mozFullScreenEnabled",
+    "mozGetAll",
+    "mozGetAllKeys",
+    "mozGetAsFile",
+    "mozGetDataAt",
+    "mozGetMetadata",
+    "mozGetUserMedia",
+    "mozHasAudio",
+    "mozHasItem",
+    "mozHidden",
+    "mozImageSmoothingEnabled",
+    "mozIndexedDB",
+    "mozInnerScreenX",
+    "mozInnerScreenY",
+    "mozInputSource",
+    "mozIsTextField",
+    "mozItem",
+    "mozItemCount",
+    "mozItems",
+    "mozLength",
+    "mozLockOrientation",
+    "mozMatchesSelector",
+    "mozMovementX",
+    "mozMovementY",
+    "mozOpaque",
+    "mozOrientation",
+    "mozPaintCount",
+    "mozPaintedFrames",
+    "mozParsedFrames",
+    "mozPay",
+    "mozPointerLockElement",
+    "mozPresentedFrames",
+    "mozPreservesPitch",
+    "mozPressure",
+    "mozPrintCallback",
+    "mozRTCIceCandidate",
+    "mozRTCPeerConnection",
+    "mozRTCSessionDescription",
+    "mozRemove",
+    "mozRequestAnimationFrame",
+    "mozRequestFullScreen",
+    "mozRequestPointerLock",
+    "mozSetDataAt",
+    "mozSetImageElement",
+    "mozSourceNode",
+    "mozSrcObject",
+    "mozSystem",
+    "mozTCPSocket",
+    "mozTextStyle",
+    "mozTypesAt",
+    "mozUnlockOrientation",
+    "mozUserCancelled",
+    "mozVisibilityState",
+    "msAnimation",
+    "msAnimationDelay",
+    "msAnimationDirection",
+    "msAnimationDuration",
+    "msAnimationFillMode",
+    "msAnimationIterationCount",
+    "msAnimationName",
+    "msAnimationPlayState",
+    "msAnimationStartTime",
+    "msAnimationTimingFunction",
+    "msBackfaceVisibility",
+    "msBlockProgression",
+    "msCSSOMElementFloatMetrics",
+    "msCaching",
+    "msCachingEnabled",
+    "msCancelRequestAnimationFrame",
+    "msCapsLockWarningOff",
+    "msClearImmediate",
+    "msClose",
+    "msContentZoomChaining",
+    "msContentZoomFactor",
+    "msContentZoomLimit",
+    "msContentZoomLimitMax",
+    "msContentZoomLimitMin",
+    "msContentZoomSnap",
+    "msContentZoomSnapPoints",
+    "msContentZoomSnapType",
+    "msContentZooming",
+    "msConvertURL",
+    "msCrypto",
+    "msDoNotTrack",
+    "msElementsFromPoint",
+    "msElementsFromRect",
+    "msExitFullscreen",
+    "msExtendedCode",
+    "msFillRule",
+    "msFirstPaint",
+    "msFlex",
+    "msFlexAlign",
+    "msFlexDirection",
+    "msFlexFlow",
+    "msFlexItemAlign",
+    "msFlexLinePack",
+    "msFlexNegative",
+    "msFlexOrder",
+    "msFlexPack",
+    "msFlexPositive",
+    "msFlexPreferredSize",
+    "msFlexWrap",
+    "msFlowFrom",
+    "msFlowInto",
+    "msFontFeatureSettings",
+    "msFullscreenElement",
+    "msFullscreenEnabled",
+    "msGetInputContext",
+    "msGetRegionContent",
+    "msGetUntransformedBounds",
+    "msGraphicsTrustStatus",
+    "msGridColumn",
+    "msGridColumnAlign",
+    "msGridColumnSpan",
+    "msGridColumns",
+    "msGridRow",
+    "msGridRowAlign",
+    "msGridRowSpan",
+    "msGridRows",
+    "msHidden",
+    "msHighContrastAdjust",
+    "msHyphenateLimitChars",
+    "msHyphenateLimitLines",
+    "msHyphenateLimitZone",
+    "msHyphens",
+    "msImageSmoothingEnabled",
+    "msImeAlign",
+    "msIndexedDB",
+    "msInterpolationMode",
+    "msIsStaticHTML",
+    "msKeySystem",
+    "msKeys",
+    "msLaunchUri",
+    "msLockOrientation",
+    "msManipulationViewsEnabled",
+    "msMatchMedia",
+    "msMatchesSelector",
+    "msMaxTouchPoints",
+    "msOrientation",
+    "msOverflowStyle",
+    "msPerspective",
+    "msPerspectiveOrigin",
+    "msPlayToDisabled",
+    "msPlayToPreferredSourceUri",
+    "msPlayToPrimary",
+    "msPointerEnabled",
+    "msRegionOverflow",
+    "msReleasePointerCapture",
+    "msRequestAnimationFrame",
+    "msRequestFullscreen",
+    "msSaveBlob",
+    "msSaveOrOpenBlob",
+    "msScrollChaining",
+    "msScrollLimit",
+    "msScrollLimitXMax",
+    "msScrollLimitXMin",
+    "msScrollLimitYMax",
+    "msScrollLimitYMin",
+    "msScrollRails",
+    "msScrollSnapPointsX",
+    "msScrollSnapPointsY",
+    "msScrollSnapType",
+    "msScrollSnapX",
+    "msScrollSnapY",
+    "msScrollTranslation",
+    "msSetImmediate",
+    "msSetMediaKeys",
+    "msSetPointerCapture",
+    "msTextCombineHorizontal",
+    "msTextSizeAdjust",
+    "msToBlob",
+    "msTouchAction",
+    "msTouchSelect",
+    "msTraceAsyncCallbackCompleted",
+    "msTraceAsyncCallbackStarting",
+    "msTraceAsyncOperationCompleted",
+    "msTraceAsyncOperationStarting",
+    "msTransform",
+    "msTransformOrigin",
+    "msTransformStyle",
+    "msTransition",
+    "msTransitionDelay",
+    "msTransitionDuration",
+    "msTransitionProperty",
+    "msTransitionTimingFunction",
+    "msUnlockOrientation",
+    "msUpdateAsyncCallbackRelation",
+    "msUserSelect",
+    "msVisibilityState",
+    "msWrapFlow",
+    "msWrapMargin",
+    "msWrapThrough",
+    "msWriteProfilerMark",
+    "msZoom",
+    "msZoomTo",
+    "mt",
+    "multiEntry",
+    "multiSelectionObj",
+    "multiline",
+    "multiple",
+    "multiply",
+    "multiplySelf",
+    "mutableFile",
+    "muted",
+    "n",
+    "name",
+    "nameProp",
+    "namedItem",
+    "namedRecordset",
+    "names",
+    "namespaceURI",
+    "namespaces",
+    "naturalHeight",
+    "naturalWidth",
+    "navigate",
+    "navigation",
+    "navigationMode",
+    "navigationStart",
+    "navigator",
+    "near",
+    "nearestViewportElement",
+    "negative",
+    "netscape",
+    "networkState",
+    "newScale",
+    "newTranslate",
+    "newURL",
+    "newValue",
+    "newValueSpecifiedUnits",
+    "newVersion",
+    "newhome",
+    "next",
+    "nextElementSibling",
+    "nextNode",
+    "nextPage",
+    "nextSibling",
+    "nickname",
+    "noHref",
+    "noResize",
+    "noShade",
+    "noValidate",
+    "noWrap",
+    "nodeName",
+    "nodeType",
+    "nodeValue",
+    "normalize",
+    "normalizedPathSegList",
+    "notationName",
+    "notations",
+    "note",
+    "noteGrainOn",
+    "noteOff",
+    "noteOn",
+    "now",
+    "numOctaves",
+    "number",
+    "numberOfChannels",
+    "numberOfInputs",
+    "numberOfItems",
+    "numberOfOutputs",
+    "numberValue",
+    "oMatchesSelector",
+    "object",
+    "object-fit",
+    "object-position",
+    "objectFit",
+    "objectPosition",
+    "objectStore",
+    "objectStoreNames",
+    "observe",
+    "of",
+    "offscreenBuffering",
+    "offset",
+    "offsetHeight",
+    "offsetLeft",
+    "offsetNode",
+    "offsetParent",
+    "offsetTop",
+    "offsetWidth",
+    "offsetX",
+    "offsetY",
+    "ok",
+    "oldURL",
+    "oldValue",
+    "oldVersion",
+    "olderShadowRoot",
+    "onLine",
+    "onabort",
+    "onactivate",
+    "onactive",
+    "onaddstream",
+    "onaddtrack",
+    "onafterprint",
+    "onafterscriptexecute",
+    "onafterupdate",
+    "onaudioend",
+    "onaudioprocess",
+    "onaudiostart",
+    "onautocomplete",
+    "onautocompleteerror",
+    "onbeforeactivate",
+    "onbeforecopy",
+    "onbeforecut",
+    "onbeforedeactivate",
+    "onbeforeeditfocus",
+    "onbeforepaste",
+    "onbeforeprint",
+    "onbeforescriptexecute",
+    "onbeforeunload",
+    "onbeforeupdate",
+    "onblocked",
+    "onblur",
+    "onbounce",
+    "onboundary",
+    "oncached",
+    "oncancel",
+    "oncandidatewindowhide",
+    "oncandidatewindowshow",
+    "oncandidatewindowupdate",
+    "oncanplay",
+    "oncanplaythrough",
+    "oncellchange",
+    "onchange",
+    "onchargingchange",
+    "onchargingtimechange",
+    "onchecking",
+    "onclick",
+    "onclose",
+    "oncompassneedscalibration",
+    "oncomplete",
+    "oncontextmenu",
+    "oncontrolselect",
+    "oncopy",
+    "oncuechange",
+    "oncut",
+    "ondataavailable",
+    "ondatachannel",
+    "ondatasetchanged",
+    "ondatasetcomplete",
+    "ondblclick",
+    "ondeactivate",
+    "ondevicelight",
+    "ondevicemotion",
+    "ondeviceorientation",
+    "ondeviceproximity",
+    "ondischargingtimechange",
+    "ondisplay",
+    "ondownloading",
+    "ondrag",
+    "ondragend",
+    "ondragenter",
+    "ondragleave",
+    "ondragover",
+    "ondragstart",
+    "ondrop",
+    "ondurationchange",
+    "onemptied",
+    "onencrypted",
+    "onend",
+    "onended",
+    "onenter",
+    "onerror",
+    "onerrorupdate",
+    "onexit",
+    "onfilterchange",
+    "onfinish",
+    "onfocus",
+    "onfocusin",
+    "onfocusout",
+    "onfullscreenchange",
+    "onfullscreenerror",
+    "ongesturechange",
+    "ongestureend",
+    "ongesturestart",
+    "ongotpointercapture",
+    "onhashchange",
+    "onhelp",
+    "onicecandidate",
+    "oniceconnectionstatechange",
+    "oninactive",
+    "oninput",
+    "oninvalid",
+    "onkeydown",
+    "onkeypress",
+    "onkeyup",
+    "onlanguagechange",
+    "onlayoutcomplete",
+    "onlevelchange",
+    "onload",
+    "onloadeddata",
+    "onloadedmetadata",
+    "onloadend",
+    "onloadstart",
+    "onlosecapture",
+    "onlostpointercapture",
+    "only",
+    "onmark",
+    "onmessage",
+    "onmousedown",
+    "onmouseenter",
+    "onmouseleave",
+    "onmousemove",
+    "onmouseout",
+    "onmouseover",
+    "onmouseup",
+    "onmousewheel",
+    "onmove",
+    "onmoveend",
+    "onmovestart",
+    "onmozfullscreenchange",
+    "onmozfullscreenerror",
+    "onmozorientationchange",
+    "onmozpointerlockchange",
+    "onmozpointerlockerror",
+    "onmscontentzoom",
+    "onmsfullscreenchange",
+    "onmsfullscreenerror",
+    "onmsgesturechange",
+    "onmsgesturedoubletap",
+    "onmsgestureend",
+    "onmsgesturehold",
+    "onmsgesturestart",
+    "onmsgesturetap",
+    "onmsgotpointercapture",
+    "onmsinertiastart",
+    "onmslostpointercapture",
+    "onmsmanipulationstatechanged",
+    "onmsneedkey",
+    "onmsorientationchange",
+    "onmspointercancel",
+    "onmspointerdown",
+    "onmspointerenter",
+    "onmspointerhover",
+    "onmspointerleave",
+    "onmspointermove",
+    "onmspointerout",
+    "onmspointerover",
+    "onmspointerup",
+    "onmssitemodejumplistitemremoved",
+    "onmsthumbnailclick",
+    "onnegotiationneeded",
+    "onnomatch",
+    "onnoupdate",
+    "onobsolete",
+    "onoffline",
+    "ononline",
+    "onopen",
+    "onorientationchange",
+    "onpagechange",
+    "onpagehide",
+    "onpageshow",
+    "onpaste",
+    "onpause",
+    "onplay",
+    "onplaying",
+    "onpluginstreamstart",
+    "onpointercancel",
+    "onpointerdown",
+    "onpointerenter",
+    "onpointerleave",
+    "onpointerlockchange",
+    "onpointerlockerror",
+    "onpointermove",
+    "onpointerout",
+    "onpointerover",
+    "onpointerup",
+    "onpopstate",
+    "onprogress",
+    "onpropertychange",
+    "onratechange",
+    "onreadystatechange",
+    "onremovestream",
+    "onremovetrack",
+    "onreset",
+    "onresize",
+    "onresizeend",
+    "onresizestart",
+    "onresourcetimingbufferfull",
+    "onresult",
+    "onresume",
+    "onrowenter",
+    "onrowexit",
+    "onrowsdelete",
+    "onrowsinserted",
+    "onscroll",
+    "onsearch",
+    "onseeked",
+    "onseeking",
+    "onselect",
+    "onselectionchange",
+    "onselectstart",
+    "onshow",
+    "onsignalingstatechange",
+    "onsoundend",
+    "onsoundstart",
+    "onspeechend",
+    "onspeechstart",
+    "onstalled",
+    "onstart",
+    "onstatechange",
+    "onstop",
+    "onstorage",
+    "onstoragecommit",
+    "onsubmit",
+    "onsuccess",
+    "onsuspend",
+    "ontextinput",
+    "ontimeout",
+    "ontimeupdate",
+    "ontoggle",
+    "ontouchcancel",
+    "ontouchend",
+    "ontouchmove",
+    "ontouchstart",
+    "ontransitionend",
+    "onunload",
+    "onupdateready",
+    "onupgradeneeded",
+    "onuserproximity",
+    "onversionchange",
+    "onvoiceschanged",
+    "onvolumechange",
+    "onwaiting",
+    "onwarning",
+    "onwebkitanimationend",
+    "onwebkitanimationiteration",
+    "onwebkitanimationstart",
+    "onwebkitcurrentplaybacktargetiswirelesschanged",
+    "onwebkitfullscreenchange",
+    "onwebkitfullscreenerror",
+    "onwebkitkeyadded",
+    "onwebkitkeyerror",
+    "onwebkitkeymessage",
+    "onwebkitneedkey",
+    "onwebkitorientationchange",
+    "onwebkitplaybacktargetavailabilitychanged",
+    "onwebkitpointerlockchange",
+    "onwebkitpointerlockerror",
+    "onwebkitresourcetimingbufferfull",
+    "onwebkittransitionend",
+    "onwheel",
+    "onzoom",
+    "opacity",
+    "open",
+    "openCursor",
+    "openDatabase",
+    "openKeyCursor",
+    "opener",
+    "opera",
+    "operationType",
+    "operator",
+    "opr",
+    "optimum",
+    "options",
+    "order",
+    "orderX",
+    "orderY",
+    "ordered",
+    "org",
+    "orient",
+    "orientAngle",
+    "orientType",
+    "orientation",
+    "origin",
+    "originalTarget",
+    "orphans",
+    "oscpu",
+    "outerHTML",
+    "outerHeight",
+    "outerText",
+    "outerWidth",
+    "outline",
+    "outline-color",
+    "outline-offset",
+    "outline-style",
+    "outline-width",
+    "outlineColor",
+    "outlineOffset",
+    "outlineStyle",
+    "outlineWidth",
+    "outputBuffer",
+    "overflow",
+    "overflow-x",
+    "overflow-y",
+    "overflowX",
+    "overflowY",
+    "overrideMimeType",
+    "oversample",
+    "ownerDocument",
+    "ownerElement",
+    "ownerNode",
+    "ownerRule",
+    "ownerSVGElement",
+    "owningElement",
+    "p1",
+    "p2",
+    "p3",
+    "p4",
+    "pad",
+    "padding",
+    "padding-bottom",
+    "padding-left",
+    "padding-right",
+    "padding-top",
+    "paddingBottom",
+    "paddingLeft",
+    "paddingRight",
+    "paddingTop",
+    "page",
+    "page-break-after",
+    "page-break-before",
+    "page-break-inside",
+    "pageBreakAfter",
+    "pageBreakBefore",
+    "pageBreakInside",
+    "pageCount",
+    "pageX",
+    "pageXOffset",
+    "pageY",
+    "pageYOffset",
+    "pages",
+    "paint-order",
+    "paintOrder",
+    "paintRequests",
+    "paintType",
+    "palette",
+    "panningModel",
+    "parent",
+    "parentElement",
+    "parentNode",
+    "parentRule",
+    "parentStyleSheet",
+    "parentTextEdit",
+    "parentWindow",
+    "parse",
+    "parseFloat",
+    "parseFromString",
+    "parseInt",
+    "participants",
+    "password",
+    "pasteHTML",
+    "path",
+    "pathLength",
+    "pathSegList",
+    "pathSegType",
+    "pathSegTypeAsLetter",
+    "pathname",
+    "pattern",
+    "patternContentUnits",
+    "patternMismatch",
+    "patternTransform",
+    "patternUnits",
+    "pause",
+    "pauseAnimations",
+    "pauseOnExit",
+    "paused",
+    "pending",
+    "performance",
+    "permission",
+    "persisted",
+    "personalbar",
+    "perspective",
+    "perspective-origin",
+    "perspectiveOrigin",
+    "phoneticFamilyName",
+    "phoneticGivenName",
+    "photo",
+    "ping",
+    "pitch",
+    "pixelBottom",
+    "pixelDepth",
+    "pixelHeight",
+    "pixelLeft",
+    "pixelRight",
+    "pixelStorei",
+    "pixelTop",
+    "pixelUnitToMillimeterX",
+    "pixelUnitToMillimeterY",
+    "pixelWidth",
+    "placeholder",
+    "platform",
+    "play",
+    "playbackRate",
+    "playbackState",
+    "playbackTime",
+    "played",
+    "plugins",
+    "pluginspage",
+    "pname",
+    "pointer-events",
+    "pointerBeforeReferenceNode",
+    "pointerEnabled",
+    "pointerEvents",
+    "pointerId",
+    "pointerLockElement",
+    "pointerType",
+    "points",
+    "pointsAtX",
+    "pointsAtY",
+    "pointsAtZ",
+    "polygonOffset",
+    "pop",
+    "popupWindowFeatures",
+    "popupWindowName",
+    "popupWindowURI",
+    "port",
+    "port1",
+    "port2",
+    "ports",
+    "posBottom",
+    "posHeight",
+    "posLeft",
+    "posRight",
+    "posTop",
+    "posWidth",
+    "position",
+    "positionAlign",
+    "postError",
+    "postMessage",
+    "poster",
+    "pow",
+    "powerOff",
+    "preMultiplySelf",
+    "precision",
+    "preferredStyleSheetSet",
+    "preferredStylesheetSet",
+    "prefix",
+    "preload",
+    "preserveAlpha",
+    "preserveAspectRatio",
+    "preserveAspectRatioString",
+    "pressed",
+    "pressure",
+    "prevValue",
+    "preventDefault",
+    "preventExtensions",
+    "previousElementSibling",
+    "previousNode",
+    "previousPage",
+    "previousScale",
+    "previousSibling",
+    "previousTranslate",
+    "primaryKey",
+    "primitiveType",
+    "primitiveUnits",
+    "principals",
+    "print",
+    "privateKey",
+    "probablySupportsContext",
+    "process",
+    "processIceMessage",
+    "product",
+    "productSub",
+    "profile",
+    "profileEnd",
+    "profiles",
+    "prompt",
+    "properties",
+    "propertyIsEnumerable",
+    "propertyName",
+    "protocol",
+    "protocolLong",
+    "prototype",
+    "pseudoClass",
+    "pseudoElement",
+    "publicId",
+    "publicKey",
+    "published",
+    "push",
+    "pushNotification",
+    "pushState",
+    "put",
+    "putImageData",
+    "quadraticCurveTo",
+    "qualifier",
+    "queryCommandEnabled",
+    "queryCommandIndeterm",
+    "queryCommandState",
+    "queryCommandSupported",
+    "queryCommandText",
+    "queryCommandValue",
+    "querySelector",
+    "querySelectorAll",
+    "quote",
+    "quotes",
+    "r",
+    "r1",
+    "r2",
+    "race",
+    "radiogroup",
+    "radiusX",
+    "radiusY",
+    "random",
+    "range",
+    "rangeCount",
+    "rangeMax",
+    "rangeMin",
+    "rangeOffset",
+    "rangeOverflow",
+    "rangeParent",
+    "rangeUnderflow",
+    "rate",
+    "ratio",
+    "raw",
+    "read",
+    "readAsArrayBuffer",
+    "readAsBinaryString",
+    "readAsBlob",
+    "readAsDataURL",
+    "readAsText",
+    "readOnly",
+    "readPixels",
+    "readReportRequested",
+    "readyState",
+    "reason",
+    "reboot",
+    "receiver",
+    "receivers",
+    "recordNumber",
+    "recordset",
+    "rect",
+    "red",
+    "redirectCount",
+    "redirectEnd",
+    "redirectStart",
+    "reduce",
+    "reduceRight",
+    "reduction",
+    "refDistance",
+    "refX",
+    "refY",
+    "referenceNode",
+    "referrer",
+    "refresh",
+    "region",
+    "regionAnchorX",
+    "regionAnchorY",
+    "regionId",
+    "regions",
+    "register",
+    "registerContentHandler",
+    "registerElement",
+    "registerProtocolHandler",
+    "reject",
+    "rel",
+    "relList",
+    "relatedNode",
+    "relatedTarget",
+    "release",
+    "releaseCapture",
+    "releaseEvents",
+    "releasePointerCapture",
+    "releaseShaderCompiler",
+    "reliable",
+    "reload",
+    "remainingSpace",
+    "remoteDescription",
+    "remove",
+    "removeAllRanges",
+    "removeAttribute",
+    "removeAttributeNS",
+    "removeAttributeNode",
+    "removeBehavior",
+    "removeChild",
+    "removeCue",
+    "removeEventListener",
+    "removeFilter",
+    "removeImport",
+    "removeItem",
+    "removeListener",
+    "removeNamedItem",
+    "removeNamedItemNS",
+    "removeNode",
+    "removeParameter",
+    "removeProperty",
+    "removeRange",
+    "removeRegion",
+    "removeRule",
+    "removeSiteSpecificTrackingException",
+    "removeSourceBuffer",
+    "removeStream",
+    "removeTrack",
+    "removeVariable",
+    "removeWakeLockListener",
+    "removeWebWideTrackingException",
+    "removedNodes",
+    "renderbufferStorage",
+    "renderedBuffer",
+    "renderingMode",
+    "repeat",
+    "replace",
+    "replaceAdjacentText",
+    "replaceChild",
+    "replaceData",
+    "replaceId",
+    "replaceItem",
+    "replaceNode",
+    "replaceState",
+    "replaceTrack",
+    "replaceWholeText",
+    "reportValidity",
+    "requestAnimationFrame",
+    "requestAutocomplete",
+    "requestData",
+    "requestFullscreen",
+    "requestMediaKeySystemAccess",
+    "requestPermission",
+    "requestPointerLock",
+    "requestStart",
+    "requestingWindow",
+    "required",
+    "requiredExtensions",
+    "requiredFeatures",
+    "reset",
+    "resetTransform",
+    "resize",
+    "resizeBy",
+    "resizeTo",
+    "resolve",
+    "response",
+    "responseBody",
+    "responseEnd",
+    "responseStart",
+    "responseText",
+    "responseType",
+    "responseURL",
+    "responseXML",
+    "restore",
+    "result",
+    "resultType",
+    "resume",
+    "returnValue",
+    "rev",
+    "reverse",
+    "reversed",
+    "revocable",
+    "revokeObjectURL",
+    "rgbColor",
+    "right",
+    "rightContext",
+    "rightMargin",
+    "rolloffFactor",
+    "root",
+    "rootElement",
+    "rotate",
+    "rotateAxisAngle",
+    "rotateAxisAngleSelf",
+    "rotateFromVector",
+    "rotateFromVectorSelf",
+    "rotateSelf",
+    "rotation",
+    "rotationRate",
+    "round",
+    "rowIndex",
+    "rowSpan",
+    "rows",
+    "rubyAlign",
+    "rubyOverhang",
+    "rubyPosition",
+    "rules",
+    "runtime",
+    "runtimeStyle",
+    "rx",
+    "ry",
+    "safari",
+    "sampleCoverage",
+    "sampleRate",
+    "sandbox",
+    "save",
+    "scale",
+    "scale3d",
+    "scale3dSelf",
+    "scaleNonUniform",
+    "scaleNonUniformSelf",
+    "scaleSelf",
+    "scheme",
+    "scissor",
+    "scope",
+    "scopeName",
+    "scoped",
+    "screen",
+    "screenBrightness",
+    "screenEnabled",
+    "screenLeft",
+    "screenPixelToMillimeterX",
+    "screenPixelToMillimeterY",
+    "screenTop",
+    "screenX",
+    "screenY",
+    "scripts",
+    "scroll",
+    "scroll-behavior",
+    "scrollAmount",
+    "scrollBehavior",
+    "scrollBy",
+    "scrollByLines",
+    "scrollByPages",
+    "scrollDelay",
+    "scrollHeight",
+    "scrollIntoView",
+    "scrollIntoViewIfNeeded",
+    "scrollLeft",
+    "scrollLeftMax",
+    "scrollMaxX",
+    "scrollMaxY",
+    "scrollTo",
+    "scrollTop",
+    "scrollTopMax",
+    "scrollWidth",
+    "scrollX",
+    "scrollY",
+    "scrollbar3dLightColor",
+    "scrollbarArrowColor",
+    "scrollbarBaseColor",
+    "scrollbarDarkShadowColor",
+    "scrollbarFaceColor",
+    "scrollbarHighlightColor",
+    "scrollbarShadowColor",
+    "scrollbarTrackColor",
+    "scrollbars",
+    "scrolling",
+    "sdp",
+    "sdpMLineIndex",
+    "sdpMid",
+    "seal",
+    "search",
+    "searchBox",
+    "searchBoxJavaBridge_",
+    "searchParams",
+    "sectionRowIndex",
+    "secureConnectionStart",
+    "security",
+    "seed",
+    "seekable",
+    "seeking",
+    "select",
+    "selectAllChildren",
+    "selectNode",
+    "selectNodeContents",
+    "selectNodes",
+    "selectSingleNode",
+    "selectSubString",
+    "selected",
+    "selectedIndex",
+    "selectedOptions",
+    "selectedStyleSheetSet",
+    "selectedStylesheetSet",
+    "selection",
+    "selectionDirection",
+    "selectionEnd",
+    "selectionStart",
+    "selector",
+    "selectorText",
+    "self",
+    "send",
+    "sendAsBinary",
+    "sendBeacon",
+    "sender",
+    "sentTimestamp",
+    "separator",
+    "serializeToString",
+    "serviceWorker",
+    "sessionId",
+    "sessionStorage",
+    "set",
+    "setActive",
+    "setAlpha",
+    "setAttribute",
+    "setAttributeNS",
+    "setAttributeNode",
+    "setAttributeNodeNS",
+    "setBaseAndExtent",
+    "setBingCurrentSearchDefault",
+    "setCapture",
+    "setColor",
+    "setCompositeOperation",
+    "setCurrentTime",
+    "setCustomValidity",
+    "setData",
+    "setDate",
+    "setDragImage",
+    "setEnd",
+    "setEndAfter",
+    "setEndBefore",
+    "setEndPoint",
+    "setFillColor",
+    "setFilterRes",
+    "setFloat32",
+    "setFloat64",
+    "setFloatValue",
+    "setFullYear",
+    "setHours",
+    "setImmediate",
+    "setInt16",
+    "setInt32",
+    "setInt8",
+    "setInterval",
+    "setItem",
+    "setLineCap",
+    "setLineDash",
+    "setLineJoin",
+    "setLineWidth",
+    "setLocalDescription",
+    "setMatrix",
+    "setMatrixValue",
+    "setMediaKeys",
+    "setMilliseconds",
+    "setMinutes",
+    "setMiterLimit",
+    "setMonth",
+    "setNamedItem",
+    "setNamedItemNS",
+    "setNonUserCodeExceptions",
+    "setOrientToAngle",
+    "setOrientToAuto",
+    "setOrientation",
+    "setOverrideHistoryNavigationMode",
+    "setPaint",
+    "setParameter",
+    "setPeriodicWave",
+    "setPointerCapture",
+    "setPosition",
+    "setPreference",
+    "setProperty",
+    "setPrototypeOf",
+    "setRGBColor",
+    "setRGBColorICCColor",
+    "setRadius",
+    "setRangeText",
+    "setRemoteDescription",
+    "setRequestHeader",
+    "setResizable",
+    "setResourceTimingBufferSize",
+    "setRotate",
+    "setScale",
+    "setSeconds",
+    "setSelectionRange",
+    "setServerCertificate",
+    "setShadow",
+    "setSkewX",
+    "setSkewY",
+    "setStart",
+    "setStartAfter",
+    "setStartBefore",
+    "setStdDeviation",
+    "setStringValue",
+    "setStrokeColor",
+    "setSuggestResult",
+    "setTargetAtTime",
+    "setTargetValueAtTime",
+    "setTime",
+    "setTimeout",
+    "setTransform",
+    "setTranslate",
+    "setUTCDate",
+    "setUTCFullYear",
+    "setUTCHours",
+    "setUTCMilliseconds",
+    "setUTCMinutes",
+    "setUTCMonth",
+    "setUTCSeconds",
+    "setUint16",
+    "setUint32",
+    "setUint8",
+    "setUri",
+    "setValueAtTime",
+    "setValueCurveAtTime",
+    "setVariable",
+    "setVelocity",
+    "setVersion",
+    "setYear",
+    "settingName",
+    "settingValue",
+    "sex",
+    "shaderSource",
+    "shadowBlur",
+    "shadowColor",
+    "shadowOffsetX",
+    "shadowOffsetY",
+    "shadowRoot",
+    "shape",
+    "shape-rendering",
+    "shapeRendering",
+    "sheet",
+    "shift",
+    "shiftKey",
+    "shiftLeft",
+    "show",
+    "showHelp",
+    "showModal",
+    "showModalDialog",
+    "showModelessDialog",
+    "showNotification",
+    "sidebar",
+    "sign",
+    "signalingState",
+    "sin",
+    "singleNodeValue",
+    "sinh",
+    "size",
+    "sizeToContent",
+    "sizes",
+    "skewX",
+    "skewXSelf",
+    "skewY",
+    "skewYSelf",
+    "slice",
+    "slope",
+    "small",
+    "smil",
+    "smoothingTimeConstant",
+    "snapToLines",
+    "snapshotItem",
+    "snapshotLength",
+    "some",
+    "sort",
+    "source",
+    "sourceBuffer",
+    "sourceBuffers",
+    "sourceIndex",
+    "spacing",
+    "span",
+    "speakAs",
+    "speaking",
+    "specified",
+    "specularConstant",
+    "specularExponent",
+    "speechSynthesis",
+    "speed",
+    "speedOfSound",
+    "spellcheck",
+    "splice",
+    "split",
+    "splitText",
+    "spreadMethod",
+    "sqrt",
+    "src",
+    "srcElement",
+    "srcFilter",
+    "srcUrn",
+    "srcdoc",
+    "srclang",
+    "srcset",
+    "stack",
+    "stackTraceLimit",
+    "stacktrace",
+    "standalone",
+    "standby",
+    "start",
+    "startContainer",
+    "startIce",
+    "startOffset",
+    "startRendering",
+    "startTime",
+    "startsWith",
+    "state",
+    "status",
+    "statusMessage",
+    "statusText",
+    "statusbar",
+    "stdDeviationX",
+    "stdDeviationY",
+    "stencilFunc",
+    "stencilFuncSeparate",
+    "stencilMask",
+    "stencilMaskSeparate",
+    "stencilOp",
+    "stencilOpSeparate",
+    "step",
+    "stepDown",
+    "stepMismatch",
+    "stepUp",
+    "sticky",
+    "stitchTiles",
+    "stop",
+    "stop-color",
+    "stop-opacity",
+    "stopColor",
+    "stopImmediatePropagation",
+    "stopOpacity",
+    "stopPropagation",
+    "storageArea",
+    "storageName",
+    "storageStatus",
+    "storeSiteSpecificTrackingException",
+    "storeWebWideTrackingException",
+    "stpVersion",
+    "stream",
+    "strike",
+    "stringValue",
+    "stringify",
+    "stroke",
+    "stroke-dasharray",
+    "stroke-dashoffset",
+    "stroke-linecap",
+    "stroke-linejoin",
+    "stroke-miterlimit",
+    "stroke-opacity",
+    "stroke-width",
+    "strokeDasharray",
+    "strokeDashoffset",
+    "strokeLinecap",
+    "strokeLinejoin",
+    "strokeMiterlimit",
+    "strokeOpacity",
+    "strokeRect",
+    "strokeStyle",
+    "strokeText",
+    "strokeWidth",
+    "style",
+    "styleFloat",
+    "styleMedia",
+    "styleSheet",
+    "styleSheetSets",
+    "styleSheets",
+    "sub",
+    "subarray",
+    "subject",
+    "submit",
+    "subscribe",
+    "substr",
+    "substring",
+    "substringData",
+    "subtle",
+    "suffix",
+    "suffixes",
+    "summary",
+    "sup",
+    "supports",
+    "surfaceScale",
+    "surroundContents",
+    "suspend",
+    "suspendRedraw",
+    "swapCache",
+    "swapNode",
+    "sweepFlag",
+    "symbols",
+    "system",
+    "systemCode",
+    "systemId",
+    "systemLanguage",
+    "systemXDPI",
+    "systemYDPI",
+    "tBodies",
+    "tFoot",
+    "tHead",
+    "tabIndex",
+    "table",
+    "table-layout",
+    "tableLayout",
+    "tableValues",
+    "tag",
+    "tagName",
+    "tagUrn",
+    "tags",
+    "taintEnabled",
+    "takeRecords",
+    "tan",
+    "tanh",
+    "target",
+    "targetElement",
+    "targetTouches",
+    "targetX",
+    "targetY",
+    "tel",
+    "terminate",
+    "test",
+    "texImage2D",
+    "texParameterf",
+    "texParameteri",
+    "texSubImage2D",
+    "text",
+    "text-align",
+    "text-anchor",
+    "text-decoration",
+    "text-decoration-color",
+    "text-decoration-line",
+    "text-decoration-style",
+    "text-indent",
+    "text-overflow",
+    "text-rendering",
+    "text-shadow",
+    "text-transform",
+    "textAlign",
+    "textAlignLast",
+    "textAnchor",
+    "textAutospace",
+    "textBaseline",
+    "textContent",
+    "textDecoration",
+    "textDecorationBlink",
+    "textDecorationColor",
+    "textDecorationLine",
+    "textDecorationLineThrough",
+    "textDecorationNone",
+    "textDecorationOverline",
+    "textDecorationStyle",
+    "textDecorationUnderline",
+    "textIndent",
+    "textJustify",
+    "textJustifyTrim",
+    "textKashida",
+    "textKashidaSpace",
+    "textLength",
+    "textOverflow",
+    "textRendering",
+    "textShadow",
+    "textTracks",
+    "textTransform",
+    "textUnderlinePosition",
+    "then",
+    "threadId",
+    "threshold",
+    "tiltX",
+    "tiltY",
+    "time",
+    "timeEnd",
+    "timeStamp",
+    "timeout",
+    "timestamp",
+    "timestampOffset",
+    "timing",
+    "title",
+    "toArray",
+    "toBlob",
+    "toDataURL",
+    "toDateString",
+    "toElement",
+    "toExponential",
+    "toFixed",
+    "toFloat32Array",
+    "toFloat64Array",
+    "toGMTString",
+    "toISOString",
+    "toJSON",
+    "toLocaleDateString",
+    "toLocaleFormat",
+    "toLocaleLowerCase",
+    "toLocaleString",
+    "toLocaleTimeString",
+    "toLocaleUpperCase",
+    "toLowerCase",
+    "toMethod",
+    "toPrecision",
+    "toSdp",
+    "toSource",
+    "toStaticHTML",
+    "toString",
+    "toStringTag",
+    "toTimeString",
+    "toUTCString",
+    "toUpperCase",
+    "toggle",
+    "toggleLongPressEnabled",
+    "tooLong",
+    "toolbar",
+    "top",
+    "topMargin",
+    "total",
+    "totalFrameDelay",
+    "totalVideoFrames",
+    "touchAction",
+    "touches",
+    "trace",
+    "track",
+    "transaction",
+    "transactions",
+    "transform",
+    "transform-origin",
+    "transform-style",
+    "transformOrigin",
+    "transformPoint",
+    "transformString",
+    "transformStyle",
+    "transformToDocument",
+    "transformToFragment",
+    "transition",
+    "transition-delay",
+    "transition-duration",
+    "transition-property",
+    "transition-timing-function",
+    "transitionDelay",
+    "transitionDuration",
+    "transitionProperty",
+    "transitionTimingFunction",
+    "translate",
+    "translateSelf",
+    "translationX",
+    "translationY",
+    "trim",
+    "trimLeft",
+    "trimRight",
+    "trueSpeed",
+    "trunc",
+    "truncate",
+    "type",
+    "typeDetail",
+    "typeMismatch",
+    "typeMustMatch",
+    "types",
+    "ubound",
+    "undefined",
+    "unescape",
+    "uneval",
+    "unicode-bidi",
+    "unicodeBidi",
+    "uniform1f",
+    "uniform1fv",
+    "uniform1i",
+    "uniform1iv",
+    "uniform2f",
+    "uniform2fv",
+    "uniform2i",
+    "uniform2iv",
+    "uniform3f",
+    "uniform3fv",
+    "uniform3i",
+    "uniform3iv",
+    "uniform4f",
+    "uniform4fv",
+    "uniform4i",
+    "uniform4iv",
+    "uniformMatrix2fv",
+    "uniformMatrix3fv",
+    "uniformMatrix4fv",
+    "unique",
+    "uniqueID",
+    "uniqueNumber",
+    "unitType",
+    "units",
+    "unloadEventEnd",
+    "unloadEventStart",
+    "unlock",
+    "unmount",
+    "unobserve",
+    "unpause",
+    "unpauseAnimations",
+    "unreadCount",
+    "unregister",
+    "unregisterContentHandler",
+    "unregisterProtocolHandler",
+    "unscopables",
+    "unselectable",
+    "unshift",
+    "unsubscribe",
+    "unsuspendRedraw",
+    "unsuspendRedrawAll",
+    "unwatch",
+    "unwrapKey",
+    "update",
+    "updateCommands",
+    "updateIce",
+    "updateInterval",
+    "updateSettings",
+    "updated",
+    "updating",
+    "upload",
+    "upper",
+    "upperBound",
+    "upperOpen",
+    "uri",
+    "url",
+    "urn",
+    "urns",
+    "usages",
+    "useCurrentView",
+    "useMap",
+    "useProgram",
+    "usedSpace",
+    "userAgent",
+    "userLanguage",
+    "username",
+    "v8BreakIterator",
+    "vAlign",
+    "vLink",
+    "valid",
+    "validateProgram",
+    "validationMessage",
+    "validity",
+    "value",
+    "valueAsDate",
+    "valueAsNumber",
+    "valueAsString",
+    "valueInSpecifiedUnits",
+    "valueMissing",
+    "valueOf",
+    "valueText",
+    "valueType",
+    "values",
+    "vector-effect",
+    "vectorEffect",
+    "velocityAngular",
+    "velocityExpansion",
+    "velocityX",
+    "velocityY",
+    "vendor",
+    "vendorSub",
+    "verify",
+    "version",
+    "vertexAttrib1f",
+    "vertexAttrib1fv",
+    "vertexAttrib2f",
+    "vertexAttrib2fv",
+    "vertexAttrib3f",
+    "vertexAttrib3fv",
+    "vertexAttrib4f",
+    "vertexAttrib4fv",
+    "vertexAttribDivisorANGLE",
+    "vertexAttribPointer",
+    "vertical",
+    "vertical-align",
+    "verticalAlign",
+    "verticalOverflow",
+    "vibrate",
+    "videoHeight",
+    "videoTracks",
+    "videoWidth",
+    "view",
+    "viewBox",
+    "viewBoxString",
+    "viewTarget",
+    "viewTargetString",
+    "viewport",
+    "viewportAnchorX",
+    "viewportAnchorY",
+    "viewportElement",
+    "visibility",
+    "visibilityState",
+    "visible",
+    "vlinkColor",
+    "voice",
+    "volume",
+    "vrml",
+    "vspace",
+    "w",
+    "wand",
+    "warn",
+    "wasClean",
+    "watch",
+    "watchPosition",
+    "webdriver",
+    "webkitAddKey",
+    "webkitAnimation",
+    "webkitAnimationDelay",
+    "webkitAnimationDirection",
+    "webkitAnimationDuration",
+    "webkitAnimationFillMode",
+    "webkitAnimationIterationCount",
+    "webkitAnimationName",
+    "webkitAnimationPlayState",
+    "webkitAnimationTimingFunction",
+    "webkitAppearance",
+    "webkitAudioContext",
+    "webkitAudioDecodedByteCount",
+    "webkitAudioPannerNode",
+    "webkitBackfaceVisibility",
+    "webkitBackground",
+    "webkitBackgroundAttachment",
+    "webkitBackgroundClip",
+    "webkitBackgroundColor",
+    "webkitBackgroundImage",
+    "webkitBackgroundOrigin",
+    "webkitBackgroundPosition",
+    "webkitBackgroundPositionX",
+    "webkitBackgroundPositionY",
+    "webkitBackgroundRepeat",
+    "webkitBackgroundSize",
+    "webkitBackingStorePixelRatio",
+    "webkitBorderImage",
+    "webkitBorderImageOutset",
+    "webkitBorderImageRepeat",
+    "webkitBorderImageSlice",
+    "webkitBorderImageSource",
+    "webkitBorderImageWidth",
+    "webkitBoxAlign",
+    "webkitBoxDirection",
+    "webkitBoxFlex",
+    "webkitBoxOrdinalGroup",
+    "webkitBoxOrient",
+    "webkitBoxPack",
+    "webkitBoxSizing",
+    "webkitCancelAnimationFrame",
+    "webkitCancelFullScreen",
+    "webkitCancelKeyRequest",
+    "webkitCancelRequestAnimationFrame",
+    "webkitClearResourceTimings",
+    "webkitClosedCaptionsVisible",
+    "webkitConvertPointFromNodeToPage",
+    "webkitConvertPointFromPageToNode",
+    "webkitCreateShadowRoot",
+    "webkitCurrentFullScreenElement",
+    "webkitCurrentPlaybackTargetIsWireless",
+    "webkitDirectionInvertedFromDevice",
+    "webkitDisplayingFullscreen",
+    "webkitEnterFullScreen",
+    "webkitEnterFullscreen",
+    "webkitExitFullScreen",
+    "webkitExitFullscreen",
+    "webkitExitPointerLock",
+    "webkitFullScreenKeyboardInputAllowed",
+    "webkitFullscreenElement",
+    "webkitFullscreenEnabled",
+    "webkitGenerateKeyRequest",
+    "webkitGetAsEntry",
+    "webkitGetDatabaseNames",
+    "webkitGetEntries",
+    "webkitGetEntriesByName",
+    "webkitGetEntriesByType",
+    "webkitGetFlowByName",
+    "webkitGetGamepads",
+    "webkitGetImageDataHD",
+    "webkitGetNamedFlows",
+    "webkitGetRegionFlowRanges",
+    "webkitGetUserMedia",
+    "webkitHasClosedCaptions",
+    "webkitHidden",
+    "webkitIDBCursor",
+    "webkitIDBDatabase",
+    "webkitIDBDatabaseError",
+    "webkitIDBDatabaseException",
+    "webkitIDBFactory",
+    "webkitIDBIndex",
+    "webkitIDBKeyRange",
+    "webkitIDBObjectStore",
+    "webkitIDBRequest",
+    "webkitIDBTransaction",
+    "webkitImageSmoothingEnabled",
+    "webkitIndexedDB",
+    "webkitInitMessageEvent",
+    "webkitIsFullScreen",
+    "webkitKeys",
+    "webkitLineDashOffset",
+    "webkitLockOrientation",
+    "webkitMatchesSelector",
+    "webkitMediaStream",
+    "webkitNotifications",
+    "webkitOfflineAudioContext",
+    "webkitOrientation",
+    "webkitPeerConnection00",
+    "webkitPersistentStorage",
+    "webkitPointerLockElement",
+    "webkitPostMessage",
+    "webkitPreservesPitch",
+    "webkitPutImageDataHD",
+    "webkitRTCPeerConnection",
+    "webkitRegionOverset",
+    "webkitRequestAnimationFrame",
+    "webkitRequestFileSystem",
+    "webkitRequestFullScreen",
+    "webkitRequestFullscreen",
+    "webkitRequestPointerLock",
+    "webkitResolveLocalFileSystemURL",
+    "webkitSetMediaKeys",
+    "webkitSetResourceTimingBufferSize",
+    "webkitShadowRoot",
+    "webkitShowPlaybackTargetPicker",
+    "webkitSlice",
+    "webkitSpeechGrammar",
+    "webkitSpeechGrammarList",
+    "webkitSpeechRecognition",
+    "webkitSpeechRecognitionError",
+    "webkitSpeechRecognitionEvent",
+    "webkitStorageInfo",
+    "webkitSupportsFullscreen",
+    "webkitTemporaryStorage",
+    "webkitTextSizeAdjust",
+    "webkitTransform",
+    "webkitTransformOrigin",
+    "webkitTransition",
+    "webkitTransitionDelay",
+    "webkitTransitionDuration",
+    "webkitTransitionProperty",
+    "webkitTransitionTimingFunction",
+    "webkitURL",
+    "webkitUnlockOrientation",
+    "webkitUserSelect",
+    "webkitVideoDecodedByteCount",
+    "webkitVisibilityState",
+    "webkitWirelessVideoPlaybackDisabled",
+    "webkitdropzone",
+    "webstore",
+    "weight",
+    "whatToShow",
+    "wheelDelta",
+    "wheelDeltaX",
+    "wheelDeltaY",
+    "which",
+    "white-space",
+    "whiteSpace",
+    "wholeText",
+    "widows",
+    "width",
+    "will-change",
+    "willChange",
+    "willValidate",
+    "window",
+    "withCredentials",
+    "word-break",
+    "word-spacing",
+    "word-wrap",
+    "wordBreak",
+    "wordSpacing",
+    "wordWrap",
+    "wrap",
+    "wrapKey",
+    "write",
+    "writeln",
+    "writingMode",
+    "x",
+    "x1",
+    "x2",
+    "xChannelSelector",
+    "xmlEncoding",
+    "xmlStandalone",
+    "xmlVersion",
+    "xmlbase",
+    "xmllang",
+    "xmlspace",
+    "y",
+    "y1",
+    "y2",
+    "yChannelSelector",
+    "yandex",
+    "z",
+    "z-index",
+    "zIndex",
+    "zoom",
+    "zoomAndPan",
+    "zoomRectScreen"
+]
diff --git a/node_modules/uglify-js/tools/exports.js b/node_modules/uglify-js/tools/exports.js
index 09acc13ec..e08296f36 100644
--- a/node_modules/uglify-js/tools/exports.js
+++ b/node_modules/uglify-js/tools/exports.js
@@ -1,19 +1,5 @@
-exports["Compressor"] = Compressor;
-exports["DefaultsError"] = DefaultsError;
 exports["Dictionary"] = Dictionary;
-exports["JS_Parse_Error"] = JS_Parse_Error;
-exports["MAP"] = MAP;
-exports["OutputStream"] = OutputStream;
-exports["SourceMap"] = SourceMap;
-exports["TreeTransformer"] = TreeTransformer;
 exports["TreeWalker"] = TreeWalker;
-exports["base54"] = base54;
-exports["defaults"] = defaults;
-exports["mangle_properties"] = mangle_properties;
-exports["merge"] = merge;
-exports["parse"] = parse;
-exports["push_uniq"] = push_uniq;
-exports["string_template"] = string_template;
-exports["tokenizer"] = tokenizer;
-exports["is_identifier"] = is_identifier;
-exports["SymbolDef"] = SymbolDef;
+exports["TreeTransformer"] = TreeTransformer;
+exports["minify"] = minify;
+exports["_push_uniq"] = push_uniq;
diff --git a/node_modules/uglify-js/tools/node.js b/node_modules/uglify-js/tools/node.js
index 147751aeb..dc2701060 100644
--- a/node_modules/uglify-js/tools/node.js
+++ b/node_modules/uglify-js/tools/node.js
@@ -1,10 +1,3 @@
-// workaround for tty output truncation upon process.exit()
-[process.stdout, process.stderr].forEach(function(stream){
-    if (stream._handle && stream._handle.setBlocking)
-        stream._handle.setBlocking(true);
-});
-
-var path = require("path");
 var fs = require("fs");
 
 var UglifyJS = exports;
@@ -19,182 +12,25 @@ var FILES = UglifyJS.FILES = [
     "../lib/sourcemap.js",
     "../lib/mozilla-ast.js",
     "../lib/propmangle.js",
+    "../lib/minify.js",
     "./exports.js",
 ].map(function(file){
     return require.resolve(file);
 });
 
-new Function("MOZ_SourceMap", "exports", FILES.map(function(file){
-    return fs.readFileSync(file, "utf8");
-}).join("\n\n"))(
+new Function("MOZ_SourceMap", "exports", function() {
+    var code = FILES.map(function(file) {
+        return fs.readFileSync(file, "utf8");
+    });
+    code.push("exports.describe_ast = " + describe_ast.toString());
+    return code.join("\n\n");
+}())(
     require("source-map"),
     UglifyJS
 );
 
-UglifyJS.AST_Node.warn_function = function(txt) {
-    console.error("WARN: %s", txt);
-};
-
-function read_source_map(code) {
-    var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
-    if (!match) {
-        UglifyJS.AST_Node.warn("inline source map not found");
-        return null;
-    }
-    return JSON.parse(new Buffer(match[2], "base64"));
-}
-
-UglifyJS.minify = function(files, options) {
-    options = UglifyJS.defaults(options, {
-        compress         : {},
-        fromString       : false,
-        inSourceMap      : null,
-        mangle           : {},
-        mangleProperties : false,
-        nameCache        : null,
-        outFileName      : null,
-        output           : null,
-        outSourceMap     : null,
-        parse            : {},
-        sourceMapInline  : false,
-        sourceMapUrl     : null,
-        sourceRoot       : null,
-        spidermonkey     : false,
-        warnings         : false,
-    });
-    UglifyJS.base54.reset();
-
-    var inMap = options.inSourceMap;
-    if (typeof inMap == "string" && inMap != "inline") {
-        inMap = JSON.parse(fs.readFileSync(inMap, "utf8"));
-    }
-
-    // 1. parse
-    var toplevel = null,
-        sourcesContent = {};
-
-    if (options.spidermonkey) {
-        if (inMap == "inline") {
-            throw new Error("inline source map only works with built-in parser");
-        }
-        toplevel = UglifyJS.AST_Node.from_mozilla_ast(files);
-    } else {
-        function addFile(file, fileUrl) {
-            var code = options.fromString
-                ? file
-                : fs.readFileSync(file, "utf8");
-            if (inMap == "inline") {
-                inMap = read_source_map(code);
-            }
-            sourcesContent[fileUrl] = code;
-            toplevel = UglifyJS.parse(code, {
-                filename: fileUrl,
-                toplevel: toplevel,
-                bare_returns: options.parse ? options.parse.bare_returns : undefined
-            });
-        }
-        if (!options.fromString) {
-            files = UglifyJS.simple_glob(files);
-            if (inMap == "inline" && files.length > 1) {
-                throw new Error("inline source map only works with singular input");
-            }
-        }
-        [].concat(files).forEach(function (files, i) {
-            if (typeof files === 'string') {
-                addFile(files, options.fromString ? i : files);
-            } else {
-                for (var fileUrl in files) {
-                    addFile(files[fileUrl], fileUrl);
-                }
-            }
-        });
-    }
-    if (options.wrap) {
-      toplevel = toplevel.wrap_commonjs(options.wrap, options.exportAll);
-    }
-
-    // 2. compress
-    if (options.compress) {
-        var compress = { warnings: options.warnings };
-        UglifyJS.merge(compress, options.compress);
-        toplevel.figure_out_scope(options.mangle);
-        var sq = UglifyJS.Compressor(compress);
-        toplevel = sq.compress(toplevel);
-    }
-
-    // 3. mangle properties
-    if (options.mangleProperties || options.nameCache) {
-        options.mangleProperties.cache = UglifyJS.readNameCache(options.nameCache, "props");
-        toplevel = UglifyJS.mangle_properties(toplevel, options.mangleProperties);
-        UglifyJS.writeNameCache(options.nameCache, "props", options.mangleProperties.cache);
-    }
-
-    // 4. mangle
-    if (options.mangle) {
-        toplevel.figure_out_scope(options.mangle);
-        toplevel.compute_char_frequency(options.mangle);
-        toplevel.mangle_names(options.mangle);
-    }
-
-    // 5. output
-    var output = { max_line_len: 32000 };
-    if (options.outSourceMap || options.sourceMapInline) {
-        output.source_map = UglifyJS.SourceMap({
-            // prefer outFileName, otherwise use outSourceMap without .map suffix
-            file: options.outFileName || (typeof options.outSourceMap === 'string' ? options.outSourceMap.replace(/\.map$/i, '') : null),
-            orig: inMap,
-            root: options.sourceRoot
-        });
-        if (options.sourceMapIncludeSources) {
-            for (var file in sourcesContent) {
-                if (sourcesContent.hasOwnProperty(file)) {
-                    output.source_map.get().setSourceContent(file, sourcesContent[file]);
-                }
-            }
-        }
-
-    }
-    if (options.output) {
-        UglifyJS.merge(output, options.output);
-    }
-    var stream = UglifyJS.OutputStream(output);
-    toplevel.print(stream);
-
-
-    var source_map = output.source_map;
-    if (source_map) {
-        source_map = source_map + "";
-    }
-
-    var mappingUrlPrefix = "\n//# sourceMappingURL=";
-    if (options.sourceMapInline) {
-        stream += mappingUrlPrefix + "data:application/json;charset=utf-8;base64," + new Buffer(source_map).toString("base64");
-    } else if (options.outSourceMap && typeof options.outSourceMap === "string" && options.sourceMapUrl !== false) {
-        stream += mappingUrlPrefix + (typeof options.sourceMapUrl === "string" ? options.sourceMapUrl : options.outSourceMap);
-    }
-
-    return {
-        code : stream + "",
-        map  : source_map
-    };
-};
-
-// UglifyJS.describe_ast = function() {
-//     function doitem(ctor) {
-//         var sub = {};
-//         ctor.SUBCLASSES.forEach(function(ctor){
-//             sub[ctor.TYPE] = doitem(ctor);
-//         });
-//         var ret = {};
-//         if (ctor.SELF_PROPS.length > 0) ret.props = ctor.SELF_PROPS;
-//         if (ctor.SUBCLASSES.length > 0) ret.sub = sub;
-//         return ret;
-//     }
-//     return doitem(UglifyJS.AST_Node).sub;
-// }
-
-UglifyJS.describe_ast = function() {
-    var out = UglifyJS.OutputStream({ beautify: true });
+function describe_ast() {
+    var out = OutputStream({ beautify: true });
     function doitem(ctor) {
         out.print("AST_" + ctor.TYPE);
         var props = ctor.SELF_PROPS.filter(function(prop){
@@ -224,97 +60,23 @@ UglifyJS.describe_ast = function() {
             });
         }
     };
-    doitem(UglifyJS.AST_Node);
-    return out + "";
-};
-
-function readReservedFile(filename, reserved) {
-    if (!reserved) {
-        reserved = { vars: [], props: [] };
-    }
-    var data = fs.readFileSync(filename, "utf8");
-    data = JSON.parse(data);
-    if (data.vars) {
-        data.vars.forEach(function(name){
-            UglifyJS.push_uniq(reserved.vars, name);
-        });
-    }
-    if (data.props) {
-        data.props.forEach(function(name){
-            UglifyJS.push_uniq(reserved.props, name);
-        });
-    }
-    return reserved;
+    doitem(AST_Node);
+    return out + "\n";
 }
 
-UglifyJS.readReservedFile = readReservedFile;
-
-UglifyJS.readDefaultReservedFile = function(reserved) {
-    return readReservedFile(require.resolve("./domprops.json"), reserved);
-};
-
-UglifyJS.readNameCache = function(filename, key) {
-    var cache = null;
-    if (filename) {
-        try {
-            var cache = fs.readFileSync(filename, "utf8");
-            cache = JSON.parse(cache)[key];
-            if (!cache) throw "init";
-            cache.props = UglifyJS.Dictionary.fromObject(cache.props);
-        } catch(ex) {
-            cache = {
-                cname: -1,
-                props: new UglifyJS.Dictionary()
-            };
-        }
-    }
-    return cache;
-};
-
-UglifyJS.writeNameCache = function(filename, key, cache) {
-    if (filename) {
-        var data;
-        try {
-            data = fs.readFileSync(filename, "utf8");
-            data = JSON.parse(data);
-        } catch(ex) {
-            data = {};
-        }
-        data[key] = {
-            cname: cache.cname,
-            props: cache.props.toObject()
-        };
-        fs.writeFileSync(filename, JSON.stringify(data, null, 2), "utf8");
-    }
-};
+function infer_options(options) {
+    var result = UglifyJS.minify("", options);
+    return result.error && result.error.defs;
+}
 
-// A file glob function that only supports "*" and "?" wildcards in the basename.
-// Example: "foo/bar/*baz??.*.js"
-// Argument `glob` may be a string or an array of strings.
-// Returns an array of strings. Garbage in, garbage out.
-UglifyJS.simple_glob = function simple_glob(glob) {
-    if (Array.isArray(glob)) {
-        return [].concat.apply([], glob.map(simple_glob));
-    }
-    if (glob.match(/\*|\?/)) {
-        var dir = path.dirname(glob);
-        try {
-            var entries = fs.readdirSync(dir);
-        } catch (ex) {}
-        if (entries) {
-            var pattern = "^" + path.basename(glob)
-                .replace(/[.+^$[\]\\(){}]/g, "\\$&")
-                .replace(/\*/g, "[^/\\\\]*")
-                .replace(/\?/g, "[^/\\\\]") + "$";
-            var mod = process.platform === "win32" ? "i" : "";
-            var rx = new RegExp(pattern, mod);
-            var results = entries.filter(function(name) {
-                return rx.test(name);
-            }).map(function(name) {
-                return path.join(dir, name);
-            });
-            if (results.length) return results;
+UglifyJS.default_options = function() {
+    var defs = {};
+    Object.keys(infer_options({ 0: 0 })).forEach(function(component) {
+        var options = {};
+        options[component] = { 0: 0 };
+        if (options = infer_options(options)) {
+            defs[component] = options;
         }
-    }
-    return [ glob ];
+    });
+    return defs;
 };