We should make this JSLint clean code.

For example, we can use constant folding result value to determine target branch is dead or not.

var s = 10;
if (!s) {  // this is dead code
   ...
}

But folding simply, sometimes we generate more codes...

var s = 10000000000000000000000000000000000;  // too big number
s,s,s,s,s,

So I think we attach some information to AST node like __$esmangle_constant to store calculated result.

By this, we can extract scope analyzer in mangle process to common and use this analyzer in other passes.

This might be a tough one:

for(;;) {
  if(cond) continue;
  f()
}

is currently mangled to

for(;;){if(cond)continue;f()}

but it could be

for(;;)if(!cond)f()

We should add label mangling

a = (b(), c(), d())

to

b(),c(),a=d()

edit: related: 1bce14b#commitcomment-1890993

Just a general reminder to do constant folding.

• "a" + "b" -> "ab"
• 0 + 1 -> 1
• typeof function(){} -> "function"
• etc.

Thanks to @mishoo, it is found that remove-context-sensitive-expression pass has a bug.

http://lisperator.net/blog/uglifyjs-why-not-switching-to-spidermonkey-ast/

By attaching loc information to rewrited node, we can pass loc information to escodegen.

Such as jQuery.

Do not move FunctionDeclaration before DirectiveStatement.
related to #46

While it's not the primary use case, a browser-based version is very useful to quickly check different kind of transformation. I see two possible solutions:

• A specialized build for the browser, much like the current demo (browserify?). This requires a build step but that's likely needed only for each version and not every commit.
• Modify the code so that all the requires to escope, estraverse, etc are not needed in a browser environment. Here we assume that the user should already make them available as the dependencies.

(function(something){
    var a, b;
    sideEffect(a(b));
})(somethingElse)

is a common pattern that can be shortened with a step that provides the following transformation:

(function(something, a, b){
    sideEffect(a(b));
})(somethingElse)

You just have to watch out for arguments references within the function body (but not nested under other functions).

We can provide inlining optimize pass optionally.

esmangle should not transform 9e9 + 1 into 9000000001, as it currently does.

We should implement tree based constant folding

If an expression in a sequence does not have side effects and it's not the rightmost expression, it can be eliminated.

• 0, 1, 2 -> empty program
• f(), 1, 2 -> f()
• f(), 1, g() -> f(), g()
• f((0, 1, 2)) -> f(2)
• f((g(), 1, 2)) -> f((g(), 2)) (or, fancier: g(),f(2))

Be careful to preserve indirect eval, though:

• (999, eval)(str) -> (0, eval)(str)

wget http://github.com/DmitryBaranovskiy/raphael/raw/master/raphael.js
esmangle.js raphael.js

→

/.../esmangle/node_modules/escodegen/escodegen.js:354
    throw new Error('Numeric literal whose value is negative');

I'm filing it on Esmangle, but it's possibly an Escodegen issue.

We should add demo pages.

{
    'use strict';  // this is not directive
}

should not be transformed to

'use strict'

We should add tests.

See mishoo/UglifyJS#112

We should drop unused variable definitions.

Add recovery pass to estools/escodegen#49.
After this change, we can break AST in passes.

(function() {
  void 0
}());

to

(function() { }());

Hi, and thanks for your work.

I'd like to use esmangle in my project, but because I have to do dirty hacks to actually get messages from node when running from PHP (2>&1), I can't get the source from the result, so I'd like to be able to pass an --output (-o) directive to tell esmangle where to save the minified file.

