pdf-creator-node 2.3.4 → 2.3.5

package/example/node_modules/pdf-creator-node/example/node_modules/uglify-js/lib/scope.js

@@ -1,7 +1,7 @@
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS
+  https://github.com/mishoo/UglifyJS2
 
   -------------------------------- (C) ---------------------------------
 
@@ -43,36 +43,42 @@
 
 "use strict";
 
-function SymbolDef(id, scope, orig, init) {
-    this.eliminated = 0;
-    this.exported = false;
-    this.global = false;
-    this.id = id;
-    this.init = init;
-    this.mangled_name = null;
+function SymbolDef(scope, orig, init) {
     this.name = orig.name;
     this.orig = [ orig ];
+    this.init = init;
+    this.eliminated = 0;
+    this.scope = scope;
     this.references = [];
     this.replaced = 0;
-    this.scope = scope;
+    this.global = false;
+    this.mangled_name = null;
     this.undeclared = false;
+    this.id = SymbolDef.next_id++;
+    this.lambda = orig instanceof AST_SymbolLambda;
 }
 
+SymbolDef.next_id = 1;
+
 SymbolDef.prototype = {
-    forEach: function(fn) {
-        this.orig.forEach(fn);
-        this.references.forEach(fn);
+    unmangleable: function(options) {
+        return this.global && !options.toplevel
+            || this.undeclared
+            || !options.eval && this.scope.pinned()
+            || options.keep_fnames
+                && (this.orig[0] instanceof AST_SymbolLambda
+                    || this.orig[0] instanceof AST_SymbolDefun);
     },
     mangle: function(options) {
         var cache = options.cache && options.cache.props;
         if (this.global && cache && cache.has(this.name)) {
             this.mangled_name = cache.get(this.name);
         } else if (!this.mangled_name && !this.unmangleable(options)) {
-            var def = this.redefined();
-            if (def) {
+            var def;
+            if (def = this.redefined()) {
                 this.mangled_name = def.mangled_name || def.name;
             } else {
-                this.mangled_name = next_mangled_name(this, options);
+                this.mangled_name = next_mangled_name(this.scope, options, this);
             }
             if (this.global && cache) {
                 cache.set(this.name, this.mangled_name);
@@ -80,38 +86,10 @@ SymbolDef.prototype = {
         }
     },
     redefined: function() {
-        var scope = this.defun;
-        if (!scope) return;
-        var name = this.name;
-        var def = scope.variables.get(name)
-            || scope instanceof AST_Toplevel && scope.globals.get(name)
-            || this.orig[0] instanceof AST_SymbolConst && find_if(function(def) {
-                return def.name == name;
-            }, scope.enclosed);
-        if (def && def !== this) return def.redefined() || def;
-    },
-    unmangleable: function(options) {
-        return this.global && !options.toplevel
-            || this.exported
-            || this.undeclared
-            || !options.eval && this.scope.pinned()
-            || options.keep_fnames
-                && (this.orig[0] instanceof AST_SymbolLambda
-                    || this.orig[0] instanceof AST_SymbolDefun);
-    },
+        return this.defun && this.defun.variables.get(this.name);
+    }
 };
 
-var unary_side_effects = makePredicate("delete ++ --");
-
-function is_lhs(node, parent) {
-    if (parent instanceof AST_Assign) return parent.left === node && node;
-    if (parent instanceof AST_DefaultValue) return parent.name === node && node;
-    if (parent instanceof AST_Destructured) return node;
-    if (parent instanceof AST_DestructuredKeyVal) return node;
-    if (parent instanceof AST_ForEnumeration) return parent.init === node && node;
-    if (parent instanceof AST_Unary) return unary_side_effects[parent.operator] && parent.expression;
-}
-
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     options = defaults(options, {
         cache: null,
@@ -120,71 +98,30 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
 
     // pass 1: setup scope chaining and handle definitions
     var self = this;
-    var defun = null;
-    var exported = false;
-    var next_def_id = 0;
     var scope = self.parent_scope = null;
+    var defun = null;
     var tw = new TreeWalker(function(node, descend) {
-        if (node instanceof AST_DefClass) {
-            var save_exported = exported;
-            exported = tw.parent() instanceof AST_ExportDeclaration;
-            node.name.walk(tw);
-            exported = save_exported;
-            walk_scope(function() {
-                if (node.extends) node.extends.walk(tw);
-                node.properties.forEach(function(prop) {
-                    prop.walk(tw);
-                });
-            });
-            return true;
-        }
-        if (node instanceof AST_Definitions) {
-            var save_exported = exported;
-            exported = tw.parent() instanceof AST_ExportDeclaration;
+        if (node instanceof AST_Catch) {
+            var save_scope = scope;
+            scope = new AST_Scope(node);
+            scope.init_scope_vars(save_scope);
             descend();
-            exported = save_exported;
-            return true;
-        }
-        if (node instanceof AST_LambdaDefinition) {
-            var save_exported = exported;
-            exported = tw.parent() instanceof AST_ExportDeclaration;
-            node.name.walk(tw);
-            exported = save_exported;
-            walk_scope(function() {
-                node.argnames.forEach(function(argname) {
-                    argname.walk(tw);
-                });
-                if (node.rest) node.rest.walk(tw);
-                walk_body(node, tw);
-            });
+            scope = save_scope;
             return true;
         }
-        if (node instanceof AST_SwitchBranch) {
-            node.init_vars(scope);
+        if (node instanceof AST_Scope) {
+            node.init_scope_vars(scope);
+            var save_scope = scope;
+            var save_defun = defun;
+            defun = scope = node;
             descend();
-            return true;
-        }
-        if (node instanceof AST_Try) {
-            walk_scope(function() {
-                walk_body(node, tw);
-            });
-            if (node.bcatch) node.bcatch.walk(tw);
-            if (node.bfinally) node.bfinally.walk(tw);
+            scope = save_scope;
+            defun = save_defun;
             return true;
         }
         if (node instanceof AST_With) {
-            var s = scope;
-            do {
-                s = s.resolve();
-                if (s.uses_with) break;
-                s.uses_with = true;
-            } while (s = s.parent_scope);
-            walk_scope(descend);
-            return true;
-        }
-        if (node instanceof AST_BlockScope) {
-            walk_scope(descend);
-            return true;
+            for (var s = scope; s; s = s.parent_scope) s.uses_with = true;
+            return;
         }
         if (node instanceof AST_Symbol) {
             node.scope = scope;
@@ -193,152 +130,62 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             node.thedef = node;
             node.references = [];
         }
-        if (node instanceof AST_SymbolCatch) {
-            scope.def_variable(node).defun = defun;
-        } else if (node instanceof AST_SymbolConst) {
-            var def = scope.def_variable(node);
-            def.defun = defun;
-            def.exported = exported;
-        } else if (node instanceof AST_SymbolDefun) {
-            defun.def_function(node, tw.parent()).exported = exported;
-            entangle(defun, scope);
-        } else if (node instanceof AST_SymbolFunarg) {
-            defun.def_variable(node);
-            entangle(defun, scope);
+        if (node instanceof AST_SymbolDefun) {
+            // This should be defined in the parent scope, as we encounter the
+            // AST_Defun node before getting to its AST_Symbol.
+            (node.scope = defun.parent_scope.resolve()).def_function(node, defun);
         } else if (node instanceof AST_SymbolLambda) {
             var def = defun.def_function(node, node.name == "arguments" ? undefined : defun);
             if (options.ie8) def.defun = defun.parent_scope.resolve();
-        } else if (node instanceof AST_SymbolLet) {
-            scope.def_variable(node).exported = exported;
         } else if (node instanceof AST_SymbolVar) {
-            defun.def_variable(node, node instanceof AST_SymbolImport ? undefined : null).exported = exported;
-            entangle(defun, scope);
-        }
-
-        function walk_scope(descend) {
-            node.init_vars(scope);
-            var save_defun = defun;
-            var save_scope = scope;
-            if (node instanceof AST_Scope) defun = node;
-            scope = node;
-            descend();
-            scope = save_scope;
-            defun = save_defun;
-        }
-
-        function entangle(defun, scope) {
-            if (defun === scope) return;
-            node.mark_enclosed(options);
-            var def = scope.find_variable(node.name);
-            if (node.thedef === def) return;
-            node.thedef = def;
-            def.orig.push(node);
-            node.mark_enclosed(options);
+            defun.def_variable(node, node.TYPE == "SymbolVar" ? null : undefined);
+            if (defun !== scope) {
+                node.mark_enclosed(options);
+                var def = scope.find_variable(node);
+                if (node.thedef !== def) {
+                    node.thedef = def;
+                }
+                node.reference(options);
+            }
+        } else if (node instanceof AST_SymbolCatch) {
+            scope.def_variable(node).defun = defun;
         }
     });
-    self.make_def = function(orig, init) {
-        return new SymbolDef(++next_def_id, this, orig, init);
-    };
     self.walk(tw);
 
     // pass 2: find back references and eval
     self.globals = new Dictionary();
-    var in_arg = [];
     var tw = new TreeWalker(function(node) {
-        if (node instanceof AST_Catch) {
-            if (!(node.argname instanceof AST_Destructured)) return;
-            in_arg.push(node);
-            node.argname.walk(tw);
-            in_arg.pop();
-            walk_body(node, tw);
-            return true;
-        }
-        if (node instanceof AST_Lambda) {
-            in_arg.push(node);
-            node.argnames.forEach(function(argname) {
-                argname.walk(tw);
-            });
-            if (node.rest) node.rest.walk(tw);
-            in_arg.pop();
-            walk_lambda(node, tw);
-            return true;
-        }
         if (node instanceof AST_LoopControl) {
             if (node.label) node.label.thedef.references.push(node);
             return true;
         }
-        if (node instanceof AST_SymbolDeclaration) {
-            if (node instanceof AST_SymbolCatch) {
-                // ensure mangling works if `catch` reuses a scope variable
-                var def = node.definition().redefined();
-                if (def) for (var s = node.scope; s; s = s.parent_scope) {
-                    push_uniq(s.enclosed, def);
-                    if (s === def.scope) break;
-                }
-            } else if (node instanceof AST_SymbolConst) {
-                // ensure compression works if `const` reuses a scope variable
-                var redef = node.definition().redefined();
-                if (redef) redef.const_redefs = true;
-            }
-            if (node.name != "arguments") return true;
-            var parent = node instanceof AST_SymbolVar && tw.parent();
-            if (parent instanceof AST_VarDef && !parent.value) return true;
-            var sym = node.scope.resolve().find_variable("arguments");
-            if (sym && is_arguments(sym)) sym.scope.uses_arguments = 3;
-            return true;
-        }
         if (node instanceof AST_SymbolRef) {
             var name = node.name;
-            var sym = node.scope.find_variable(name);
-            for (var i = in_arg.length; i > 0 && sym;) {
-                i = in_arg.lastIndexOf(sym.scope, i - 1);
-                if (i < 0) break;
-                var decl = sym.orig[0];
-                if (decl instanceof AST_SymbolCatch
-                    || decl instanceof AST_SymbolFunarg
-                    || decl instanceof AST_SymbolLambda) {
-                    node.in_arg = true;
-                    break;
+            if (name == "eval" && tw.parent() instanceof AST_Call) {
+                for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) {
+                    s.uses_eval = true;
                 }
-                sym = sym.scope.parent_scope.find_variable(name);
             }
+            var sym = node.scope.find_variable(name);
             if (!sym) {
                 sym = self.def_global(node);
-            } else if (name == "arguments" && is_arguments(sym)) {
-                var parent = tw.parent();
-                if (is_lhs(node, parent)) {
-                    sym.scope.uses_arguments = 3;
-                } else if (sym.scope.uses_arguments < 2
-                    && !(parent instanceof AST_PropAccess && parent.expression === node)) {
-                    sym.scope.uses_arguments = 2;
-                } else if (!sym.scope.uses_arguments) {
-                    sym.scope.uses_arguments = true;
-                }
-            }
-            if (name == "eval") {
-                var parent = tw.parent();
-                if (parent.TYPE == "Call" && parent.expression === node) {
-                    var s = node.scope;
-                    do {
-                        s = s.resolve();
-                        if (s.uses_eval) break;
-                        s.uses_eval = true;
-                    } while (s = s.parent_scope);
-                } else if (sym.undeclared) {
-                    self.uses_eval = true;
-                }
-            }
-            if (sym.init instanceof AST_LambdaDefinition && sym.scope !== sym.init.name.scope) {
-                var scope = node.scope;
-                do {
-                    if (scope === sym.init.name.scope) break;
-                } while (scope = scope.parent_scope);
-                if (!scope) sym.init = undefined;
+            } else if (sym.scope instanceof AST_Lambda && name == "arguments") {
+                sym.scope.uses_arguments = true;
             }
             node.thedef = sym;
             node.reference(options);
             return true;
         }
+        // ensure mangling works if catch reuses a scope variable
+        if (node instanceof AST_SymbolCatch) {
+            var def = node.definition().redefined();
+            if (def) for (var s = node.scope; s; s = s.parent_scope) {
+                push_uniq(s.enclosed, def);
+                if (s === def.scope) break;
+            }
+            return true;
+        }
     });
     self.walk(tw);
 
@@ -354,9 +201,8 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         }
         if (node instanceof AST_SymbolLambda) {
             var def = node.thedef;
-            if (!redefine(node, node.scope.parent_scope.resolve())) {
-                delete def.defun;
-            } else if (typeof node.thedef.init !== "undefined") {
+            redefine(node, node.scope.parent_scope.resolve());
+            if (typeof node.thedef.init !== "undefined") {
                 node.thedef.init = false;
             } else if (def.init) {
                 node.thedef.init = def.init;
@@ -365,22 +211,13 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         }
     }));
 
-    function is_arguments(sym) {
-        return sym.orig[0] instanceof AST_SymbolFunarg
-            && !(sym.orig[1] instanceof AST_SymbolFunarg || sym.orig[2] instanceof AST_SymbolFunarg)
-            && !is_arrow(sym.scope);
-    }
-
     function redefine(node, scope) {
         var name = node.name;
         var old_def = node.thedef;
-        if (!all(old_def.orig, function(sym) {
-            return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet);
-        })) return false;
         var new_def = scope.find_variable(name);
         if (new_def) {
-            var redef = new_def.redefined();
-            if (redef) new_def = redef;
+            var redef;
+            while (redef = new_def.redefined()) new_def = redef;
         } else {
             new_def = self.globals.get(name);
         }
@@ -389,14 +226,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         } else {
             new_def = scope.def_variable(node);
         }
-        old_def.defun = new_def.scope;
-        old_def.forEach(function(node) {
-            node.redef = old_def;
+        old_def.orig.concat(old_def.references).forEach(function(node) {
             node.thedef = new_def;
             node.reference(options);
         });
+        if (old_def.lambda) new_def.lambda = true;
         if (new_def.undeclared) self.variables.set(name, new_def);
-        return true;
     }
 });
 
@@ -405,7 +240,7 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
     if (globals.has(name)) {
         return globals.get(name);
     } else {
-        var g = this.make_def(node);
+        var g = new SymbolDef(this, node);
         g.undeclared = true;
         g.global = true;
         globals.set(name, g);
@@ -413,50 +248,31 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
     }
 });
 
-function init_block_vars(scope, parent) {
-    scope.enclosed = [];                            // variables from this or outer scope(s) that are referenced from this or inner scopes
-    scope.parent_scope = parent;                    // the parent scope (null if this is the top level)
-    scope.functions = new Dictionary();             // map name to AST_SymbolDefun (functions defined in this scope)
-    scope.variables = new Dictionary();             // map name to AST_SymbolVar (variables defined in this scope; includes functions)
-    if (parent) scope.make_def = parent.make_def;   // top-level tracking of SymbolDef instances
-}
-
-function init_scope_vars(scope, parent) {
-    init_block_vars(scope, parent);
-    scope.uses_eval = false;                        // will be set to true if this or nested scope uses the global `eval`
-    scope.uses_with = false;                        // will be set to true if this or some nested scope uses the `with` statement
-}
-
-AST_BlockScope.DEFMETHOD("init_vars", function(parent_scope) {
-    init_block_vars(this, parent_scope);
+AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope) {
+    this.variables = new Dictionary();  // map name to AST_SymbolVar (variables defined in this scope; includes functions)
+    this.functions = new Dictionary();  // map name to AST_SymbolDefun (functions defined in this scope)
+    this.uses_with = false;             // will be set to true if this or some nested scope uses the `with` statement
+    this.uses_eval = false;             // will be set to true if this or nested scope uses the global `eval`
+    this.parent_scope = parent_scope;   // the parent scope
+    this.enclosed = [];                 // a list of variables from this or outer scope(s) that are referenced from this or inner scopes
+    this.cname = -1;                    // the current index for mangling functions/variables
 });
-AST_Scope.DEFMETHOD("init_vars", function(parent_scope) {
-    init_scope_vars(this, parent_scope);
-});
-AST_Arrow.DEFMETHOD("init_vars", function(parent_scope) {
-    init_scope_vars(this, parent_scope);
-});
-AST_AsyncArrow.DEFMETHOD("init_vars", function(parent_scope) {
-    init_scope_vars(this, parent_scope);
-});
-AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
-    init_scope_vars(this, parent_scope);
+
+AST_Lambda.DEFMETHOD("init_scope_vars", function() {
+    AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
     this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
         start: this.start,
-        end: this.end,
+        end: this.end
     }));
-    return this;
 });
 
 AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
     var def = this.definition();
     for (var s = this.scope; s; s = s.parent_scope) {
         push_uniq(s.enclosed, def);
-        if (!options) {
-            delete s._var_names;
-        } else if (options.keep_fnames) {
+        if (options.keep_fnames) {
             s.functions.each(function(d) {
                 push_uniq(def.scope.enclosed, d);
             });
@@ -470,37 +286,43 @@ AST_Symbol.DEFMETHOD("reference", function(options) {
     this.mark_enclosed(options);
 });
 
-AST_BlockScope.DEFMETHOD("find_variable", function(name) {
+AST_Scope.DEFMETHOD("find_variable", function(name) {
+    if (name instanceof AST_Symbol) name = name.name;
     return this.variables.get(name)
-        || this.parent_scope && this.parent_scope.find_variable(name);
+        || (this.parent_scope && this.parent_scope.find_variable(name));
 });
 
-AST_BlockScope.DEFMETHOD("def_function", function(symbol, init) {
+AST_Scope.DEFMETHOD("def_function", function(symbol, init) {
     var def = this.def_variable(symbol, init);
-    if (!def.init || def.init instanceof AST_LambdaDefinition) def.init = init;
+    if (!def.init || def.init instanceof AST_Defun) def.init = init;
     this.functions.set(symbol.name, def);
     return def;
 });
 
-AST_BlockScope.DEFMETHOD("def_variable", function(symbol, init) {
+AST_Scope.DEFMETHOD("def_variable", function(symbol, init) {
     var def = this.variables.get(symbol.name);
     if (def) {
         def.orig.push(symbol);
-        if (def.init instanceof AST_LambdaExpression) def.init = init;
+        if (def.init instanceof AST_Function) def.init = init;
     } else {
-        def = this.make_def(symbol, init);
+        def = new SymbolDef(this, symbol, init);
         this.variables.set(symbol.name, def);
         def.global = !this.parent_scope;
     }
     return symbol.thedef = def;
 });
 
+AST_Lambda.DEFMETHOD("resolve", return_this);
+AST_Scope.DEFMETHOD("resolve", function() {
+    return this.parent_scope.resolve();
+});
+AST_Toplevel.DEFMETHOD("resolve", return_this);
+
 function names_in_use(scope, options) {
     var names = scope.names_in_use;
     if (!names) {
-        scope.cname = -1;
+        scope.names_in_use = names = Object.create(scope.mangled_names || null);
         scope.cname_holes = [];
-        scope.names_in_use = names = Object.create(null);
         var cache = options.cache && options.cache.props;
         scope.enclosed.forEach(function(def) {
             if (def.unmangleable(options)) names[def.name] = true;
@@ -512,13 +334,12 @@ function names_in_use(scope, options) {
     return names;
 }
 
-function next_mangled_name(def, options) {
-    var scope = def.scope;
+function next_mangled_name(scope, options, def) {
     var in_use = names_in_use(scope, options);
     var holes = scope.cname_holes;
     var names = Object.create(null);
     var scopes = [ scope ];
-    def.forEach(function(sym) {
+    def.references.forEach(function(sym) {
         var scope = sym.scope;
         do {
             if (scopes.indexOf(scope) < 0) {
@@ -534,7 +355,7 @@ function next_mangled_name(def, options) {
         name = base54(holes[i]);
         if (names[name]) continue;
         holes.splice(i, 1);
-        in_use[name] = true;
+        scope.names_in_use[name] = true;
         return name;
     }
     while (true) {
@@ -543,7 +364,7 @@ function next_mangled_name(def, options) {
         if (!names[name]) break;
         holes.push(scope.cname);
     }
-    in_use[name] = true;
+    scope.names_in_use[name] = true;
     return name;
 }
 
@@ -555,10 +376,18 @@ AST_Symbol.DEFMETHOD("unmangleable", function(options) {
 // labels are always mangleable
 AST_Label.DEFMETHOD("unmangleable", return_false);
 
+AST_Symbol.DEFMETHOD("unreferenced", function() {
+    return !this.definition().references.length && !this.scope.pinned();
+});
+
 AST_Symbol.DEFMETHOD("definition", function() {
     return this.thedef;
 });
 
+AST_Symbol.DEFMETHOD("global", function() {
+    return this.definition().global;
+});
+
 function _default_mangler_options(options) {
     options = defaults(options, {
         eval        : false,
@@ -566,8 +395,6 @@ function _default_mangler_options(options) {
         keep_fnames : false,
         reserved    : [],
         toplevel    : false,
-        v8          : false,
-        webkit      : false,
     });
     if (!Array.isArray(options.reserved)) options.reserved = [];
     // Never mangle arguments
@@ -586,7 +413,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     var lname = -1;
 
     if (options.cache && options.cache.props) {
-        var mangled_names = names_in_use(this, options);
+        var mangled_names = this.mangled_names = Object.create(null);
         options.cache.props.each(function(mangled_name) {
             mangled_names[mangled_name] = true;
         });
@@ -598,29 +425,10 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             // lname is incremented when we get to the AST_Label
             var save_nesting = lname;
             descend();
-            if (!options.v8 || !in_label(tw)) lname = save_nesting;
+            lname = save_nesting;
             return true;
         }
-        if (node instanceof AST_BlockScope) {
-            if (options.webkit && node instanceof AST_IterationStatement && node.init instanceof AST_Let) {
-                node.init.definitions.forEach(function(defn) {
-                    defn.name.match_symbol(function(sym) {
-                        if (!(sym instanceof AST_SymbolLet)) return;
-                        var def = sym.definition();
-                        var scope = sym.scope.parent_scope;
-                        var redef = scope.def_variable(sym);
-                        sym.thedef = def;
-                        scope.to_mangle.push(redef);
-                        def.redefined = function() {
-                            return redef;
-                        };
-                    });
-                }, true);
-            }
-            node.to_mangle = [];
-            node.variables.each(function(def) {
-                if (!defer_redef(def)) node.to_mangle.push(def);
-            });
+        if (node instanceof AST_Scope) {
             descend();
             if (options.cache && node instanceof AST_Toplevel) {
                 node.globals.each(mangle);
@@ -630,7 +438,9 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                 sym.scope = node;
                 sym.reference(options);
             }
-            node.to_mangle.forEach(mangle);
+            node.variables.each(function(def) {
+                if (!defer_redef(def)) mangle(def);
+            });
             return true;
         }
         if (node instanceof AST_Label) {
@@ -641,6 +451,13 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             node.mangled_name = name;
             return true;
         }
+        if (!options.ie8 && node instanceof AST_Catch) {
+            var def = node.argname.definition();
+            var redef = defer_redef(def, node.argname);
+            descend();
+            if (!redef) mangle(def);
+            return true;
+        }
     });
     this.walk(tw);
     redefined.forEach(mangle);
@@ -650,20 +467,12 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
         def.mangle(options);
     }
 
-    function defer_redef(def) {
-        var sym = def.orig[0];
+    function defer_redef(def, node) {
         var redef = def.redefined();
-        if (!redef) {
-            if (!(sym instanceof AST_SymbolConst)) return false;
-            var scope = def.scope.resolve();
-            if (def.scope === scope) return false;
-            if (def.scope.parent_scope.find_variable(sym.name)) return false;
-            redef = scope.def_variable(sym);
-            scope.to_mangle.push(redef);
-        }
+        if (!redef) return false;
         redefined.push(def);
         def.references.forEach(reference);
-        if (sym instanceof AST_SymbolCatch || sym instanceof AST_SymbolConst) reference(sym);
+        if (node) reference(node);
         return true;
 
         function reference(sym) {
@@ -672,23 +481,16 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             sym.thedef = def;
         }
     }
-
-    function in_label(tw) {
-        var level = 0, parent;
-        while (parent = tw.parent(level++)) {
-            if (parent instanceof AST_Block) return parent instanceof AST_Toplevel && !options.toplevel;
-            if (parent instanceof AST_LabeledStatement) return true;
-        }
-    }
 });
 
 AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) {
     var cache = options.cache && options.cache.props;
-    var avoid = Object.create(RESERVED_WORDS);
+    var avoid = Object.create(null);
     options.reserved.forEach(to_avoid);
     this.globals.each(add_def);
     this.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_BlockScope) node.variables.each(add_def);
+        if (node instanceof AST_Scope) node.variables.each(add_def);
+        if (node instanceof AST_SymbolCatch) add_def(node.definition());
     }));
     return avoid;
 
@@ -712,14 +514,15 @@ AST_Toplevel.DEFMETHOD("expand_names", function(options) {
     var cname = 0;
     this.globals.each(rename);
     this.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_BlockScope) node.variables.each(rename);
+        if (node instanceof AST_Scope) node.variables.each(rename);
+        if (node instanceof AST_SymbolCatch) rename(node.definition());
     }));
 
     function next_name() {
         var name;
         do {
             name = base54(cname++);
-        } while (avoid[name]);
+        } while (avoid[name] || RESERVED_WORDS[name]);
         return name;
     }
 
@@ -730,8 +533,11 @@ AST_Toplevel.DEFMETHOD("expand_names", function(options) {
         var redef = def.redefined();
         var name = redef ? redef.rename || redef.name : next_name();
         def.rename = name;
-        def.forEach(function(sym) {
-            if (sym.definition() === def) sym.name = name;
+        def.orig.forEach(function(sym) {
+            sym.name = name;
+        });
+        def.references.forEach(function(sym) {
+            sym.name = name;
         });
     }
 });
@@ -744,24 +550,22 @@ AST_Sequence.DEFMETHOD("tail_node", function() {
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) {
     options = _default_mangler_options(options);
     base54.reset();
-    var fn = AST_Symbol.prototype.add_source_map;
     try {
-        AST_Symbol.prototype.add_source_map = function() {
-            if (!this.unmangleable(options)) base54.consider(this.name, -1);
+        AST_Node.prototype.print = function(stream, force_parens) {
+            this._print(stream, force_parens);
+            if (this instanceof AST_Symbol && !this.unmangleable(options)) {
+                base54.consider(this.name, -1);
+            } else if (options.properties) {
+                if (this instanceof AST_Dot) {
+                    base54.consider(this.property, -1);
+                } else if (this instanceof AST_Sub) {
+                    skip_string(this.property);
+                }
+            }
         };
-        if (options.properties) {
-            AST_Dot.prototype.add_source_map = function() {
-                base54.consider(this.property, -1);
-            };
-            AST_Sub.prototype.add_source_map = function() {
-                skip_string(this.property);
-            };
-        }
         base54.consider(this.print_to_string(), 1);
     } finally {
-        AST_Symbol.prototype.add_source_map = fn;
-        delete AST_Dot.prototype.add_source_map;
-        delete AST_Sub.prototype.add_source_map;
+        AST_Node.prototype.print = AST_Node.prototype._print;
     }
     base54.sort();