uglifier 1.0.0 → 1.0.1

data/.travis.yml

@@ -1,5 +1,4 @@
 rvm:
   - 1.8.7
   - 1.9.2
-env: "EXECJS_RUNTIME='RubyRacer'"
 before_script: "git submodule update --init --recursive"

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.1

data/lib/uglify.js

@@ -239,7 +239,7 @@ var OPERATORS = array_to_hash([
         "||"
 ]);
 
-var WHITESPACE_CHARS = array_to_hash(characters(" \u00a0\n\r\t\f\v\u200b"));
+var WHITESPACE_CHARS = array_to_hash(characters(" \u00a0\n\r\t\f\u000b\u200b"));
 
 var PUNC_BEFORE_EXPRESSION = array_to_hash(characters("[{}(,.;:"));
 
@@ -454,11 +454,12 @@ function tokenizer($TEXT) {
                     case "r" : return "\r";
                     case "t" : return "\t";
                     case "b" : return "\b";
-                    case "v" : return "\v";
+                    case "v" : return "\u000b";
                     case "f" : return "\f";
                     case "0" : return "\0";
                     case "x" : return String.fromCharCode(hex_bytes(2));
                     case "u" : return String.fromCharCode(hex_bytes(4));
+                    case "\n": return "";
                     default  : return ch;
                 }
         };
