pdf-creator-node 2.2.4 → 2.3.4

package/example/node_modules/uglify-js/lib/output.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS
+  https://github.com/mishoo/UglifyJS2
 
   -------------------------------- (C) ---------------------------------
 
@@ -56,7 +56,6 @@ function OutputStream(options) {
         beautify         : false,
         braces           : false,
         comments         : false,
-        galio            : false,
         ie8              : false,
         indent_level     : 4,
         indent_start     : 0,
@@ -70,7 +69,6 @@ function OutputStream(options) {
         semicolons       : true,
         shebang          : true,
         source_map       : null,
-        v8               : false,
         webkit           : false,
         width            : 80,
         wrap_iife        : false,
@@ -102,16 +100,13 @@ function OutputStream(options) {
         }
     }
 
-    var indentation = options.indent_start;
+    var indentation = 0;
     var current_col = 0;
     var current_line = 1;
     var current_pos = 0;
     var OUTPUT = "";
 
     var to_utf8 = options.ascii_only ? function(str, identifier) {
-        if (identifier) str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) {
-            return "\\u{" + (ch.charCodeAt(0) - 0xd7c0 << 10 | ch.charCodeAt(1) - 0xdc00).toString(16) + "}";
-        });
         return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
             var code = ch.charCodeAt(0).toString(16);
             if (code.length <= 2 && !identifier) {
@@ -196,6 +191,10 @@ function OutputStream(options) {
         return name;
     }
 
+    function make_indent(back) {
+        return repeat_string(" ", options.indent_start + indentation - back * options.indent_level);
+    }
+
     /* -----[ beautification/minification ]----- */
 
     var has_parens = false;
@@ -306,7 +305,6 @@ function OutputStream(options) {
                 || (ch == "/" && ch == prev)
                 || ((ch == "+" || ch == "-") && ch == last)
                 || str == "--" && last == "!"
-                || str == "in" && prev == "/"
                 || last == "--" && ch == ">") {
                 OUTPUT += " ";
                 current_col++;
@@ -346,7 +344,9 @@ function OutputStream(options) {
     };
 
     var indent = options.beautify ? function(half) {
-        print(repeat_string(" ", half ? indentation - (options.indent_level >> 1) : indentation));
+        if (options.beautify) {
+            print(make_indent(half ? 0.5 : 0));
+        }
     } : noop;
 
     var with_indent = options.beautify ? function(col, cont) {
@@ -501,11 +501,11 @@ function OutputStream(options) {
                 }
             }
             if (/comment[134]/.test(c.type)) {
-                print("//" + c.value.replace(/[@#]__PURE__/g, " ") + "\n");
+                print("//" + c.value.replace(/[@#]__PURE__/g, ' ') + "\n");
                 indent();
                 last_nlb = true;
             } else if (c.type == "comment2") {
-                print("/*" + c.value.replace(/[@#]__PURE__/g, " ") + "*/");
+                print("/*" + c.value.replace(/[@#]__PURE__/g, ' ') + "*/");
                 last_nlb = false;
             }
         });
@@ -559,10 +559,10 @@ function OutputStream(options) {
                 space();
             }
             if (/comment[134]/.test(c.type)) {
-                print("//" + c.value.replace(/[@#]__PURE__/g, " "));
+                print("//" + c.value.replace(/[@#]__PURE__/g, ' '));
                 need_newline_indented = true;
             } else if (c.type == "comment2") {
-                print("/*" + c.value.replace(/[@#]__PURE__/g, " ") + "*/");
+                print("/*" + c.value.replace(/[@#]__PURE__/g, ' ') + "*/");
                 need_space = true;
             }
         });
@@ -574,9 +574,9 @@ function OutputStream(options) {
         get             : get,
         toString        : get,
         indent          : indent,
-        should_break    : readonly ? noop : function() {
-            return options.width && current_col - indentation >= options.width;
-        },
+        indentation     : function() { return indentation },
+        current_width   : function() { return current_col - indentation },
+        should_break    : function() { return options.width && this.current_width() >= options.width },
         has_parens      : function() { return has_parens },
         newline         : newline,
         print           : print,
@@ -612,7 +612,7 @@ function OutputStream(options) {
         },
         parent          : function(n) {
             return stack[stack.length - 2 - (n || 0)];
-        },
+        }
     };
 }
 
@@ -629,7 +629,13 @@ function OutputStream(options) {
     var use_asm = false;
 
     AST_Node.DEFMETHOD("print", function(stream, force_parens) {
-        var self = this;
+        var self = this, generator = self._codegen;
+        function doit() {
+            stream.prepend_comments(self);
+            self.add_source_map(stream);
+            generator(self, stream);
+            stream.append_comments(self);
+        }
         stream.push_node(self);
         if (force_parens || self.needs_parens(stream)) {
             stream.with_parens(doit);
@@ -637,14 +643,9 @@ function OutputStream(options) {
             doit();
         }
         stream.pop_node();
-
-        function doit() {
-            stream.prepend_comments(self);
-            self.add_source_map(stream);
-            self._codegen(stream);
-            stream.append_comments(self);
-        }
     });
+    AST_Node.DEFMETHOD("_print", AST_Node.prototype.print);
+
     AST_Node.DEFMETHOD("print_to_string", function(options) {
         var s = OutputStream(options);
         this.print(s);
@@ -654,149 +655,113 @@ function OutputStream(options) {
     /* -----[ PARENTHESES ]----- */
 
     function PARENS(nodetype, func) {
-        nodetype.DEFMETHOD("needs_parens", func);
+        if (Array.isArray(nodetype)) {
+            nodetype.forEach(function(nodetype) {
+                PARENS(nodetype, func);
+            });
+        } else {
+            nodetype.DEFMETHOD("needs_parens", func);
+        }
     }
 
     PARENS(AST_Node, return_false);
 
     // a function expression needs parens around it when it's provably
     // the first token to appear in a statement.
-    function needs_parens_function(output) {
-        var p = output.parent();
-        if (!output.has_parens() && first_in_statement(output, false, true)) {
-            // export default function() {}
-            // export default (function foo() {});
-            // export default (function() {})(foo);
-            // export default (function() {})`foo`;
-            // export default (function() {}) ? foo : bar;
-            return this.name || !(p instanceof AST_ExportDefault);
+    PARENS(AST_Function, function(output) {
+        if (!output.has_parens() && first_in_statement(output)) return true;
+        if (output.option('webkit')) {
+            var p = output.parent();
+            if (p instanceof AST_PropAccess && p.expression === this) return true;
         }
-        if (output.option("webkit") && p instanceof AST_PropAccess && p.expression === this) return true;
-        if (output.option("wrap_iife") && p instanceof AST_Call && p.expression === this) return true;
-    }
-    PARENS(AST_AsyncFunction, needs_parens_function);
-    PARENS(AST_AsyncGeneratorFunction, needs_parens_function);
-    PARENS(AST_ClassExpression, needs_parens_function);
-    PARENS(AST_Function, needs_parens_function);
-    PARENS(AST_GeneratorFunction, needs_parens_function);
+        if (output.option('wrap_iife')) {
+            var p = output.parent();
+            if (p instanceof AST_Call && p.expression === this) return true;
+        }
+    });
 
     // same goes for an object literal, because otherwise it would be
     // interpreted as a block of code.
-    function needs_parens_obj(output) {
-        return !output.has_parens() && first_in_statement(output, true);
-    }
-    PARENS(AST_Object, needs_parens_obj);
+    PARENS(AST_Object, function(output) {
+        return !output.has_parens() && first_in_statement(output);
+    });
 
-    function needs_parens_unary(output) {
+    PARENS(AST_Unary, function(output) {
         var p = output.parent();
-        // (-x) ** y
-        if (p instanceof AST_Binary) return p.operator == "**" && p.left === this;
-        // (await x)(y)
-        // new (await x)
-        if (p instanceof AST_Call) return p.expression === this;
-        // class extends (x++) {}
-        // class x extends (typeof y) {}
-        if (p instanceof AST_Class) return true;
-        // (x++)[y]
-        // (typeof x).y
-        if (p instanceof AST_PropAccess) return p.expression === this;
-    }
-    PARENS(AST_Await, needs_parens_unary);
-    PARENS(AST_Unary, needs_parens_unary);
+        return p instanceof AST_PropAccess && p.expression === this
+            || p instanceof AST_Call && p.expression === this;
+    });
 
     PARENS(AST_Sequence, function(output) {
         var p = output.parent();
-            // [ 1, (2, 3), 4 ] ---> [ 1, 3, 4 ]
-        return p instanceof AST_Array
-            // () ---> (foo, bar)
-            || is_arrow(p) && p.value === this
-            // await (foo, bar)
-            || p instanceof AST_Await
-            // 1 + (2, 3) + 4 ---> 8
-            || p instanceof AST_Binary
-            // new (foo, bar) or foo(1, (2, 3), 4)
-            || p instanceof AST_Call
-            // class extends (foo, bar) {}
-            // class foo extends (bar, baz) {}
-            || p instanceof AST_Class
-            // class { foo = (bar, baz) }
-            // class { [(foo, bar)]() {} }
-            || p instanceof AST_ClassProperty
-            // (false, true) ? (a = 10, b = 20) : (c = 30)
-            // ---> 20 (side effect, set a := 10 and b := 20)
-            || p instanceof AST_Conditional
-            // [ a = (1, 2) ] = [] ---> a == 2
-            || p instanceof AST_DefaultValue
-            // { [(1, 2)]: foo } = bar
-            // { 1: (2, foo) } = bar
-            || p instanceof AST_DestructuredKeyVal
-            // export default (foo, bar)
-            || p instanceof AST_ExportDefault
-            // for (foo of (bar, baz));
-            || p instanceof AST_ForOf
-            // { [(1, 2)]: 3 }[2] ---> 3
-            // { foo: (1, 2) }.foo ---> 2
-            || p instanceof AST_ObjectProperty
-            // (1, {foo:2}).foo or (1, {foo:2})["foo"] ---> 2
-            || p instanceof AST_PropAccess && p.expression === this
-            // ...(foo, bar, baz)
-            || p instanceof AST_Spread
+            // (foo, bar)() or foo(1, (2, 3), 4)
+        return p instanceof AST_Call
             // !(foo, bar, baz)
             || p instanceof AST_Unary
-            // var a = (1, 2), b = a + a; ---> b == 4
+            // 1 + (2, 3) + 4 ==> 8
+            || p instanceof AST_Binary
+            // var a = (1, 2), b = a + a; ==> b == 4
             || p instanceof AST_VarDef
-            // yield (foo, bar)
-            || p instanceof AST_Yield;
+            // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
+            || p instanceof AST_PropAccess && p.expression === this
+            // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
+            || p instanceof AST_Array
+            // { foo: (1, 2) }.foo ==> 2
+            || p instanceof AST_ObjectProperty
+            // (false, true) ? (a = 10, b = 20) : (c = 30)
+            // ==> 20 (side effect, set a := 10 and b := 20)
+            || p instanceof AST_Conditional;
     });
 
     PARENS(AST_Binary, function(output) {
         var p = output.parent();
-        // await (foo && bar)
-        if (p instanceof AST_Await) return true;
-        // this deals with precedence:
-        //   3 * (2 + 1)
-        //   3 - (2 - 1)
-        //   (1 ** 2) ** 3
+        // (foo && bar)()
+        if (p instanceof AST_Call && p.expression === this)
+            return true;
+        // typeof (foo && bar)
+        if (p instanceof AST_Unary)
+            return true;
+        // (foo && bar)["prop"], (foo && bar).prop
+        if (p instanceof AST_PropAccess && p.expression === this)
+            return true;
+        // this deals with precedence: 3 * (2 + 1)
         if (p instanceof AST_Binary) {
             var po = p.operator, pp = PRECEDENCE[po];
             var so = this.operator, sp = PRECEDENCE[so];
-            return pp > sp
-                || po == "??" && (so == "&&" || so == "||")
-                || (pp == sp && this === p[po == "**" ? "left" : "right"]);
+            if (pp > sp
+                || (pp == sp
+                    && this === p.right)) {
+                return true;
+            }
         }
-        // (foo && bar)()
-        if (p instanceof AST_Call) return p.expression === this;
-        // class extends (foo && bar) {}
-        // class foo extends (bar || null) {}
-        if (p instanceof AST_Class) return true;
-        // (foo && bar)["prop"], (foo && bar).prop
-        if (p instanceof AST_PropAccess) return p.expression === this;
-        // typeof (foo && bar)
-        if (p instanceof AST_Unary) return true;
     });
 
     PARENS(AST_PropAccess, function(output) {
-        var node = this;
         var p = output.parent();
-        if (p instanceof AST_New && p.expression === node) {
-            // i.e. new (foo().bar)
+        if (p instanceof AST_New && p.expression === this) {
+            // i.e. new (foo.bar().baz)
             //
             // if there's one call into this subtree, then we need
             // parens around it too, otherwise the call will be
             // interpreted as passing the arguments to the upper New
             // expression.
-            do {
-                node = node.expression;
-            } while (node instanceof AST_PropAccess);
-            return node.TYPE == "Call";
+            var parens = false;
+            this.walk(new TreeWalker(function(node) {
+                if (parens || node instanceof AST_Scope) return true;
+                if (node instanceof AST_Call) {
+                    parens = true;
+                    return true;
+                }
+            }));
+            return parens;
         }
     });
 
     PARENS(AST_Call, function(output) {
         var p = output.parent();
-        if (p instanceof AST_New) return p.expression === this;
+        if (p instanceof AST_New && p.expression === this) return true;
         // https://bugs.webkit.org/show_bug.cgi?id=123506
-        if (output.option("webkit")) {
+        if (output.option('webkit')) {
             var g = output.parent(1);
             return this.expression instanceof AST_Function
                 && p instanceof AST_PropAccess
@@ -807,69 +772,49 @@ function OutputStream(options) {
     });
 
     PARENS(AST_New, function(output) {
-        if (need_constructor_parens(this, output)) return false;
         var p = output.parent();
-        // (new foo)(bar)
-        if (p instanceof AST_Call) return p.expression === this;
-        // (new Date).getTime(), (new Date)["getTime"]()
-        if (p instanceof AST_PropAccess) return true;
-        // (new foo)`bar`
-        if (p instanceof AST_Template) return p.tag === this;
+        if (!need_constructor_parens(this, output)
+            && (p instanceof AST_PropAccess // (new Date).getTime(), (new Date)["getTime"]()
+                || p instanceof AST_Call && p.expression === this)) // (new foo)(bar)
+            return true;
     });
 
     PARENS(AST_Number, function(output) {
-        if (!output.option("galio")) return false;
-        // https://github.com/mishoo/UglifyJS/pull/1009
         var p = output.parent();
-        return p instanceof AST_PropAccess && p.expression === this && /^0/.test(make_num(this.value));
+        if (p instanceof AST_PropAccess && p.expression === this) {
+            var value = this.value;
+            // https://github.com/mishoo/UglifyJS2/issues/115
+            // https://github.com/mishoo/UglifyJS2/pull/1009
+            if (value < 0 || /^0/.test(make_num(value))) {
+                return true;
+            }
+        }
     });
 
-    function needs_parens_assign_cond(self, output) {
+    PARENS([ AST_Assign, AST_Conditional ], function(output) {
         var p = output.parent();
-        // await (a = foo)
-        if (p instanceof AST_Await) return true;
+        // !(a = false) → true
+        if (p instanceof AST_Unary)
+            return true;
         // 1 + (a = 2) + 3 → 6, side effect setting a = 2
-        if (p instanceof AST_Binary) return !(p instanceof AST_Assign);
+        if (p instanceof AST_Binary && !(p instanceof AST_Assign))
+            return true;
         // (a = func)() —or— new (a = Object)()
-        if (p instanceof AST_Call) return p.expression === self;
-        // class extends (a = foo) {}
-        // class foo extends (bar ? baz : moo) {}
-        if (p instanceof AST_Class) return true;
+        if (p instanceof AST_Call && p.expression === this)
+            return true;
         // (a = foo) ? bar : baz
-        if (p instanceof AST_Conditional) return p.condition === self;
+        if (p instanceof AST_Conditional && p.condition === this)
+            return true;
         // (a = foo)["prop"] —or— (a = foo).prop
-        if (p instanceof AST_PropAccess) return p.expression === self;
-        // (a = foo)`bar`
-        if (p instanceof AST_Template) return p.tag === self;
-        // !(a = false) → true
-        if (p instanceof AST_Unary) return true;
-    }
-    PARENS(AST_Arrow, function(output) {
-        return needs_parens_assign_cond(this, output);
-    });
-    PARENS(AST_Assign, function(output) {
-        if (needs_parens_assign_cond(this, output)) return true;
-        //  v8 parser bug   --->     workaround
-        // f([1], [a] = []) ---> f([1], ([a] = []))
-        if (output.option("v8")) return this.left instanceof AST_Destructured;
-        // ({ p: a } = o);
-        if (this.left instanceof AST_DestructuredObject) return needs_parens_obj(output);
-    });
-    PARENS(AST_AsyncArrow, function(output) {
-        return needs_parens_assign_cond(this, output);
-    });
-    PARENS(AST_Conditional, function(output) {
-        return needs_parens_assign_cond(this, output);
-    });
-    PARENS(AST_Yield, function(output) {
-        return needs_parens_assign_cond(this, output);
+        if (p instanceof AST_PropAccess && p.expression === this)
+            return true;
     });
 
     /* -----[ PRINTERS ]----- */
 
-    DEFPRINT(AST_Directive, function(output) {
-        var quote = this.quote;
-        var value = this.value;
+    DEFPRINT(AST_Directive, function(self, output) {
+        var quote = self.quote;
+        var value = self.value;
         switch (output.option("quote_style")) {
           case 0:
           case 2:
@@ -882,7 +827,7 @@ function OutputStream(options) {
         output.print(quote + value + quote);
         output.semicolon();
     });
-    DEFPRINT(AST_Debugger, function(output) {
+    DEFPRINT(AST_Debugger, function(self, output) {
         output.print("debugger");
         output.semicolon();
     });
@@ -914,17 +859,25 @@ function OutputStream(options) {
         use_asm = was_asm;
     }
 
-    DEFPRINT(AST_Toplevel, function(output) {
-        display_body(this.body, true, output, true);
+    AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output) {
+        force_statement(this.body, output);
+    });
+
+    DEFPRINT(AST_Statement, function(self, output) {
+        self.body.print(output);
+        output.semicolon();
+    });
+    DEFPRINT(AST_Toplevel, function(self, output) {
+        display_body(self.body, true, output, true);
         output.print("");
     });
-    DEFPRINT(AST_LabeledStatement, function(output) {
-        this.label.print(output);
+    DEFPRINT(AST_LabeledStatement, function(self, output) {
+        self.label.print(output);
         output.colon();
-        this.body.print(output);
+        self.body.print(output);
     });
-    DEFPRINT(AST_SimpleStatement, function(output) {
-        this.body.print(output);
+    DEFPRINT(AST_SimpleStatement, function(self, output) {
+        self.body.print(output);
         output.semicolon();
     });
     function print_braced_empty(self, output) {
@@ -941,14 +894,13 @@ function OutputStream(options) {
             });
         } else print_braced_empty(self, output);
     }
-    DEFPRINT(AST_BlockStatement, function(output) {
-        print_braced(this, output);
+    DEFPRINT(AST_BlockStatement, function(self, output) {
+        print_braced(self, output);
     });
-    DEFPRINT(AST_EmptyStatement, function(output) {
+    DEFPRINT(AST_EmptyStatement, function(self, output) {
         output.semicolon();
     });
-    DEFPRINT(AST_Do, function(output) {
-        var self = this;
+    DEFPRINT(AST_Do, function(self, output) {
         output.print("do");
         output.space();
         make_block(self.body, output);
@@ -960,18 +912,16 @@ function OutputStream(options) {
         });
         output.semicolon();
     });
-    DEFPRINT(AST_While, function(output) {
-        var self = this;
+    DEFPRINT(AST_While, function(self, output) {
         output.print("while");
         output.space();
         output.with_parens(function() {
             self.condition.print(output);
         });
         output.space();
-        force_statement(self.body, output);
+        self._do_print_body(output);
     });
-    DEFPRINT(AST_For, function(output) {
-        var self = this;
+    DEFPRINT(AST_For, function(self, output) {
         output.print("for");
         output.space();
         output.with_parens(function() {
@@ -998,273 +948,81 @@ function OutputStream(options) {
             }
         });
         output.space();
-        force_statement(self.body, output);
+        self._do_print_body(output);
     });
-    function print_for_enum(prefix, infix) {
-        return function(output) {
-            var self = this;
-            output.print(prefix);
+    DEFPRINT(AST_ForIn, function(self, output) {
+        output.print("for");
+        output.space();
+        output.with_parens(function() {
+            self.init.print(output);
             output.space();
-            output.with_parens(function() {
-                self.init.print(output);
-                output.space();
-                output.print(infix);
-                output.space();
-                self.object.print(output);
-            });
+            output.print("in");
             output.space();
-            force_statement(self.body, output);
-        };
-    }
-    DEFPRINT(AST_ForAwaitOf, print_for_enum("for await", "of"));
-    DEFPRINT(AST_ForIn, print_for_enum("for", "in"));
-    DEFPRINT(AST_ForOf, print_for_enum("for", "of"));
-    DEFPRINT(AST_With, function(output) {
-        var self = this;
+            self.object.print(output);
+        });
+        output.space();
+        self._do_print_body(output);
+    });
+    DEFPRINT(AST_With, function(self, output) {
         output.print("with");
         output.space();
         output.with_parens(function() {
             self.expression.print(output);
         });
         output.space();
-        force_statement(self.body, output);
-    });
-    DEFPRINT(AST_ExportDeclaration, function(output) {
-        output.print("export");
-        output.space();
-        this.body.print(output);
+        self._do_print_body(output);
     });
-    DEFPRINT(AST_ExportDefault, function(output) {
-        output.print("export");
-        output.space();
-        output.print("default");
-        output.space();
-        var body = this.body;
-        body.print(output);
-        if (body instanceof AST_ClassExpression) {
-            if (!body.name) return;
-        }
-        if (body instanceof AST_DefClass) return;
-        if (body instanceof AST_LambdaDefinition) return;
-        if (body instanceof AST_LambdaExpression) {
-            if (!body.name && !is_arrow(body)) return;
-        }
-        output.semicolon();
-    });
-    DEFPRINT(AST_ExportForeign, function(output) {
-        var self = this;
-        output.print("export");
-        output.space();
-        var len = self.keys.length;
-        if (len == 0) {
-            print_braced_empty(self, output);
-        } else if (self.keys[0] == "*") {
-            print_entry(0);
-        } else output.with_block(function() {
-            output.indent();
-            print_entry(0);
-            for (var i = 1; i < len; i++) {
-                output.print(",");
-                output.newline();
-                output.indent();
-                print_entry(i);
-            }
-            output.newline();
-        });
-        output.space();
-        output.print("from");
-        output.space();
-        output.print_string(self.path, self.quote);
-        output.semicolon();
 
-        function print_entry(index) {
-            var alias = self.aliases[index];
-            var key = self.keys[index];
-            output.print_name(key);
-            if (alias != key) {
-                output.space();
-                output.print("as");
-                output.space();
-                output.print_name(alias);
-            }
-        }
-    });
-    DEFPRINT(AST_ExportReferences, function(output) {
-        var self = this;
-        output.print("export");
-        output.space();
-        print_properties(self, output);
-        output.semicolon();
-    });
-    DEFPRINT(AST_Import, function(output) {
+    /* -----[ functions ]----- */
+    AST_Lambda.DEFMETHOD("_do_print", function(output, nokeyword) {
         var self = this;
-        output.print("import");
-        output.space();
-        if (self.default) self.default.print(output);
-        if (self.all) {
-            if (self.default) output.comma();
-            self.all.print(output);
-        }
-        if (self.properties) {
-            if (self.default) output.comma();
-            print_properties(self, output);
+        if (!nokeyword) {
+            output.print("function");
         }
-        if (self.all || self.default || self.properties) {
-            output.space();
-            output.print("from");
+        if (self.name) {
             output.space();
+            self.name.print(output);
         }
-        output.print_string(self.path, self.quote);
-        output.semicolon();
-    });
-
-    /* -----[ functions ]----- */
-    function print_funargs(self, output) {
         output.with_parens(function() {
             self.argnames.forEach(function(arg, i) {
                 if (i) output.comma();
                 arg.print(output);
             });
-            if (self.rest) {
-                if (self.argnames.length) output.comma();
-                output.print("...");
-                self.rest.print(output);
-            }
         });
-    }
-    function print_arrow(self, output) {
-        if (self.argnames.length == 1 && self.argnames[0] instanceof AST_SymbolFunarg && !self.rest) {
-            self.argnames[0].print(output);
-        } else {
-            print_funargs(self, output);
-        }
-        output.space();
-        output.print("=>");
         output.space();
-        if (self.value) {
-            self.value.print(output);
-        } else {
-            print_braced(self, output, true);
-        }
-    }
-    DEFPRINT(AST_Arrow, function(output) {
-        print_arrow(this, output);
+        print_braced(self, output, true);
     });
-    DEFPRINT(AST_AsyncArrow, function(output) {
-        output.print("async");
-        output.space();
-        print_arrow(this, output);
+    DEFPRINT(AST_Lambda, function(self, output) {
+        self._do_print(output);
     });
-    function print_lambda(self, output) {
-        if (self.name) {
+
+    /* -----[ jumps ]----- */
+    function print_jump(output, kind, target) {
+        output.print(kind);
+        if (target) {
             output.space();
-            self.name.print(output);
+            target.print(output);
         }
-        print_funargs(self, output);
-        output.space();
-        print_braced(self, output, true);
-    }
-    DEFPRINT(AST_Lambda, function(output) {
-        output.print("function");
-        print_lambda(this, output);
-    });
-    function print_async(output) {
-        output.print("async");
-        output.space();
-        output.print("function");
-        print_lambda(this, output);
-    }
-    DEFPRINT(AST_AsyncDefun, print_async);
-    DEFPRINT(AST_AsyncFunction, print_async);
-    function print_async_generator(output) {
-        output.print("async");
-        output.space();
-        output.print("function*");
-        print_lambda(this, output);
-    }
-    DEFPRINT(AST_AsyncGeneratorDefun, print_async_generator);
-    DEFPRINT(AST_AsyncGeneratorFunction, print_async_generator);
-    function print_generator(output) {
-        output.print("function*");
-        print_lambda(this, output);
+        output.semicolon();
     }
-    DEFPRINT(AST_GeneratorDefun, print_generator);
-    DEFPRINT(AST_GeneratorFunction, print_generator);
 
-    /* -----[ classes ]----- */
-    DEFPRINT(AST_Class, function(output) {
-        var self = this;
-        output.print("class");
-        if (self.name) {
-            output.space();
-            self.name.print(output);
-        }
-        if (self.extends) {
-            output.space();
-            output.print("extends");
-            output.space();
-            self.extends.print(output);
-        }
-        output.space();
-        print_properties(self, output, true);
+    DEFPRINT(AST_Return, function(self, output) {
+        print_jump(output, "return", self.value);
     });
-    DEFPRINT(AST_ClassField, function(output) {
-        var self = this;
-        if (self.static) {
-            output.print("static");
-            output.space();
-        }
-        print_property_key(self, output);
-        if (self.value) {
-            output.space();
-            output.print("=");
-            output.space();
-            self.value.print(output);
-        }
-        output.semicolon();
+    DEFPRINT(AST_Throw, function(self, output) {
+        print_jump(output, "throw", self.value);
     });
-    DEFPRINT(AST_ClassGetter, print_accessor("get"));
-    DEFPRINT(AST_ClassSetter, print_accessor("set"));
-    function print_method(self, output) {
-        var fn = self.value;
-        if (is_async(fn)) {
-            output.print("async");
-            output.space();
-        }
-        if (is_generator(fn)) output.print("*");
-        print_property_key(self, output);
-        print_lambda(self.value, output);
-    }
-    DEFPRINT(AST_ClassMethod, function(output) {
-        var self = this;
-        if (self.static) {
-            output.print("static");
-            output.space();
-        }
-        print_method(self, output);
+    DEFPRINT(AST_Break, function(self, output) {
+        print_jump(output, "break", self.label);
+    });
+    DEFPRINT(AST_Continue, function(self, output) {
+        print_jump(output, "continue", self.label);
     });
-
-    /* -----[ jumps ]----- */
-    function print_jump(kind, prop) {
-        return function(output) {
-            output.print(kind);
-            var target = this[prop];
-            if (target) {
-                output.space();
-                target.print(output);
-            }
-            output.semicolon();
-        };
-    }
-    DEFPRINT(AST_Return, print_jump("return", "value"));
-    DEFPRINT(AST_Throw, print_jump("throw", "value"));
-    DEFPRINT(AST_Break, print_jump("break", "label"));
-    DEFPRINT(AST_Continue, print_jump("continue", "label"));
 
     /* -----[ if ]----- */
     function make_then(self, output) {
         var b = self.body;
-        if (output.option("braces") && !(b instanceof AST_Const || b instanceof AST_Let)
+        if (output.option("braces")
             || output.option("ie8") && b instanceof AST_Do)
             return make_block(b, output);
         // The squeezer replaces "block"-s that contain only a single
@@ -1288,8 +1046,7 @@ function OutputStream(options) {
         }
         force_statement(self.body, output);
     }
-    DEFPRINT(AST_If, function(output) {
-        var self = this;
+    DEFPRINT(AST_If, function(self, output) {
         output.print("if");
         output.space();
         output.with_parens(function() {
@@ -1306,13 +1063,12 @@ function OutputStream(options) {
             else
                 force_statement(self.alternative, output);
         } else {
-            force_statement(self.body, output);
+            self._do_print_body(output);
         }
     });
 
     /* -----[ switch ]----- */
-    DEFPRINT(AST_Switch, function(output) {
-        var self = this;
+    DEFPRINT(AST_Switch, function(self, output) {
         output.print("switch");
         output.space();
         output.with_parens(function() {
@@ -1330,30 +1086,28 @@ function OutputStream(options) {
             });
         });
     });
-    function print_branch_body(self, output) {
+    AST_SwitchBranch.DEFMETHOD("_do_print_body", function(output) {
         output.newline();
-        self.body.forEach(function(stmt) {
+        this.body.forEach(function(stmt) {
             output.indent();
             stmt.print(output);
             output.newline();
         });
-    }
-    DEFPRINT(AST_Default, function(output) {
+    });
+    DEFPRINT(AST_Default, function(self, output) {
         output.print("default:");
-        print_branch_body(this, output);
+        self._do_print_body(output);
     });
-    DEFPRINT(AST_Case, function(output) {
-        var self = this;
+    DEFPRINT(AST_Case, function(self, output) {
         output.print("case");
         output.space();
         self.expression.print(output);
         output.print(":");
-        print_branch_body(self, output);
+        self._do_print_body(output);
     });
 
     /* -----[ exceptions ]----- */
-    DEFPRINT(AST_Try, function(output) {
-        var self = this;
+    DEFPRINT(AST_Try, function(self, output) {
         output.print("try");
         output.space();
         print_braced(self, output);
@@ -1366,77 +1120,63 @@ function OutputStream(options) {
             self.bfinally.print(output);
         }
     });
-    DEFPRINT(AST_Catch, function(output) {
-        var self = this;
+    DEFPRINT(AST_Catch, function(self, output) {
         output.print("catch");
-        if (self.argname) {
-            output.space();
-            output.with_parens(function() {
-                self.argname.print(output);
-            });
-        }
+        output.space();
+        output.with_parens(function() {
+            self.argname.print(output);
+        });
         output.space();
         print_braced(self, output);
     });
-    DEFPRINT(AST_Finally, function(output) {
+    DEFPRINT(AST_Finally, function(self, output) {
         output.print("finally");
         output.space();
-        print_braced(this, output);
+        print_braced(self, output);
     });
 
-    function print_definitinos(type) {
-        return function(output) {
-            var self = this;
-            output.print(type);
-            output.space();
-            self.definitions.forEach(function(def, i) {
-                if (i) output.comma();
-                def.print(output);
-            });
-            var p = output.parent();
-            if (!(p instanceof AST_IterationStatement && p.init === self)) output.semicolon();
-        };
-    }
-    DEFPRINT(AST_Const, print_definitinos("const"));
-    DEFPRINT(AST_Let, print_definitinos("let"));
-    DEFPRINT(AST_Var, print_definitinos("var"));
+    DEFPRINT(AST_Var, function(self, output) {
+        output.print("var");
+        output.space();
+        self.definitions.forEach(function(def, i) {
+            if (i) output.comma();
+            def.print(output);
+        });
+        var p = output.parent();
+        if (p && p.init !== self || !(p instanceof AST_For || p instanceof AST_ForIn)) output.semicolon();
+    });
 
     function parenthesize_for_noin(node, output, noin) {
         var parens = false;
         // need to take some precautions here:
-        //    https://github.com/mishoo/UglifyJS/issues/60
+        //    https://github.com/mishoo/UglifyJS2/issues/60
         if (noin) node.walk(new TreeWalker(function(node) {
-            if (parens) return true;
-            if (node instanceof AST_Binary && node.operator == "in") return parens = true;
-            if (node instanceof AST_Scope && !(is_arrow(node) && node.value)) return true;
+            if (parens || node instanceof AST_Scope) return true;
+            if (node instanceof AST_Binary && node.operator == "in") {
+                parens = true;
+                return true;
+            }
         }));
         node.print(output, parens);
     }
 
-    DEFPRINT(AST_VarDef, function(output) {
-        var self = this;
+    DEFPRINT(AST_VarDef, function(self, output) {
         self.name.print(output);
         if (self.value) {
             output.space();
             output.print("=");
             output.space();
             var p = output.parent(1);
-            var noin = p instanceof AST_For || p instanceof AST_ForEnumeration;
+            var noin = p instanceof AST_For || p instanceof AST_ForIn;
             parenthesize_for_noin(self.value, output, noin);
         }
     });
 
-    DEFPRINT(AST_DefaultValue, function(output) {
-        var self = this;
-        self.name.print(output);
-        output.space();
-        output.print("=");
-        output.space();
-        self.value.print(output);
-    });
-
     /* -----[ other expressions ]----- */
-    function print_call_args(self, output) {
+    DEFPRINT(AST_Call, function(self, output) {
+        self.expression.print(output);
+        if (self instanceof AST_New && !need_constructor_parens(self, output))
+            return;
         if (self.expression instanceof AST_Call || self.expression instanceof AST_Lambda) {
             output.add_mapping(self.start);
         }
@@ -1446,20 +1186,14 @@ function OutputStream(options) {
                 expr.print(output);
             });
         });
-    }
-    DEFPRINT(AST_Call, function(output) {
-        this.expression.print(output);
-        print_call_args(this, output);
     });
-    DEFPRINT(AST_New, function(output) {
-        var self = this;
+    DEFPRINT(AST_New, function(self, output) {
         output.print("new");
         output.space();
-        self.expression.print(output);
-        if (need_constructor_parens(self, output)) print_call_args(self, output);
+        AST_Call.prototype._codegen(self, output);
     });
-    DEFPRINT(AST_Sequence, function(output) {
-        this.expressions.forEach(function(node, index) {
+    DEFPRINT(AST_Sequence, function(self, output) {
+        self.expressions.forEach(function(node, index) {
             if (index > 0) {
                 output.comma();
                 if (output.should_break()) {
@@ -1470,8 +1204,7 @@ function OutputStream(options) {
             node.print(output);
         });
     });
-    DEFPRINT(AST_Dot, function(output) {
-        var self = this;
+    DEFPRINT(AST_Dot, function(self, output) {
         var expr = self.expression;
         expr.print(output);
         var prop = self.property;
@@ -1492,42 +1225,35 @@ function OutputStream(options) {
             output.print_name(prop);
         }
     });
-    DEFPRINT(AST_Sub, function(output) {
-        this.expression.print(output);
+    DEFPRINT(AST_Sub, function(self, output) {
+        self.expression.print(output);
         output.print("[");
-        this.property.print(output);
+        self.property.print(output);
         output.print("]");
     });
-    DEFPRINT(AST_Spread, function(output) {
-        output.print("...");
-        this.expression.print(output);
-    });
-    DEFPRINT(AST_UnaryPrefix, function(output) {
-        var op = this.operator;
-        var exp = this.expression;
+    DEFPRINT(AST_UnaryPrefix, function(self, output) {
+        var op = self.operator;
         output.print(op);
         if (/^[a-z]/i.test(op)
             || (/[+-]$/.test(op)
-                && exp instanceof AST_UnaryPrefix
-                && /^[+-]/.test(exp.operator))) {
+                && self.expression instanceof AST_UnaryPrefix
+                && /^[+-]/.test(self.expression.operator))) {
             output.space();
         }
-        exp.print(output);
+        self.expression.print(output);
     });
-    DEFPRINT(AST_UnaryPostfix, function(output) {
-        this.expression.print(output);
-        output.print(this.operator);
+    DEFPRINT(AST_UnaryPostfix, function(self, output) {
+        self.expression.print(output);
+        output.print(self.operator);
     });
-    DEFPRINT(AST_Binary, function(output) {
-        var self = this;
+    DEFPRINT(AST_Binary, function(self, output) {
         self.left.print(output);
         output.space();
         output.print(self.operator);
         output.space();
         self.right.print(output);
     });
-    DEFPRINT(AST_Conditional, function(output) {
-        var self = this;
+    DEFPRINT(AST_Conditional, function(self, output) {
         self.condition.print(output);
         output.space();
         output.print("?");
@@ -1537,24 +1263,12 @@ function OutputStream(options) {
         output.colon();
         self.alternative.print(output);
     });
-    DEFPRINT(AST_Await, function(output) {
-        output.print("await");
-        output.space();
-        this.expression.print(output);
-    });
-    DEFPRINT(AST_Yield, function(output) {
-        output.print(this.nested ? "yield*" : "yield");
-        if (this.expression) {
-            output.space();
-            this.expression.print(output);
-        }
-    });
 
     /* -----[ literals ]----- */
-    DEFPRINT(AST_Array, function(output) {
-        var a = this.elements, len = a.length;
-        output.with_square(len > 0 ? function() {
-            output.space();
+    DEFPRINT(AST_Array, function(self, output) {
+        output.with_square(function() {
+            var a = self.elements, len = a.length;
+            if (len > 0) output.space();
             a.forEach(function(exp, i) {
                 if (i) output.comma();
                 exp.print(output);
@@ -1564,61 +1278,14 @@ function OutputStream(options) {
                 if (i === len - 1 && exp instanceof AST_Hole)
                   output.comma();
             });
-            output.space();
-        } : noop);
-    });
-    DEFPRINT(AST_DestructuredArray, function(output) {
-        var a = this.elements, len = a.length, rest = this.rest;
-        output.with_square(len || rest ? function() {
-            output.space();
-            a.forEach(function(exp, i) {
-                if (i) output.comma();
-                exp.print(output);
-            });
-            if (rest) {
-                if (len) output.comma();
-                output.print("...");
-                rest.print(output);
-            } else if (a[len - 1] instanceof AST_Hole) {
-                // If the final element is a hole, we need to make sure it
-                // doesn't look like a trailing comma, by inserting an actual
-                // trailing comma.
-                output.comma();
-            }
-            output.space();
-        } : noop);
-    });
-    DEFPRINT(AST_DestructuredKeyVal, print_key_value);
-    DEFPRINT(AST_DestructuredObject, function(output) {
-        var props = this.properties, len = props.length, rest = this.rest;
-        if (len || rest) output.with_block(function() {
-            props.forEach(function(prop, i) {
-                if (i) {
-                    output.print(",");
-                    output.newline();
-                }
-                output.indent();
-                prop.print(output);
-            });
-            if (rest) {
-                if (len) {
-                    output.print(",");
-                    output.newline();
-                }
-                output.indent();
-                output.print("...");
-                rest.print(output);
-            }
-            output.newline();
+            if (len > 0) output.space();
         });
-        else print_braced_empty(this, output);
     });
-    function print_properties(self, output, no_comma) {
-        var props = self.properties;
-        if (props.length > 0) output.with_block(function() {
-            props.forEach(function(prop, i) {
+    DEFPRINT(AST_Object, function(self, output) {
+        if (self.properties.length > 0) output.with_block(function() {
+            self.properties.forEach(function(prop, i) {
                 if (i) {
-                    if (!no_comma) output.print(",");
+                    output.print(",");
                     output.newline();
                 }
                 output.indent();
@@ -1627,120 +1294,65 @@ function OutputStream(options) {
             output.newline();
         });
         else print_braced_empty(self, output);
-    }
-    DEFPRINT(AST_Object, function(output) {
-        print_properties(this, output);
     });
 
-    function print_property_key(self, output) {
-        var key = self.key;
-        if (key instanceof AST_Node) {
-            output.with_square(function() {
-                key.print(output);
-            });
-        } else if (output.option("quote_keys")) {
+    function print_property_name(key, quote, output) {
+        if (output.option("quote_keys")) {
             output.print_string(key);
         } else if ("" + +key == key && key >= 0) {
             output.print(make_num(key));
-        } else {
-            var quote = self.start && self.start.quote;
-            if (self.private) {
-                output.print_name(key);
-            } else if (RESERVED_WORDS[key] ? !output.option("ie8") : is_identifier_string(key)) {
-                if (quote && output.option("keep_quoted_props")) {
-                    output.print_string(key, quote);
-                } else {
-                    output.print_name(key);
-                }
-            } else {
+        } else if (RESERVED_WORDS[key] ? !output.option("ie8") : is_identifier_string(key)) {
+            if (quote && output.option("keep_quoted_props")) {
                 output.print_string(key, quote);
+            } else {
+                output.print_name(key);
             }
+        } else {
+            output.print_string(key, quote);
         }
     }
 
-    function print_key_value(output) {
-        var self = this;
-        print_property_key(self, output);
+    DEFPRINT(AST_ObjectKeyVal, function(self, output) {
+        print_property_name(self.key, self.quote, output);
         output.colon();
         self.value.print(output);
-    }
-    DEFPRINT(AST_ObjectKeyVal, print_key_value);
-    DEFPRINT(AST_ObjectMethod, function(output) {
-        print_method(this, output);
-    });
-    function print_accessor(type) {
-        return function(output) {
-            var self = this;
-            if (self.static) {
-                output.print("static");
-                output.space();
-            }
-            output.print(type);
-            output.space();
-            print_property_key(self, output);
-            print_lambda(self.value, output);
-        };
-    }
-    DEFPRINT(AST_ObjectGetter, print_accessor("get"));
-    DEFPRINT(AST_ObjectSetter, print_accessor("set"));
-    function print_symbol(self, output) {
-        var def = self.definition();
-        output.print_name(def && def.mangled_name || self.name);
-    }
-    DEFPRINT(AST_Symbol, function(output) {
-        print_symbol(this, output);
     });
-    DEFPRINT(AST_SymbolExport, function(output) {
-        var self = this;
-        print_symbol(self, output);
-        if (self.alias) {
-            output.space();
-            output.print("as");
-            output.space();
-            output.print_name(self.alias);
-        }
+    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
+        output.print(type);
+        output.space();
+        print_property_name(this.key.name, this.quote, output);
+        this.value._do_print(output, true);
     });
-    DEFPRINT(AST_SymbolImport, function(output) {
-        var self = this;
-        if (self.key) {
-            output.print_name(self.key);
-            output.space();
-            output.print("as");
-            output.space();
-        }
-        print_symbol(self, output);
+    DEFPRINT(AST_ObjectSetter, function(self, output) {
+        self._print_getter_setter("set", output);
+    });
+    DEFPRINT(AST_ObjectGetter, function(self, output) {
+        self._print_getter_setter("get", output);
+    });
+    DEFPRINT(AST_Symbol, function(self, output) {
+        var def = self.definition();
+        output.print_name(def && def.mangled_name || self.name);
     });
     DEFPRINT(AST_Hole, noop);
-    DEFPRINT(AST_Template, function(output) {
-        var self = this;
-        if (self.tag) self.tag.print(output);
-        output.print("`");
-        for (var i = 0; i < self.expressions.length; i++) {
-            output.print(self.strings[i]);
-            output.print("${");
-            self.expressions[i].print(output);
-            output.print("}");
-        }
-        output.print(self.strings[i]);
-        output.print("`");
+    DEFPRINT(AST_This, function(self, output) {
+        output.print("this");
     });
-    DEFPRINT(AST_Constant, function(output) {
-        output.print(this.value);
+    DEFPRINT(AST_Constant, function(self, output) {
+        output.print(self.value);
     });
-    DEFPRINT(AST_String, function(output) {
-        output.print_string(this.value, this.quote);
+    DEFPRINT(AST_String, function(self, output) {
+        output.print_string(self.value, self.quote);
     });
-    DEFPRINT(AST_Number, function(output) {
-        var start = this.start;
-        if (use_asm && start && start.raw != null) {
-            output.print(start.raw);
+    DEFPRINT(AST_Number, function(self, output) {
+        if (use_asm && self.start && self.start.raw != null) {
+            output.print(self.start.raw);
         } else {
-            output.print(make_num(this.value));
+            output.print(make_num(self.value));
         }
     });
 
-    DEFPRINT(AST_RegExp, function(output) {
-        var regexp = this.value;
+    DEFPRINT(AST_RegExp, function(self, output) {
+        var regexp = self.value;
         var str = regexp.toString();
         var end = str.lastIndexOf("/");
         if (regexp.raw_source) {
@@ -1774,17 +1386,18 @@ function OutputStream(options) {
             }
         }));
         var p = output.parent();
-        if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === this)
+        if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === self)
             output.print(" ");
     });
 
     function force_statement(stat, output) {
-        if (output.option("braces") && !(stat instanceof AST_Const || stat instanceof AST_Let)) {
+        if (output.option("braces")) {
             make_block(stat, output);
-        } else if (!stat || stat instanceof AST_EmptyStatement) {
-            output.force_semicolon();
         } else {
-            stat.print(output);
+            if (!stat || stat instanceof AST_EmptyStatement)
+                output.force_semicolon();
+            else
+                stat.print(output);
         }
     }
 
@@ -1857,6 +1470,7 @@ function OutputStream(options) {
         AST_Node,
         // since the label symbol will mark it
         AST_LabeledStatement,
+        AST_Toplevel,
     ], noop);
 
     // XXX: I'm not exactly sure if we need it for all of these nodes,
@@ -1868,7 +1482,7 @@ function OutputStream(options) {
         AST_Constant,
         AST_Debugger,
         AST_Definitions,
-        AST_Destructured,
+        AST_Directive,
         AST_Finally,
         AST_Jump,
         AST_Lambda,
@@ -1883,7 +1497,14 @@ function OutputStream(options) {
         output.add_mapping(this.start);
     });
 
-    DEFMAP([ AST_DestructuredKeyVal, AST_ObjectProperty ], function(output) {
-        if (typeof this.key == "string") output.add_mapping(this.start, this.key);
+    DEFMAP([
+        AST_ObjectGetter,
+        AST_ObjectSetter,
+     ], function(output) {
+        output.add_mapping(this.start, this.key.name);
+    });
+
+    DEFMAP([ AST_ObjectProperty ], function(output) {
+        output.add_mapping(this.start, this.key);
     });
 })();