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.

fixed tests (need to drop the toplevel block in "expected" if it's a single statement)

don't duplicate argument names

declared `--stats` as boolean

fix for variable names like `toString`

support for hoisting declarations

and finally it seems we beat v1 in terms of compression

cleaned up usage of AST_BlockStatement

The following nodes were instances of AST_BlockStatement: AST_Scope,
AST_SwitchBlock, AST_SwitchBranch.  Also, AST_Try, AST_Catch, AST_Finally
were having a body instanceof AST_BlockStatement.

Overloading the meaning of AST_BlockStatement this way turned out to be a
mess; we now have an AST_Block class that is the base class for things
having a block of statements (might or might not be bracketed).  The
`this.body` of AST_Scope, AST_Try, AST_Catch, AST_Finally is now an array of
statements (as they inherit from AST_Block).

Avoiding calling superclass's _walk function in walkers (turns out we walked
a node multiple times).

checkpoint

more fiddling with boolean expressions, etc.

optimize away while(false), and transform while(true) ==> for(;;).

UNSAFE:

some expressions are optimized away when we're in boolean context and can
determine that the value will always be true or false.  For example:

    x() || true ==> always `true` in boolean context
    x() && false ==> always `false` in boolean context

It's not technically correct to drop these expressions since we drop the
function call too (that might have side effects); on the other hand, I can't
see any legitimate use for such expressions and they might simply indicate a
bug (we do warn about it).

if present, the `else` in an `if` should always be forced statement

boolean and if/exit optimizations

minor

more optimizations for ifs/conditionals

(XXX: should add tests before anything else)

resolve constant expressions

jumps, try and definitions are statements too

an AST_If is too a StatementWithBody

a LabeledStatement should be in fact a StatementWithBody

This fixes output for:

    if (foo) {
        moo: if (bar) {
            break moo;
        }
    } else {
        baz();
    }

(the labeled statement must be outputted inside brackets)

declare boolean options

switch branches must be declared `required` so that the compressor doesn't
replace nodes with a single statement.

looks stable for now, though mess begins to sink in.  need to review the AST
hierarchy.

Reverting "minor perf. improvements"
Revert "minor perf. improvements"

This reverts commit 24bfd55a22afd791d4a97694641831cfbd27fb14.

broke the parser somehow; too early to optimize, let's get the other stuff running.

add -b

add source mappings for more node types; started CLI utility

minor perf. improvements

started support for generating source maps (WIP)

plugged in @fitzgen's source-map library

don't mangle names of setters/getters

update with link to discussion about Esprima vs. UglifyJS speed

docstring for AST_StatementWithBody

fix output for arrays containing undefined values

[1,,2,] ==> [1,,2] instead of [1,undefined,2]

fix code generator for this case:

if (foo) {
  with (bar)
    if (baz)
      x();
} else y();

(the compressor removes the brackets since the consequent consists of a
single statement, but the codegen must include the brackets because
otherwise the `else` would refer to the inner `if`)

added README

minor

update (c) years

minor

fix compressing `a,b; return c;` into `return a,b,c;`

added print_to_string helper method

fix current_col and force a newline every 32K (support options.max_line_len)

added license

wrote more of the compressor and added some tests

fix output for certain edge cases

the statements if, for, do, while and with might have an AST_EmptyStatement
as body; if that's the case, we need to make sure that the semicolon gets in
the output.

declare some properties in the node constructor so that they're copied in clone

hint that brackets may be required in AST_BlockStatement

cleaned up some mess and started the actual compressor