@@ -479,7 +480,24 @@ function tokenizer($TEXT) {
                         var quote = next(), ret = "";
                         for (;;) {
                                 var ch = next(true);
-                                if (ch == "\\") ch = read_escaped_char();
+                                if (ch == "\\") {
+                                        // read OctalEscapeSequence (XXX: deprecated if "strict mode")
+                                        // https://github.com/mishoo/UglifyJS/issues/178
+                                        var octal_len = 0, first = null;
+                                        ch = read_while(function(ch){
+                                                if (ch >= "0" && ch <= "7") {
+                                                        if (!first) {
+                                                                first = ch;
+                                                                return ++octal_len;
+                                                        }
+                                                        else if (first <= "3" && octal_len <= 2) return ++octal_len;
+                                                        else if (first >= "4" && octal_len <= 1) return ++octal_len;
+                                                }
+                                                return false;
+                                        });
+                                        if (octal_len > 0) ch = String.fromCharCode(parseInt(ch, 8));
+                                        else ch = read_escaped_char();
+                                }
                                 else if (ch == quote) break;
                                 ret += ch;
                         }
@@ -1107,11 +1125,6 @@ function parse($TEXT, exigent_mode, embed_tokens) {
                         next();
                         return new_();
                 }
-                if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
-                        return make_unary("unary-prefix",
-                                          prog1(S.token.value, next),
-                                          expr_atom(allow_calls));
-                }
                 if (is("punc")) {
                         switch (S.token.value) {
                             case "(":
@@ -1212,13 +1225,23 @@ function parse($TEXT, exigent_mode, embed_tokens) {
                         next();
                         return subscripts(as("call", expr, expr_list(")")), true);
                 }
-                if (allow_calls && is("operator") && HOP(UNARY_POSTFIX, S.token.value)) {
-                        return prog1(curry(make_unary, "unary-postfix", S.token.value, expr),
-                                     next);
-                }
                 return expr;
         };
 
+        function maybe_unary(allow_calls) {
+                if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
+                        return make_unary("unary-prefix",
+                                          prog1(S.token.value, next),
+                                          maybe_unary(allow_calls));
+                }
+                var val = expr_atom(allow_calls);
+                while (is("operator") && HOP(UNARY_POSTFIX, S.token.value) && !S.token.nlb) {
+                        val = make_unary("unary-postfix", S.token.value, val);
+                        next();
+                }
+                return val;
+        };
+
         function make_unary(tag, op, expr) {
                 if ((op == "++" || op == "--") && !is_assignable(expr))
                         croak("Invalid use of " + op + " operator");
@@ -1231,14 +1254,14 @@ function parse($TEXT, exigent_mode, embed_tokens) {
                 var prec = op != null ? PRECEDENCE[op] : null;
                 if (prec != null && prec > min_prec) {
                         next();
-                        var right = expr_op(expr_atom(true), prec, no_in);
+                        var right = expr_op(maybe_unary(true), prec, no_in);
                         return expr_op(as("binary", op, left, right), min_prec, no_in);
                 }
                 return left;
         };
 
         function expr_ops(no_in) {
-                return expr_op(expr_atom(true), 0, no_in);
+                return expr_op(maybe_unary(true), 0, no_in);
         };
 
         function maybe_conditional(no_in) {
@@ -1707,20 +1730,27 @@ Scope.prototype = {
                         return m;
                 }
         },
+        set_mangle: function(name, m) {
+                this.rev_mangled[m] = name;
+                return this.mangled[name] = m;
+        },
         get_mangled: function(name, newMangle) {
                 if (this.uses_eval || this.uses_with) return name; // no mangle if eval or with is in use
                 var s = this.has(name);
                 if (!s) return name; // not in visible scope, no mangle
                 if (HOP(s.mangled, name)) return s.mangled[name]; // already mangled in this scope
                 if (!newMangle) return name;                      // not found and no mangling requested
-
-                var m = s.next_mangled();
-                s.rev_mangled[m] = name;
-                return s.mangled[name] = m;
+                return s.set_mangle(name, s.next_mangled());
+        },
+        references: function(name) {
+                return name && !this.parent || this.uses_with || this.uses_eval || this.refs[name];
         },
-        define: function(name) {
-                if (name != null)
-                        return this.names[name] = name;
+        define: function(name, type) {
+                if (name != null) {
+                        if (type == "var" || !HOP(this.names, name))
+                                this.names[name] = type || "var";
+                        return name;
+                }
         }
 };
 
@@ -1738,8 +1768,8 @@ function ast_add_scope(ast) {
                 return ret;
         };
 
-        function define(name) {
-                return current_scope.define(name);
+        function define(name, type) {
+                return current_scope.define(name, type);
         };
 
         function reference(name) {
@@ -1748,33 +1778,41 @@ function ast_add_scope(ast) {
 
         function _lambda(name, args, body) {
                 var is_defun = this[0] == "defun";
-                return [ this[0], is_defun ? define(name) : name, args, with_new_scope(function(){
-                        if (!is_defun) define(name);
-                        MAP(args, define);
+                return [ this[0], is_defun ? define(name, "defun") : name, args, with_new_scope(function(){
+                        if (!is_defun) define(name, "lambda");
+                        MAP(args, function(name){ define(name, "arg") });
                         return MAP(body, walk);
                 })];
         };
 
+        function _vardefs(type) {
+                return function(defs) {
+                        MAP(defs, function(d){
+                                define(d[0], type);
+                                if (d[1]) reference(d[0]);
+                        });
+                };
+        };
+
         return with_new_scope(function(){
                 // process AST
                 var ret = w.with_walkers({
                         "function": _lambda,
                         "defun": _lambda,
+                        "label": function(name, stat) { define(name, "label") },
+                        "break": function(label) { if (label) reference(label) },
+                        "continue": function(label) { if (label) reference(label) },
                         "with": function(expr, block) {
                                 for (var s = current_scope; s; s = s.parent)
                                         s.uses_with = true;
                         },
-                        "var": function(defs) {
-                                MAP(defs, function(d){ define(d[0]) });
-                        },
-                        "const": function(defs) {
-                                MAP(defs, function(d){ define(d[0]) });
-                        },
+                        "var": _vardefs("var"),
+                        "const": _vardefs("const"),
                         "try": function(t, c, f) {
                                 if (c != null) return [
                                         this[0],
                                         MAP(t, walk),
-                                        [ define(c[0]), MAP(c[1], walk) ],
+                                        [ define(c[0], "catch"), MAP(c[1], walk) ],
                                         f != null ? MAP(f, walk) : null
                                 ];
                         },
@@ -1849,19 +1887,30 @@ function ast_mangle(ast, options) {
         };
 
         function _lambda(name, args, body) {
-                var is_defun = this[0] == "defun";
-                if (is_defun && name) name = get_mangled(name);
+                var is_defun = this[0] == "defun", extra;
+                if (name) {
+                        if (is_defun) name = get_mangled(name);
+                        else {
+                                extra = {};
+                                if (!(scope.uses_eval || scope.uses_with))
+                                        name = extra[name] = scope.next_mangled();
+                                else
+                                        extra[name] = name;
+                        }
+                }
                 body = with_scope(body.scope, function(){
-                        if (!is_defun && name) name = get_mangled(name);
                         args = MAP(args, function(name){ return get_mangled(name) });
                         return MAP(body, walk);
-                });
+                }, extra);
                 return [ this[0], name, args, body ];
         };
 
-        function with_scope(s, cont) {
+        function with_scope(s, cont, extra) {
                 var _scope = scope;
                 scope = s;
+                if (extra) for (var i in extra) if (HOP(extra, i)) {
+                        s.set_mangle(i, extra[i]);
+                }
                 for (var i in s.names) if (HOP(s.names, i)) {
                         get_mangled(i, true);
                 }
@@ -1891,6 +1940,9 @@ function ast_mangle(ast, options) {
                         }
                         return ast;
                 },
+                "label": function(label, stat) { return [ this[0], get_mangled(label), walk(stat) ] },
+                "break": function(label) { if (label) return [ this[0], get_mangled(label) ] },
+                "continue": function(label) { if (label) return [ this[0], get_mangled(label) ] },
                 "var": _vardefs,
                 "const": _vardefs,
                 "name": function(name) {
@@ -1937,10 +1989,12 @@ function last_stat(b) {
 }
 
 function aborts(t) {
-        if (t) {
-                t = last_stat(t);
-                if (t[0] == "return" || t[0] == "break" || t[0] == "continue" || t[0] == "throw")
-                        return true;
+        if (t) switch (last_stat(t)[0]) {
+            case "return":
+            case "break":
+            case "continue":
+            case "throw":
+                return true;
         }
 };
 
@@ -2095,6 +2149,218 @@ function warn_unreachable(ast) {
                 warn("Dropping unreachable code: " + gen_code(ast, true));
 };
 
+function prepare_ifs(ast) {
+        var w = ast_walker(), walk = w.walk;
+        // In this first pass, we rewrite ifs which abort with no else with an
+        // if-else.  For example:
+        //
+        // if (x) {
+        //     blah();
+        //     return y;
+        // }
+        // foobar();
+        //
+        // is rewritten into:
+        //
+        // if (x) {
+        //     blah();
+        //     return y;
+        // } else {
+        //     foobar();
+        // }
+        function redo_if(statements) {
+                statements = MAP(statements, walk);
+
+                for (var i = 0; i < statements.length; ++i) {
+                        var fi = statements[i];
+                        if (fi[0] != "if") continue;
+
+                        if (fi[3] && walk(fi[3])) continue;
+
+                        var t = walk(fi[2]);
+                        if (!aborts(t)) continue;
+
+                        var conditional = walk(fi[1]);
+
+                        var e_body = statements.slice(i + 1);
+                        var e = e_body.length == 1 ? e_body[0] : [ "block", e_body ];
+
+                        var ret = statements.slice(0, i).concat([ [
+                                fi[0],          // "if"
+                                conditional,    // conditional
+                                t,              // then
+                                e               // else
+                        ] ]);
+
+                        return redo_if(ret);
+                }
+
+                return statements;
+        };
+
+        function redo_if_lambda(name, args, body) {
+                body = redo_if(body);
+                return [ this[0], name, args, body ];
+        };
+
+        function redo_if_block(statements) {
+                return [ this[0], statements != null ? redo_if(statements) : null ];
+        };
+
+        return w.with_walkers({
+                "defun": redo_if_lambda,
+                "function": redo_if_lambda,
+                "block": redo_if_block,
+                "splice": redo_if_block,
+                "toplevel": function(statements) {
+                        return [ this[0], redo_if(statements) ];
+                },
+                "try": function(t, c, f) {
+                        return [
+                                this[0],
+                                redo_if(t),
+                                c != null ? [ c[0], redo_if(c[1]) ] : null,
+                                f != null ? redo_if(f) : null
+                        ];
+                }
+        }, function() {
+                return walk(ast);
+        });
+};
+
+function for_side_effects(ast, handler) {
+        var w = ast_walker(), walk = w.walk;
+        var $stop = {}, $restart = {};
+        function stop() { throw $stop };
+        function restart() { throw $restart };
+        function found(){ return handler.call(this, this, w, stop, restart) };
+        function unary(op) {
+                if (op == "++" || op == "--")
+                        return found.apply(this, arguments);
+        };
+        return w.with_walkers({
+                "try": found,
+                "throw": found,
+                "return": found,
+                "new": found,
+                "switch": found,
+                "break": found,
+                "continue": found,
+                "assign": found,
+                "call": found,
+                "if": found,
+                "for": found,
+                "for-in": found,
+                "while": found,
+                "do": found,
+                "return": found,
+                "unary-prefix": unary,
+                "unary-postfix": unary,
+                "defun": found
+        }, function(){
+                while (true) try {
+                        walk(ast);
+                        break;
+                } catch(ex) {
+                        if (ex === $stop) break;
+                        if (ex === $restart) continue;
+                        throw ex;
+                }
+        });
+};
+
+function ast_lift_variables(ast) {
+        var w = ast_walker(), walk = w.walk, scope;
+        function do_body(body, env) {
+                var _scope = scope;
+                scope = env;
+                body = MAP(body, walk);
+                var hash = {}, names = MAP(env.names, function(type, name){
+                        if (type != "var") return MAP.skip;
+                        if (!env.references(name)) return MAP.skip;
+                        hash[name] = true;
+                        return [ name ];
+                });
+                if (names.length > 0) {
+                        // looking for assignments to any of these variables.
+                        // we can save considerable space by moving the definitions
+                        // in the var declaration.
+                        for_side_effects([ "block", body ], function(ast, walker, stop, restart) {
+                                if (ast[0] == "assign"
+                                    && ast[1] === true
+                                    && ast[2][0] == "name"
+                                    && HOP(hash, ast[2][1])) {
+                                        // insert the definition into the var declaration
+                                        for (var i = names.length; --i >= 0;) {
+                                                if (names[i][0] == ast[2][1]) {
+                                                        if (names[i][1]) // this name already defined, we must stop
+                                                                stop();
+                                                        names[i][1] = ast[3]; // definition
+                                                        names.push(names.splice(i, 1)[0]);
+                                                        break;
+                                                }
+                                        }
+                                        // remove this assignment from the AST.
+                                        var p = walker.parent();
+                                        if (p[0] == "seq") {
+                                                var a = p[2];
+                                                a.unshift(0, p.length);
+                                                p.splice.apply(p, a);
+                                        }
+                                        else if (p[0] == "stat") {
+                                                p.splice(0, p.length, "block"); // empty statement
+                                        }
+                                        else {
+                                                stop();
+                                        }
+                                        restart();
+                                }
+                                stop();
+                        });
+                        body.unshift([ "var", names ]);
+                }
+                scope = _scope;
+                return body;
+        };
+        function _vardefs(defs) {
+                var ret = null;
+                for (var i = defs.length; --i >= 0;) {
+                        var d = defs[i];
+                        if (!d[1]) continue;
+                        d = [ "assign", true, [ "name", d[0] ], d[1] ];
+                        if (ret == null) ret = d;
+                        else ret = [ "seq", d, ret ];
+                }
+                if (ret == null) {
+                        if (w.parent()[0] == "for-in")
+                                return [ "name", defs[0][0] ];
+                        return MAP.skip;
+                }
+                return [ "stat", ret ];
+        };
+        function _toplevel(body) {
+                return [ this[0], do_body(body, this.scope) ];
+        };
+        return w.with_walkers({
+                "function": function(name, args, body){
+                        for (var i = args.length; --i >= 0 && !body.scope.references(args[i]);)
+                                args.pop();
+                        if (!body.scope.references(name)) name = null;
+                        return [ this[0], name, args, do_body(body, body.scope) ];
+                },
+                "defun": function(name, args, body){
+                        if (!scope.references(name)) return MAP.skip;
+                        for (var i = args.length; --i >= 0 && !body.scope.references(args[i]);)
+                                args.pop();
+                        return [ this[0], name, args, do_body(body, body.scope) ];
+                },
+                "var": _vardefs,
+                "toplevel": _toplevel
+        }, function(){
+                return walk(ast_add_scope(ast));
+        });
+};
+
 function ast_squeeze(ast, options) {
         options = defaults(options, {
                 make_seqs   : true,
@@ -2159,15 +2425,14 @@ function ast_squeeze(ast, options) {
         function _lambda(name, args, body) {
                 var is_defun = this[0] == "defun";
                 body = with_scope(body.scope, function(){
-                        var ret = tighten(MAP(body, walk), "lambda");
-                        if (!is_defun && name && !HOP(scope.refs, name))
+                        var ret = tighten(body, "lambda");
+                        if (!is_defun && name && !scope.references(name))
                                 name = null;
                         return ret;
                 });
                 return [ this[0], name, args, body ];
         };
 
-        // we get here for blocks that have been already transformed.
         // this function does a few things:
         // 1. discard useless blocks
         // 2. join consecutive var declarations
@@ -2175,6 +2440,8 @@ function ast_squeeze(ast, options) {
         // 4. transform consecutive statements using the comma operator
         // 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... }
         function tighten(statements, block_type) {
+                statements = MAP(statements, walk);
+
                 statements = statements.reduce(function(a, stat){
                         if (stat[0] == "block") {
                                 if (stat[1]) {
@@ -2202,7 +2469,17 @@ function ast_squeeze(ast, options) {
                 if (options.dead_code) statements = (function(a, has_quit){
                         statements.forEach(function(st){
                                 if (has_quit) {
-                                        if (member(st[0], [ "function", "defun" , "var", "const" ])) {
+                                        if (st[0] == "function" || st[0] == "defun") {
+                                                a.push(st);
+                                        }
+                                        else if (st[0] == "var" || st[0] == "const") {
+                                                if (!options.no_warnings)
+                                                        warn("Variables declared in unreachable code");
+                                                st[1] = MAP(st[1], function(def){
+                                                        if (def[1] && !options.no_warnings)
+                                                                warn_unreachable([ "assign", true, [ "name", def[0] ], def[1] ]);
+                                                        return [ def[0] ];
+                                                });
                                                 a.push(st);
                                         }
                                         else if (!options.no_warnings)
@@ -2226,27 +2503,38 @@ function ast_squeeze(ast, options) {
                                         prev = cur;
                                 }
                         });
+                        if (a.length >= 2
+                            && a[a.length-2][0] == "stat"
+                            && (a[a.length-1][0] == "return" || a[a.length-1][0] == "throw")
+                            && a[a.length-1][1])
+                        {
+                                a.splice(a.length - 2, 2,
+                                         [ a[a.length-1][0],
+                                           [ "seq", a[a.length-2][1], a[a.length-1][1] ]]);
+                        }
                         return a;
                 })([]);
 
-                if (block_type == "lambda") statements = (function(i, a, stat){
-                        while (i < statements.length) {
-                                stat = statements[i++];
-                                if (stat[0] == "if" && !stat[3]) {
-                                        if (stat[2][0] == "return" && stat[2][1] == null) {
-                                                a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ]));
-                                                break;
-                                        }
-                                        var last = last_stat(stat[2]);
-                                        if (last[0] == "return" && last[1] == null) {
-                                                a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ]));
-                                                break;
-                                        }
-                                }
-                                a.push(stat);
-                        }
-                        return a;
-                })(0, []);
+                // this increases jQuery by 1K.  Probably not such a good idea after all..
+                // part of this is done in prepare_ifs anyway.
+                // if (block_type == "lambda") statements = (function(i, a, stat){
+                //         while (i < statements.length) {
+                //                 stat = statements[i++];
+                //                 if (stat[0] == "if" && !stat[3]) {
+                //                         if (stat[2][0] == "return" && stat[2][1] == null) {
+                //                                 a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ]));
+                //                                 break;
+                //                         }
+                //                         var last = last_stat(stat[2]);
+                //                         if (last[0] == "return" && last[1] == null) {
+                //                                 a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ]));
+                //                                 break;
+                //                         }
+                //                 }
+                //                 a.push(stat);
+                //         }
+                //         return a;
+                // })(0, []);
 
                 return statements;
         };
@@ -2355,13 +2643,13 @@ function ast_squeeze(ast, options) {
                 "if": make_if,
                 "toplevel": function(body) {
                         return [ "toplevel", with_scope(this.scope, function(){
-                                return tighten(MAP(body, walk));
+                                return tighten(body);
                         }) ];
                 },
                 "switch": function(expr, body) {
                         var last = body.length - 1;
                         return [ "switch", walk(expr), MAP(body, function(branch, i){
-                                var block = tighten(MAP(branch[1], walk));
+                                var block = tighten(branch[1]);
                                 if (i == last && block.length > 0) {
                                         var node = block[block.length - 1];
                                         if (node[0] == "break" && !node[1])
@@ -2373,7 +2661,7 @@ function ast_squeeze(ast, options) {
                 "function": _lambda,
                 "defun": _lambda,
                 "block": function(body) {
-                        if (body) return rmblock([ "block", tighten(MAP(body, walk)) ]);
+                        if (body) return rmblock([ "block", tighten(body) ]);
                 },
                 "binary": function(op, left, right) {
                         return when_constant([ "binary", op, walk(left), walk(right) ], function yes(c){
@@ -2388,9 +2676,9 @@ function ast_squeeze(ast, options) {
                 "try": function(t, c, f) {
                         return [
                                 "try",
-                                tighten(MAP(t, walk)),
-                                c != null ? [ c[0], tighten(MAP(c[1], walk)) ] : null,
-                                f != null ? tighten(MAP(f, walk)) : null
+                                tighten(t),
+                                c != null ? [ c[0], tighten(c[1]) ] : null,
+                                f != null ? tighten(f) : null
                         ];
                 },
                 "unary-prefix": function(op, expr) {
@@ -2424,7 +2712,12 @@ function ast_squeeze(ast, options) {
                 },
                 "while": _do_while
         }, function() {
-                return walk(ast_add_scope(ast));
+                for (var i = 0; i < 2; ++i) {
+                        ast = prepare_ifs(ast);
+                        ast = ast_add_scope(ast);
+                        ast = walk(ast);
+                }
+                return ast;
         });
 };
 
@@ -2481,7 +2774,8 @@ function gen_code(ast, options) {
                 quote_keys   : false,
                 space_colon  : false,
                 beautify     : false,
-                ascii_only   : false
+                ascii_only   : false,
+                inline_script: false
         });
         var beautify = !!options.beautify;
         var indentation = 0,
@@ -2489,7 +2783,10 @@ function gen_code(ast, options) {
             space = beautify ? " " : "";
 
         function encode_string(str) {
-                return make_string(str, options.ascii_only);
+                var ret = make_string(str, options.ascii_only);
+                if (options.inline_script)
+                        ret = ret.replace(/<\x2fscript([>/\t\n\f\r ])/gi, "<\\/script$1");
+                return ret;
         };
 
         function make_name(name) {
@@ -2566,7 +2863,7 @@ function gen_code(ast, options) {
                         // we're the first in this "seq" and the
                         // parent is "stat", and so on.  Messy stuff,
                         // but it worths the trouble.
-                        var a = slice($stack), self = a.pop(), p = a.pop();
+                        var a = slice(w.stack()), self = a.pop(), p = a.pop();
                         while (p) {
                                 if (p[0] == "stat") return true;
                                 if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) ||
@@ -2596,7 +2893,9 @@ function gen_code(ast, options) {
                 return best_of(a);
         };
 
-        var generators = {
+        var w = ast_walker();
+        var make = w.walk;
+        return w.with_walkers({
                 "string": encode_string,
                 "num": make_num,
                 "name": make_name,
@@ -2605,7 +2904,7 @@ function gen_code(ast, options) {
                                 .join(newline + newline);
                 },
                 "splice": function(statements) {
-                        var parent = $stack[$stack.length - 2][0];
+                        var parent = w.parent();
                         if (HOP(SPLICE_NEEDS_BRACKETS, parent)) {
                                 // we need block brackets in this case
                                 return make_block.apply(this, arguments);
@@ -2745,6 +3044,10 @@ function gen_code(ast, options) {
                             !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) {
                                 right = "(" + right + ")";
                         }
+                        else if (!beautify && options.inline_script && (operator == "<" || operator == "<<")
+                                 && rvalue[0] == "regexp" && /^script/i.test(rvalue[1])) {
+                                right = " " + right;
+                        }
                         return add_spaces([ left, operator, right ]);
                 },
                 "unary-prefix": function(operator, expr) {
@@ -2775,7 +3078,7 @@ function gen_code(ast, options) {
                                                 // body in p[1][3] and type ("get" / "set") in p[2].
                                                 return indent(make_function(p[0], p[1][2], p[1][3], p[2]));
                                         }
-                                        var key = p[0], val = make(p[1]);
+                                        var key = p[0], val = parenthesize(p[1], "seq");
                                         if (options.quote_keys) {
                                                 key = encode_string(key);
                                         } else if ((typeof key == "number" || !beautify && +key + "" == key)
@@ -2815,7 +3118,7 @@ function gen_code(ast, options) {
                 "atom": function(name) {
                         return make_name(name);
                 }
-        };
+        }, function(){ return make(ast) });
 
         // The squeezer replaces "block"-s that contain only a single
         // statement with the statement itself; technically, the AST
@@ -2830,7 +3133,7 @@ function gen_code(ast, options) {
                         // IE croaks with "syntax error" on code like this:
                         //     if (foo) do ... while(cond); else ...
                         // we need block brackets around do/while
-                        return make([ "block", [ th ]]);
+                        return make_block([ th ]);
                 }
                 var b = th;
                 while (true) {
@@ -2857,20 +3160,31 @@ function gen_code(ast, options) {
                 return add_spaces([ out, make_block(body) ]);
         };
 
+        function must_has_semicolon(node) {
+                switch (node[0]) {
+                    case "with":
+                    case "while":
+                        return empty(node[2]); // `with' or `while' with empty body?
+                    case "for":
+                    case "for-in":
+                        return empty(node[4]); // `for' with empty body?
+                    case "if":
+                        if (empty(node[2]) && !node[3]) return true; // `if' with empty `then' and no `else'
+                        if (node[3]) {
+                                if (empty(node[3])) return true; // `else' present but empty
+                                return must_has_semicolon(node[3]); // dive into the `else' branch
+                        }
+                        return must_has_semicolon(node[2]); // dive into the `then' branch
+                }
+        };
+
         function make_block_statements(statements, noindent) {
                 for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) {
                         var stat = statements[i];
                         var code = make(stat);
                         if (code != ";") {
-                                if (!beautify && i == last) {
-                                        if ((stat[0] == "while" && empty(stat[2])) ||
-                                            (member(stat[0], [ "for", "for-in"] ) && empty(stat[4])) ||
-                                            (stat[0] == "if" && empty(stat[2]) && !stat[3]) ||
-                                            (stat[0] == "if" && stat[3] && empty(stat[3]))) {
-                                                code = code.replace(/;*\s*$/, ";");
-                                        } else {
-                                                code = code.replace(/;+\s*$/, "");
-                                        }
+                                if (!beautify && i == last && !must_has_semicolon(stat)) {
+                                        code = code.replace(/;+\s*$/, "");
                                 }
                                 a.push(code);
                         }
@@ -2910,20 +3224,6 @@ function gen_code(ast, options) {
                 return name;
         };
 
-        var $stack = [];
-
-        function make(node) {
-                var type = node[0];
-                var gen = generators[type];
-                if (!gen)
-                        throw new Error("Can't find generator for \"" + type + "\"");
-                $stack.push(node);
-                var ret = gen.apply(type, node.slice(1));
-                $stack.pop();
-                return ret;
-        };
-
-        return make(ast);
 };
 
 function split_lines(code, max_line_length) {
@@ -3008,16 +3308,34 @@ var MAP;
 
 (function(){
         MAP = function(a, f, o) {
-                var ret = [];
-                for (var i = 0; i < a.length; ++i) {
+                var ret = [], top = [], i;
+                function doit() {
                         var val = f.call(o, a[i], i);
-                        if (val instanceof AtTop) ret.unshift(val.v);
-                        else ret.push(val);
-                }
-                return ret;
+                        if (val instanceof AtTop) {
+                                val = val.v;
+                                if (val instanceof Splice) {
+                                        top.push.apply(top, val.v);
+                                } else {
+                                        top.push(val);
+                                }
+                        }
+                        else if (val != skip) {
+                                if (val instanceof Splice) {
+                                        ret.push.apply(ret, val.v);
+                                } else {
+                                        ret.push(val);
+                                }
+                        }
+                };
+                if (a instanceof Array) for (i = 0; i < a.length; ++i) doit();
+                else for (i in a) if (HOP(a, i)) doit();
+                return top.concat(ret);
         };
         MAP.at_top = function(val) { return new AtTop(val) };
+        MAP.splice = function(val) { return new Splice(val) };
+        var skip = MAP.skip = {};
         function AtTop(val) { this.v = val };
+        function Splice(val) { this.v = val };
 })();
 
 /* -----[ Exports ]----- */
@@ -3025,6 +3343,7 @@ var MAP;
 exports.ast_walker = ast_walker;
 exports.ast_mangle = ast_mangle;
 exports.ast_squeeze = ast_squeeze;
+exports.ast_lift_variables = ast_lift_variables;
 exports.gen_code = gen_code;
 exports.ast_add_scope = ast_add_scope;
 exports.set_logger = function(logger) { warn = logger };

data/uglifier.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{uglifier}
-  s.version = "1.0.0"
+  s.version = "1.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = [%q{Ville Lautanala}]
-  s.date = %q{2011-06-21}
+  s.authors = ["Ville Lautanala"]
+  s.date = %q{2011-08-15}
   s.email = %q{lautis@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE.txt",
@@ -34,14 +34,15 @@ Gem::Specification.new do |s|
     "uglifier.gemspec"
   ]
   s.homepage = %q{http://github.com/lautis/uglifier}
-  s.require_paths = [%q{lib}]
-  s.rubygems_version = %q{1.8.4}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Ruby wrapper for UglifyJS JavaScript compressor}
 
   if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<execjs>, [">= 0.3.0"])
       s.add_runtime_dependency(%q<multi_json>, [">= 1.0.2"])
       s.add_development_dependency(%q<rspec>, ["~> 2.6.0"])

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: uglifier
 version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: 
+  prerelease: false
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Ville Lautanala
@@ -15,102 +14,91 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-21 00:00:00 Z
+date: 2011-08-15 00:00:00 +03:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  type: :runtime
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 19
         segments: 
         - 0
         - 3
         - 0
         version: 0.3.0
-  prerelease: false
-  version_requirements: *id001
+  requirement: *id001
   name: execjs
-- !ruby/object:Gem::Dependency 
+  prerelease: false
   type: :runtime
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 19
         segments: 
         - 1
         - 0
         - 2
         version: 1.0.2
-  prerelease: false
-  version_requirements: *id002
+  requirement: *id002
   name: multi_json
+  prerelease: false
+  type: :runtime
 - !ruby/object:Gem::Dependency 
-  type: :development
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
         segments: 
         - 2
         - 6
         - 0
         version: 2.6.0
-  prerelease: false
-  version_requirements: *id003
+  requirement: *id003
   name: rspec
-- !ruby/object:Gem::Dependency 
+  prerelease: false
   type: :development
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
         segments: 
         - 1
         - 0
         - 0
         version: 1.0.0
-  prerelease: false
-  version_requirements: *id004
+  requirement: *id004
   name: bundler
-- !ruby/object:Gem::Dependency 
+  prerelease: false
   type: :development
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
         segments: 
         - 1
         - 6
         - 0
         version: 1.6.0
-  prerelease: false
-  version_requirements: *id005
+  requirement: *id005
   name: jeweler
-- !ruby/object:Gem::Dependency 
+  prerelease: false
   type: :development
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
-  prerelease: false
-  version_requirements: *id006
+  requirement: *id006
   name: rcov
+  prerelease: false
+  type: :development
 description: 
 email: lautis@gmail.com
 executables: []
@@ -137,6 +125,7 @@ files:
 - spec/spec_helper.rb
 - spec/uglifier_spec.rb
 - uglifier.gemspec
+has_rdoc: true
 homepage: http://github.com/lautis/uglifier
 licenses: []
 
@@ -146,27 +135,23 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.4
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Ruby wrapper for UglifyJS JavaScript compressor