disable warnings by default in `minify` (pass warnings: true to enable)

close #11

fix node name

seems cleaner if AST_Label doesn't inherit from AST_SymbolDeclaration

small improvements in wrap_commonjs:

- use MAP.splice instead of a BlockStatement to inject code (avoids some
  warnings in the linter)
- use the original symbol in exports, so that we get the proper source mapping

drop unused variable

add `--lint` and display {file} in scope_warnings

minor

update on @cc_on

add AST_Infinity node

make `--comments` keep @cc_on too

added $propdoc to AST nodes and some cleanups

hopefully we can make the AST documentation self-generating

minor AST cleanup (AST_BlockStatement may inherit from AST_Block)

add `--ast-help`

displays a rather cruel description of the AST classes, derived
directly from the node definitions.

fix detecting symbols in use

Merge pull request #8 from SevInf/master

Fix crash in minify function

Fix nodejs minify without inSourceMap exception

When inSourceMap is omitted fs.readFile throws exception. Fixed version
calls fs.readFile only when inSourceMap argument is present

fix `inSourceMap` in `minify` (should read the file)

add simple API wrapper: UglifyJS.minify

(refs #7)

added some basic API doc

should not expose base54.sort() in the API docs, I think

added --self to easily get a browser-runnable version of UglifyJS

eliminate redundant directives in the same scope

for certain nodes that we invent we might not have a original source file to
map from, so just use "?".  and in any case, don't fail hard when addMapping throws.

fix typo

remove unused code

minor

replace `(function(){ ...no side effects ... })()` with `undefined`.

prevent mangling only when eval is *called*, not when it's just referenced

add note about installation

added --acorn and --spidermonkey options

fixed import of locations from SpiderMonkey AST

use the appropriate constructor for symbols

minor

removed some unused variables

moving code around

define AST_Node.from_mozilla_ast(ast)

returns an UglifyJS2 AST given a Mozilla AST.  Still needs some work to do
(need to create specific nodes like AST_SymbolRef, AST_SymbolLambda
etc. instead of base AST_Symbol, in order for the mangler/compressor to work
properly)

ignore tmp/

more cleanup (dropped AST_SwitchBlock)

AST cleanup (dropped AST_StatementBase)

added package.json

added option for side-effect-free statements, fix test

fix endless loop in tests

drop tmp. files

document the CLI tool

fix for `a = !b && !c && !d && !e → a=!(b||c||d||e)`

disable `hoist_vars` by default and change `comparations` to `comparisons`

fixed usage string

support for `--comments` option to keep comments containing @license or @preserve

discard annoying nodejs warning

line numbers start at 1

added option to keep some comments in the output

option to exclude certain names from mangling

support defines

"use strict";

more constant folding (for names defined with `const`)

add AST_SymbolConst for names defined with `const`

drop more unused names

a shy attempt to obey `width` in the beautifier; added `bracketize` option to always print brackets around if/do/while/for statements; export more options via the CLI

minor

fix mangling

(bug in our code prevented the mangler from using a name that was in use
prior to mangling but not after it)

removed the "squeeze" method (it's now effectively "transform")

some speedup and more savings from unused vars that have side effects in initialization

compressor successfully moved to TreeTransformer

checkpoint (refactoring, WIP)

minor

more cleanups

moving code around (refactoring, WIP)

discard all \uFEFF characters (https://github.com/mishoo/UglifyJS/issues/462)

started some refactoring (WIP) -- moving squeezer to TreeTransformer

minor

it's not safe to assume that property access is side-effect-free

(getters/setters + various browser bugs will trigger side effects; also, an
exception is thrown when the expression is undefined)

some boolean cleanup

Support input source map

This is useful while compressing generated code; for example compressing JS
compiled by CoffeeScript (assuming you got a source map):

    uglifyjs2 --in-source-map generated.js.map \
              --source-map uglified.js.map \
              -o uglified.js

The above assumes you have a "generated.js.map" file which is the source
mapping between your CoffeeScript and the generated.js (compiled output from
CoffeeScript).  The name of the input file is not present in this example;
it will be fetched from the source map (but it can be passed manually too).

The output will be in "uglified.js" and the output map "uglified.js.map"
will actually map to the original CoffeeScript code, rather than to
generated.js.

minor tests fix

properly drop mutually-referring declarations that are not otherwise
referenced and have no side effects

tree transformer api (WIP)

log filename in parse errors / compressor warnings

better support for multiple input files:

- use a single AST_Toplevel node for all files
- keep original source filename in the tokens

more on detecting side effects

drop unused variables

support -c with no arguments to disable compression entirely

fixed label scope/mangling

minor

support for directives

added AST_NaN (output as 0/0)

only do the typeof x == "undefined" optimization if x is a symbol reference and it's declared in scope, or x is not a symbol reference.

moved `typeof foo == "undefined"` ==> `foo === undefined` under `--unsafe`

because https://github.com/mishoo/UglifyJS2/commit/43fd45154bac89b89330e13bd1f167e2a927a23c#commitcomment-1864505

fix .undeclared (it's now a function)

minor

one more test for sequences

possible optimization for AST_Undefined

if undefined is defined, ;-), we replace AST_Undefined nodes to a reference
to the "undefined" variable; in turn the mangler will compress it to a
single letter; this helps at least on jQuery.

empty block to empty statement: {} ==> ;

more smallish optimizations

try negating AST_Binary

some cleanup

more sequencesizing (WIP)

drop unused function

rewrite handle_if_return

optimizations of if/return/continue seem to be even better now

other small optimization:

if (foo) continue;
...body...

==>

if (!foo) { ...body ... }

Only when the parent block is the target loop of the `continue` statement.

figure out label targets