(this might be as easy as to add this : - but I don't know if this is how you'd want it to work / how optimist works

//generated is basically all the files concatened
if (argv['output'] == null) {
  console.log(generated);
} else {
  fs.writeFile(argv['output'], generated);
}

Thanks!

transform

typeof ... === 'string'

to

typeof ... == 'string'

We should process Infinity value to 1/0 & 1/-0

Tests that are currently passing may be invalidated by introducing additional, advanced rewriting rules. For example, in the same way we don't apply the name mangling to the tests, we also shouldn't apply the boolean rewriting to tests where that optimisation isn't involved in what we're testing. Maybe a JSON file with a mapping from test names to a list of the applicable rules would be a better solution.

This can allow us to reduce more blocks. Taken from UglifyJS2. See this test case:

if (foo) {
    a = x();
    b = y();
    for (; a < b; ++a) console.log(a);
}

to

if (foo) for (a = x(), b = y(); a < b; ++a) console.log(a);

var obj = {
  'test' : 10
};

to

var obj = {
  test: 10
};

cond1 && (cond2 && cond3)

equals to

cond1 && cond2 && cond3

Use DirectiveStatement

For more complicated optimization, we should add optimization pass that solving Data Flow Equation.

This way, consumers of this tool that want to take advantage of as many transformations as possible don't need to keep updating how they invoke esmangle when new passes are added. This is the function that would be used in bin/esmangle.js.

As long as X is not an identifier, this is safe. If X is an identifier, but we can determine that it will be in scope (and not a global), it is safe. Otherwise, it is unsafe. Test cases:

• transform

  (function(){
    return typeof x() == "undefined";
  }())

  to

  (function(){
    return x() === void 0;
  }())

• transform

  (function(){
    var x;
    return function(){
      return typeof x === 'undefined';
    };
  }()

  to

  (function(){
    var x;
    return function(){
      return x === void 0;
    };
  }()

Please pin the dependencies to the exact version not >= or ~

It makes a big difference for people with deployed code to have the same versions deployed if they are depending on your packages. By using >= or really anything except exact pinning you open yourself and your users to broken packages when versions change.

function t() {
  if (a) {
    ...
  }
  return;
}

should be transformed to

function t() {
  if (a) {
    ...
  }
}

function f() {
  return void 0;
}

to

function t() { }

We should check control flow and eliminate wasted return statement.

According to the README this is how you use esmangle:

 var ast = esprima.parse(code);
 var result = esmangle.mangle(ast);  // gets mangled result

But when I tried this, I get an Object back and not a string.

Then I browsed the CLI script and saw this:

https://github.com/Constellation/esmangle/blob/master/bin/esmangle.js#L55-68

It runs though these steps:

• esprima.parse
• esmangle.optimize
• esmangle.mangle
• escodegen.generate

Can you update the README to document the proper way to take a string of JSCode and minify it into a string worth writing into a file?

Maybe add som sugar so that I can require esmangle and not have to require esmangle, esprima and escodegen?

Because Escodegen & Escope use them.

We should provide more flexible pipeline construction.
For example,

esmangle.optimize(tree, [
[
  'pre-passes'
],
[
  'passes'
],
[
  'post-passes'
]
]);

Probably, we should make easier pass format.

Esmangle should not reduce directives like 'use strict' to SequenceExpression.

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

can become

(function(u){
  return function(){
    return x ? y : u;
  };
}())

We should add more minifying passes.

Like,

• remove blocks
• reordering statements (for minifying, like function declaration)

We should consider ToBoolean context & IgnoreResult context

void void 0

to

void 0

&

if (!!0);

to

if (0);

Drop unused assignments

function test() {
  var i;
  i = 20;
}

to

function test() {
  var i;
  20;
}

and then

function test() {
  var i;
}

and finally

function test() { }

Would be cool if Esmangle could generate Source Maps for minified files. More info here: http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/

Is this something that could be considered?

/cc @paulirish

If we start with this program:

null!=(a?b:void 0)

and temporarily expand it to

a?null!=b:null!=void 0

we can further reduce it to

a?null!=b:!1

Inspired by UglifyJS2. A good test case:

(function(){
  if(x) return y;
  if(y) return z;
}())

should become

(function(){
  return x ? y : y ? z : void 0;
}())