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

join_vars:

var XXX;
for (var YYY; ...)

==>

for (var XXX,YYY; ...)

compress typeof x == "undefined" to x === undefined, which further gets
shortened to x === void 0 (or x === [][0] in unsafe mode)

minor

when unsafe, compress undefined as [][0]

adding an imaginary "return undefined" can sometimes help

function f() {
  if (foo) return x();
  if (!bar) return y();
}

==>

function f() {
  return foo ? x() : bar ? void 0 : y();
}

more optimizations that v1 does and some cleanups

- a = a + x ==> a+=x
- joining consecutive var statements (hoisting is not always desirable)
- x == false ==> x == 0, x != true ==> x != 1
- x, x ==> x; x = exp(), x ==> x = exp()
- discarding useless break-s

added -m and -c options

few more optimizations:

- do multiple passes in tighten_body if it was changed
- transform if (foo) return x; return y; ==> return foo?x:y
- don't optimize !0 as true (use best_of after evaluation of constant expr)

With hoist_vars off we now beat UglifyJS v1 on jQuery-1.8.1

minor

more AST_If optimizations

side effect fixes and small optimization for gzip

prefer to always use > and >= operators (idea from Closure)

fixed run-tests and an issue about reversing the condition in AST_If

minor

fixed some mess with symbols/scope

- all symbols now have a `thedef` property which is a SymbolDef object,
  instead of the `uniq` that we had before (pointing to the first occurrence
  of the name as declaration).

- for undeclared symbols we still create a SymbolDef object in the toplevel
  scope but mark it "undeclared"

- we can now call figure_out_scope after squeezing, which is useful in order
  not to mangle names that were dropped by the squeezer

checkpoint

- discard statements with no side effects (unsafe? could be)
- safer hoist_vars (needs some revamping of scope/mangling)

hoist_vars is pretty bad, it seems.  cancelled it for now.

adaptive base54 digits depending on char frequency (WIP)

more progress on the compressor (WIP)

fix "file" in the source map

minor

fix output for division followed by regexp

( v1 report: https://github.com/mishoo/UglifyJS/pull/458 )

checkpoint

fix bug (forgot arg name)

always keep declarations found in unreachable code

a few more tests and some cleanups.