terser 3.16.1 → 3.17.0

package/dist/bundle.js

@@ -54,7 +54,7 @@
   }
 
   function member(name, array) {
-      return array.indexOf(name) >= 0;
+      return array.includes(name);
   }
 
   function find_if(func, array) {
@@ -174,7 +174,7 @@
   })();
 
   function push_uniq(array, el) {
-      if (array.indexOf(el) < 0)
+      if (!array.includes(el))
           array.push(el);
   }
 
@@ -552,10 +552,7 @@
   }
 
   function is_identifier(name) {
-      if (typeof name !== "string" || RESERVED_WORDS(name))
-          return false;
-
-      return true;
+      return typeof name === "string" && !RESERVED_WORDS(name);
   }
 
   function is_identifier_start(ch) {
@@ -924,7 +921,7 @@
           // update stream position
           forward(get_full_char_length(text) /* text length doesn't count \r\n as 2 char while S.pos - i does */ + 2);
           S.comments_before.push(token("comment2", text, true));
-          S.newline_before = S.newline_before || text.indexOf("\n") >= 0;
+          S.newline_before = S.newline_before || text.includes("\n");
           S.regex_allowed = regex_allowed;
           return next_token;
       });
@@ -1353,7 +1350,7 @@
             case "string":
               if (S.in_directives) {
                   var token = peek();
-                  if (S.token.raw.indexOf("\\") == -1
+                  if (!S.token.raw.includes("\\")
                       && (is_token(token, "punc", ";")
                           || is_token(token, "punc", "}")
                           || has_newline_before(token)
@@ -1946,7 +1943,7 @@
                       used_parameters.mark_spread(S.token);
                       next();
                   }
-                  if (is("name") && (is_token(peek(), "punc") || is_token(peek(), "operator")) && [",", "}", "="].indexOf(peek().value) !== -1) {
+                  if (is("name") && (is_token(peek(), "punc") || is_token(peek(), "operator")) && [",", "}", "="].includes(peek().value)) {
                       used_parameters.add_parameter(S.token);
                       var start = prev();
                       var value = as_symbol(symbol_type);
@@ -2972,7 +2969,7 @@
                   next();
                   return null;
               }
-              if (["delete", "in", "instanceof", "new", "typeof", "void"].indexOf(tmp.value) === -1) {
+              if (!["delete", "in", "instanceof", "new", "typeof", "void"].includes(tmp.value)) {
                   unexpected(tmp);
               }
             case "name":
@@ -5262,10 +5259,9 @@
       function print(str) {
           str = String(str);
           var ch = get_full_char(str, 0);
-          var prev = get_full_char(last, last.length - 1);
           if (need_newline_indented && ch) {
               need_newline_indented = false;
-              if (ch != "\n") {
+              if (ch !== "\n") {
                   print("\n");
                   indent();
               }
@@ -5281,7 +5277,7 @@
           if (might_need_semicolon) {
               might_need_semicolon = false;
 
-              if (prev == ":" && ch == "}" || (!ch || ";}".indexOf(ch) < 0) && prev != ";") {
+              if (prev === ":" && ch === "}" || (!ch || !";}".includes(ch)) && prev !== ";") {
                   if (options.semicolons || requireSemicolonChars(ch)) {
                       OUTPUT += ";";
                       current_col++;
@@ -5586,7 +5582,7 @@
           print_name      : function(name) { print(make_name(name)); },
           print_string    : function(str, quote, escape_directive) {
               var encoded = encode_string(str, quote);
-              if (escape_directive === true && encoded.indexOf("\\") === -1) {
+              if (escape_directive === true && !encoded.includes("\\")) {
                   // Insert semicolons to break directive prologue
                   if (!EXPECT_DIRECTIVE.test(OUTPUT)) {
                       force_semicolon();
@@ -6842,19 +6838,14 @@
       function make_num(num) {
           var str = num.toString(10), a = [ str.replace(/^0\./, ".").replace("e+", "e") ], m;
           if (Math.floor(num) === num) {
-              if (num >= 0) {
-                  a.push("0x" + num.toString(16).toLowerCase(), // probably pointless
-                         "0" + num.toString(8)); // same.
-              } else {
-                  a.push("-0x" + (-num).toString(16).toLowerCase(), // probably pointless
-                         "-0" + (-num).toString(8)); // same.
-              }
-              if ((m = /^(.*?)(0+)$/.exec(num))) {
+              a.push(
+                  (num >= 0 ? "0x" : "-0x") + num.toString(16).toLowerCase() // probably pointless
+              );
+              if ((m = /^(.*?)(0{3,})$/.exec(num))) {
                   a.push(m[1] + "e" + m[2].length);
               }
           } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) {
-              a.push(m[2] + "e-" + (m[1].length + m[2].length),
-                     str.substr(str.indexOf(".")));
+              a.push(m[2] + "e-" + (m[1].length + m[2].length));
           }
           return best_of(a);
       }
@@ -7392,7 +7383,7 @@
       var name;
       do {
           name = next_mangled(this, options);
-      } while (member(name, this.mangled_names));
+      } while (this.mangled_names.has(name));
       return name;
   });
 
@@ -7462,12 +7453,12 @@
       var lname = -1;
       var to_mangle = [];
 
-      var mangled_names = this.mangled_names = [];
+      var mangled_names = this.mangled_names = new Set();
       if (options.cache) {
           this.globals.each(collect);
           if (options.cache.props) {
               options.cache.props.each(function(mangled_name) {
-                  push_uniq(mangled_names, mangled_name);
+                  mangled_names.add(mangled_name);
               });
           }
       }
@@ -7765,7 +7756,7 @@
           this.pure_funcs = pure_funcs;
       } else {
           this.pure_funcs = pure_funcs ? function(node) {
-              return pure_funcs.indexOf(node.expression.print_to_string()) < 0;
+              return !pure_funcs.includes(node.expression.print_to_string());
           } : return_true;
       }
       var top_retain = this.options["top_retain"];
@@ -7780,7 +7771,7 @@
               top_retain = top_retain.split(/,/);
           }
           this.top_retain = function(def) {
-              return top_retain.indexOf(def.name) >= 0;
+              return top_retain.includes(def.name);
           };
       }
       if (this.options["module"]) {
@@ -7898,7 +7889,7 @@
           }
           // Before https://github.com/mishoo/UglifyJS2/pull/1602 AST_Node.optimize()
           // would call AST_Node.transform() if a different instance of AST_Node is
-          // produced after OPT().
+          // produced after def_optimize().
           // This corrupts TreeWalker.stack, which cause AST look-ups to malfunction.
           // Migrate and defer all children's AST_Node.transform() to below, which
           // will now happen after this parent AST_Node has been properly substituted
@@ -7920,7 +7911,7 @@
 
   (function() {
 
-      function OPT(node, optimizer) {
+      function def_optimize(node, optimizer) {
           node.DEFMETHOD("optimize", function(compressor) {
               var self = this;
               if (self._optimized) return self;
@@ -7931,7 +7922,7 @@
           });
       }
 
-      OPT(AST_Node, function(self, compressor) {
+      def_optimize(AST_Node, function(self, compressor) {
           return self;
       });
 
@@ -8048,8 +8039,8 @@
           }
       }
 
-      (function(def) {
-          def(AST_Node, noop);
+      (function(def_reduce_vars) {
+          def_reduce_vars(AST_Node, noop);
 
           function reset_def(compressor, def) {
               def.assignments = 0;
@@ -8187,15 +8178,15 @@
               if (node instanceof AST_SymbolRef) d.references.push(node);
               d.fixed = false;
           });
-          def(AST_Accessor, function(tw, descend, compressor) {
+          def_reduce_vars(AST_Accessor, function(tw, descend, compressor) {
               push(tw);
               reset_variables(tw, compressor, this);
               descend();
               pop(tw);
               return true;
           });
-          def(AST_Arrow, mark_func_expr);
-          def(AST_Assign, function(tw, descend, compressor) {
+          def_reduce_vars(AST_Arrow, mark_func_expr);
+          def_reduce_vars(AST_Assign, function(tw, descend, compressor) {
               var node = this;
               if (node.left instanceof AST_Destructuring) {
                   node.left.walk(suppressor);
@@ -8229,7 +8220,7 @@
               mark_escaped(tw, d, sym.scope, node, value, 0, 1);
               return true;
           });
-          def(AST_Binary, function(tw) {
+          def_reduce_vars(AST_Binary, function(tw) {
               if (!lazy_op(this.operator)) return;
               this.left.walk(tw);
               push(tw);
@@ -8237,10 +8228,10 @@
               pop(tw);
               return true;
           });
-          def(AST_Block, function(tw, descend, compressor) {
+          def_reduce_vars(AST_Block, function(tw, descend, compressor) {
               reset_block_variables(compressor, this);
           });
-          def(AST_Case, function(tw) {
+          def_reduce_vars(AST_Case, function(tw) {
               push(tw);
               this.expression.walk(tw);
               pop(tw);
@@ -8249,14 +8240,14 @@
               pop(tw);
               return true;
           });
-          def(AST_ClassExpression, function(tw, descend) {
+          def_reduce_vars(AST_ClassExpression, function(tw, descend) {
               this.inlined = false;
               push(tw);
               descend();
               pop(tw);
               return true;
           });
-          def(AST_Conditional, function(tw) {
+          def_reduce_vars(AST_Conditional, function(tw) {
               this.condition.walk(tw);
               push(tw);
               this.consequent.walk(tw);
@@ -8266,7 +8257,7 @@
               pop(tw);
               return true;
           });
-          def(AST_Default, function(tw, descend) {
+          def_reduce_vars(AST_Default, function(tw, descend) {
               push(tw);
               descend();
               pop(tw);
@@ -8283,9 +8274,9 @@
               return true;
           }
 
-          def(AST_DefClass, mark_def_node);
-          def(AST_Defun, mark_def_node);
-          def(AST_Do, function(tw, descend, compressor) {
+          def_reduce_vars(AST_DefClass, mark_def_node);
+          def_reduce_vars(AST_Defun, mark_def_node);
+          def_reduce_vars(AST_Do, function(tw, descend, compressor) {
               reset_block_variables(compressor, this);
               var saved_loop = tw.in_loop;
               tw.in_loop = this;
@@ -8300,7 +8291,7 @@
               tw.in_loop = saved_loop;
               return true;
           });
-          def(AST_For, function(tw, descend, compressor) {
+          def_reduce_vars(AST_For, function(tw, descend, compressor) {
               reset_block_variables(compressor, this);
               if (this.init) this.init.walk(tw);
               var saved_loop = tw.in_loop;
@@ -8319,7 +8310,7 @@
               tw.in_loop = saved_loop;
               return true;
           });
-          def(AST_ForIn, function(tw, descend, compressor) {
+          def_reduce_vars(AST_ForIn, function(tw, descend, compressor) {
               reset_block_variables(compressor, this);
               this.init.walk(suppressor);
               this.object.walk(tw);
@@ -8363,8 +8354,8 @@
               return true;
           }
 
-          def(AST_Function, mark_func_expr);
-          def(AST_If, function(tw) {
+          def_reduce_vars(AST_Function, mark_func_expr);
+          def_reduce_vars(AST_If, function(tw) {
               this.condition.walk(tw);
               push(tw);
               this.body.walk(tw);
@@ -8376,16 +8367,16 @@
               }
               return true;
           });
-          def(AST_LabeledStatement, function(tw) {
+          def_reduce_vars(AST_LabeledStatement, function(tw) {
               push(tw);
               this.body.walk(tw);
               pop(tw);
               return true;
           });
-          def(AST_SymbolCatch, function() {
+          def_reduce_vars(AST_SymbolCatch, function() {
               this.definition().fixed = false;
           });
-          def(AST_SymbolRef, function(tw, descend, compressor) {
+          def_reduce_vars(AST_SymbolRef, function(tw, descend, compressor) {
               var d = this.definition();
               d.references.push(this);
               if (d.references.length == 1
@@ -8417,13 +8408,13 @@
               }
               mark_escaped(tw, d, this.scope, this, value, 0, 1);
           });
-          def(AST_Toplevel, function(tw, descend, compressor) {
+          def_reduce_vars(AST_Toplevel, function(tw, descend, compressor) {
               this.globals.each(function(def) {
                   reset_def(compressor, def);
               });
               reset_variables(tw, compressor, this);
           });
-          def(AST_Try, function(tw, descend, compressor) {
+          def_reduce_vars(AST_Try, function(tw, descend, compressor) {
               reset_block_variables(compressor, this);
               push(tw);
               walk_body(this, tw);
@@ -8436,7 +8427,7 @@
               if (this.bfinally) this.bfinally.walk(tw);
               return true;
           });
-          def(AST_Unary, function(tw, descend) {
+          def_reduce_vars(AST_Unary, function(tw, descend) {
               var node = this;
               if (node.operator != "++" && node.operator != "--") return;
               var exp = node.expression;
@@ -8464,7 +8455,7 @@
               mark(tw, d, true);
               return true;
           });
-          def(AST_VarDef, function(tw, descend) {
+          def_reduce_vars(AST_VarDef, function(tw, descend) {
               var node = this;
               if (node.name instanceof AST_Destructuring) {
                   node.name.walk(suppressor);
@@ -8486,7 +8477,7 @@
                   }
               }
           });
-          def(AST_While, function(tw, descend, compressor) {
+          def_reduce_vars(AST_While, function(tw, descend, compressor) {
               reset_block_variables(compressor, this);
               var saved_loop = tw.in_loop;
               tw.in_loop = this;
@@ -9705,9 +9696,9 @@
                   prop = "" + prop;
                   var diff = compressor.option("ecma") < 6
                       && compressor.has_directive("use strict") ? function(node) {
-                      return node.key != prop && node.key.name != prop;
+                      return node.key != prop && (node.key && node.key.name != prop);
                   } : function(node) {
-                      return node.key.name != prop;
+                      return node.key && node.key.name != prop;
                   };
                   if (!all(def.value.properties, diff)) break;
                   var p = def.value.properties.filter(function (p) { return p.key === prop; })[0];
@@ -9858,7 +9849,7 @@
 
       // may_throw_on_access()
       // returns true if this node may be null, undefined or contain `AST_Accessor`
-      (function(def) {
+      (function(def_dot_throw) {
           AST_Node.DEFMETHOD("may_throw_on_access", function(compressor) {
               return !compressor.option("pure_getters")
                   || this._dot_throw(compressor);
@@ -9868,49 +9859,49 @@
               return /strict/.test(compressor.option("pure_getters"));
           }
 
-          def(AST_Node, is_strict);
-          def(AST_Null, return_true);
-          def(AST_Undefined, return_true);
-          def(AST_Constant, return_false);
-          def(AST_Array, return_false);
-          def(AST_Object, function(compressor) {
+          def_dot_throw(AST_Node, is_strict);
+          def_dot_throw(AST_Null, return_true);
+          def_dot_throw(AST_Undefined, return_true);
+          def_dot_throw(AST_Constant, return_false);
+          def_dot_throw(AST_Array, return_false);
+          def_dot_throw(AST_Object, function(compressor) {
               if (!is_strict(compressor)) return false;
               for (var i = this.properties.length; --i >=0;)
                   if (this.properties[i]._dot_throw(compressor)) return true;
               return false;
           });
-          def(AST_ObjectProperty, return_false);
-          def(AST_ObjectGetter, return_true);
-          def(AST_Expansion, function(compressor) {
+          def_dot_throw(AST_ObjectProperty, return_false);
+          def_dot_throw(AST_ObjectGetter, return_true);
+          def_dot_throw(AST_Expansion, function(compressor) {
               return this.expression._dot_throw(compressor);
           });
-          def(AST_Function, return_false);
-          def(AST_Arrow, return_false);
-          def(AST_UnaryPostfix, return_false);
-          def(AST_UnaryPrefix, function() {
+          def_dot_throw(AST_Function, return_false);
+          def_dot_throw(AST_Arrow, return_false);
+          def_dot_throw(AST_UnaryPostfix, return_false);
+          def_dot_throw(AST_UnaryPrefix, function() {
               return this.operator == "void";
           });
-          def(AST_Binary, function(compressor) {
+          def_dot_throw(AST_Binary, function(compressor) {
               return (this.operator == "&&" || this.operator == "||")
                   && (this.left._dot_throw(compressor) || this.right._dot_throw(compressor));
           });
-          def(AST_Assign, function(compressor) {
+          def_dot_throw(AST_Assign, function(compressor) {
               return this.operator == "="
                   && this.right._dot_throw(compressor);
           });
-          def(AST_Conditional, function(compressor) {
+          def_dot_throw(AST_Conditional, function(compressor) {
               return this.consequent._dot_throw(compressor)
                   || this.alternative._dot_throw(compressor);
           });
-          def(AST_Dot, function(compressor) {
+          def_dot_throw(AST_Dot, function(compressor) {
               if (!is_strict(compressor)) return false;
               if (this.expression instanceof AST_Function && this.property == "prototype") return false;
               return true;
           });
-          def(AST_Sequence, function(compressor) {
+          def_dot_throw(AST_Sequence, function(compressor) {
               return this.tail_node()._dot_throw(compressor);
           });
-          def(AST_SymbolRef, function(compressor) {
+          def_dot_throw(AST_SymbolRef, function(compressor) {
               if (this.is_undefined) return true;
               if (!is_strict(compressor)) return false;
               if (is_undeclared_ref(this) && this.is_declared(compressor)) return false;
@@ -9925,56 +9916,56 @@
       /* -----[ boolean/negation helpers ]----- */
 
       // methods to determine whether an expression has a boolean result type
-      (function(def) {
+      (function(def_is_boolean) {
           var unary_bool = [ "!", "delete" ];
           var binary_bool = [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ];
-          def(AST_Node, return_false);
-          def(AST_UnaryPrefix, function() {
+          def_is_boolean(AST_Node, return_false);
+          def_is_boolean(AST_UnaryPrefix, function() {
               return member(this.operator, unary_bool);
           });
-          def(AST_Binary, function() {
+          def_is_boolean(AST_Binary, function() {
               return member(this.operator, binary_bool)
                   || lazy_op(this.operator)
                       && this.left.is_boolean()
                       && this.right.is_boolean();
           });
-          def(AST_Conditional, function() {
+          def_is_boolean(AST_Conditional, function() {
               return this.consequent.is_boolean() && this.alternative.is_boolean();
           });
-          def(AST_Assign, function() {
+          def_is_boolean(AST_Assign, function() {
               return this.operator == "=" && this.right.is_boolean();
           });
-          def(AST_Sequence, function() {
+          def_is_boolean(AST_Sequence, function() {
               return this.tail_node().is_boolean();
           });
-          def(AST_True, return_true);
-          def(AST_False, return_true);
+          def_is_boolean(AST_True, return_true);
+          def_is_boolean(AST_False, return_true);
       })(function(node, func) {
           node.DEFMETHOD("is_boolean", func);
       });
 
       // methods to determine if an expression has a numeric result type
-      (function(def) {
-          def(AST_Node, return_false);
-          def(AST_Number, return_true);
+      (function(def_is_number) {
+          def_is_number(AST_Node, return_false);
+          def_is_number(AST_Number, return_true);
           var unary = makePredicate("+ - ~ ++ --");
-          def(AST_Unary, function() {
+          def_is_number(AST_Unary, function() {
               return unary(this.operator);
           });
           var binary = makePredicate("- * / % & | ^ << >> >>>");
-          def(AST_Binary, function(compressor) {
+          def_is_number(AST_Binary, function(compressor) {
               return binary(this.operator) || this.operator == "+"
                   && this.left.is_number(compressor)
                   && this.right.is_number(compressor);
           });
-          def(AST_Assign, function(compressor) {
+          def_is_number(AST_Assign, function(compressor) {
               return binary(this.operator.slice(0, -1))
                   || this.operator == "=" && this.right.is_number(compressor);
           });
-          def(AST_Sequence, function(compressor) {
+          def_is_number(AST_Sequence, function(compressor) {
               return this.tail_node().is_number(compressor);
           });
-          def(AST_Conditional, function(compressor) {
+          def_is_number(AST_Conditional, function(compressor) {
               return this.consequent.is_number(compressor) && this.alternative.is_number(compressor);
           });
       })(function(node, func) {
@@ -9982,26 +9973,26 @@
       });
 
       // methods to determine if an expression has a string result type
-      (function(def) {
-          def(AST_Node, return_false);
-          def(AST_String, return_true);
-          def(AST_TemplateString, function() {
+      (function(def_is_string) {
+          def_is_string(AST_Node, return_false);
+          def_is_string(AST_String, return_true);
+          def_is_string(AST_TemplateString, function() {
               return this.segments.length === 1;
           });
-          def(AST_UnaryPrefix, function() {
+          def_is_string(AST_UnaryPrefix, function() {
               return this.operator == "typeof";
           });
-          def(AST_Binary, function(compressor) {
+          def_is_string(AST_Binary, function(compressor) {
               return this.operator == "+" &&
                   (this.left.is_string(compressor) || this.right.is_string(compressor));
           });
-          def(AST_Assign, function(compressor) {
+          def_is_string(AST_Assign, function(compressor) {
               return (this.operator == "=" || this.operator == "+=") && this.right.is_string(compressor);
           });
-          def(AST_Sequence, function(compressor) {
+          def_is_string(AST_Sequence, function(compressor) {
               return this.tail_node().is_string(compressor);
           });
-          def(AST_Conditional, function(compressor) {
+          def_is_string(AST_Conditional, function(compressor) {
               return this.consequent.is_string(compressor) && this.alternative.is_string(compressor);
           });
       })(function(node, func) {
@@ -10016,7 +10007,7 @@
           if (parent instanceof AST_Assign && parent.left === node) return node;
       }
 
-      (function(def) {
+      (function(def_find_defs) {
           function to_node(value, orig) {
               if (value instanceof AST_Node) return make_node(value.CTOR, orig, value);
               if (Array.isArray(value)) return make_node(AST_Array, orig, {
@@ -10062,15 +10053,15 @@
                   return def;
               }));
           });
-          def(AST_Node, noop);
-          def(AST_Dot, function(compressor, suffix) {
+          def_find_defs(AST_Node, noop);
+          def_find_defs(AST_Dot, function(compressor, suffix) {
               return this.expression._find_defs(compressor, "." + this.property + suffix);
           });
-          def(AST_SymbolDeclaration, function(compressor) {
+          def_find_defs(AST_SymbolDeclaration, function(compressor) {
               if (!this.global()) return;
               if (HOP(compressor.option("global_defs"), this.name)) warn(compressor, this);
           });
-          def(AST_SymbolRef, function(compressor, suffix) {
+          def_find_defs(AST_SymbolRef, function(compressor, suffix) {
               if (!this.global()) return;
               var defines = compressor.option("global_defs");
               var name = this.name + suffix;
@@ -10191,7 +10182,7 @@
       convert_to_predicate(static_fns);
 
       // methods to evaluate a constant expression
-      (function(def) {
+      (function(def_eval) {
           // If the node has been successfully reduced to a constant,
           // then its value is returned; otherwise the element itself
           // is returned.
@@ -10216,20 +10207,20 @@
                       && unaryPrefix(this.operator);
               }
           });
-          def(AST_Statement, function() {
+          def_eval(AST_Statement, function() {
               throw new Error(string_template("Cannot evaluate a statement [{file}:{line},{col}]", this.start));
           });
-          def(AST_Lambda, return_this);
-          def(AST_Class, return_this);
-          def(AST_Node, return_this);
-          def(AST_Constant, function() {
+          def_eval(AST_Lambda, return_this);
+          def_eval(AST_Class, return_this);
+          def_eval(AST_Node, return_this);
+          def_eval(AST_Constant, function() {
               return this.getValue();
           });
-          def(AST_TemplateString, function() {
+          def_eval(AST_TemplateString, function() {
               if (this.segments.length !== 1) return this;
               return this.segments[0].value;
           });
-          def(AST_Function, function(compressor) {
+          def_eval(AST_Function, function(compressor) {
               if (compressor.option("unsafe")) {
                   var fn = function() {};
                   fn.node = this;
@@ -10240,7 +10231,7 @@
               }
               return this;
           });
-          def(AST_Array, function(compressor, depth) {
+          def_eval(AST_Array, function(compressor, depth) {
               if (compressor.option("unsafe")) {
                   var elements = [];
                   for (var i = 0, len = this.elements.length; i < len; i++) {
@@ -10253,7 +10244,7 @@
               }
               return this;
           });
-          def(AST_Object, function(compressor, depth) {
+          def_eval(AST_Object, function(compressor, depth) {
               if (compressor.option("unsafe")) {
                   var val = {};
                   for (var i = 0, len = this.properties.length; i < len; i++) {
@@ -10278,7 +10269,7 @@
               return this;
           });
           var non_converting_unary = makePredicate("! typeof void");
-          def(AST_UnaryPrefix, function(compressor, depth) {
+          def_eval(AST_UnaryPrefix, function(compressor, depth) {
               var e = this.expression;
               // Function would be evaluated to an array and so typeof would
               // incorrectly return 'object'. Hence making is a special case.
@@ -10307,7 +10298,7 @@
               return this;
           });
           var non_converting_binary = makePredicate("&& || === !==");
-          def(AST_Binary, function(compressor, depth) {
+          def_eval(AST_Binary, function(compressor, depth) {
               if (!non_converting_binary(this.operator)) depth++;
               var left = this.left._eval(compressor, depth);
               if (left === this.left) return this;
@@ -10346,14 +10337,14 @@
               }
               return result;
           });
-          def(AST_Conditional, function(compressor, depth) {
+          def_eval(AST_Conditional, function(compressor, depth) {
               var condition = this.condition._eval(compressor, depth);
               if (condition === this.condition) return this;
               var node = condition ? this.consequent : this.alternative;
               var value = node._eval(compressor, depth);
               return value === node ? this : value;
           });
-          def(AST_SymbolRef, function(compressor, depth) {
+          def_eval(AST_SymbolRef, function(compressor, depth) {
               var fixed = this.fixed_value();
               if (!fixed) return this;
               var value;
@@ -10401,7 +10392,7 @@
               ],
           };
           convert_to_predicate(static_values);
-          def(AST_PropAccess, function(compressor, depth) {
+          def_eval(AST_PropAccess, function(compressor, depth) {
               if (compressor.option("unsafe")) {
                   var key = this.property;
                   if (key instanceof AST_Node) {
@@ -10418,6 +10409,9 @@
                           && (aa = compressor.parent() && compressor.parent().args)
                           && (aa && aa[0]
                           && aa[0].evaluate(compressor));
+
+                      first_arg = first_arg instanceof AST_Dot ? first_arg.expression : first_arg;
+
                       if (first_arg == null || first_arg.thedef && first_arg.thedef.undeclared) {
                           return this.clone();
                       }
@@ -10439,7 +10433,7 @@
               }
               return this;
           });
-          def(AST_Call, function(compressor, depth) {
+          def_eval(AST_Call, function(compressor, depth) {
               var exp = this.expression;
               if (compressor.option("unsafe") && exp instanceof AST_PropAccess) {
                   var key = exp.property;
@@ -10454,6 +10448,9 @@
                           e.name === "hasOwnProperty" &&
                           key === "call" &&
                           (this.args[0] && this.args[0].evaluate(compressor));
+
+                      first_arg = first_arg instanceof AST_Dot ? first_arg.expression : first_arg;
+
                       if ((first_arg == null || first_arg.thedef && first_arg.thedef.undeclared)) {
                           return this.clone();
                       }
@@ -10483,13 +10480,13 @@
               }
               return this;
           });
-          def(AST_New, return_this);
+          def_eval(AST_New, return_this);
       })(function(node, func) {
           node.DEFMETHOD("_eval", func);
       });
 
       // method to negate an expression
-      (function(def) {
+      (function(def_negate) {
           function basic_negation(exp) {
               return make_node(AST_UnaryPrefix, exp, {
                   operator: "!",
@@ -10506,35 +10503,35 @@
               }
               return best_of_expression(negated, alt);
           }
-          def(AST_Node, function() {
+          def_negate(AST_Node, function() {
               return basic_negation(this);
           });
-          def(AST_Statement, function() {
+          def_negate(AST_Statement, function() {
               throw new Error("Cannot negate a statement");
           });
-          def(AST_Function, function() {
+          def_negate(AST_Function, function() {
               return basic_negation(this);
           });
-          def(AST_Arrow, function() {
+          def_negate(AST_Arrow, function() {
               return basic_negation(this);
           });
-          def(AST_UnaryPrefix, function() {
+          def_negate(AST_UnaryPrefix, function() {
               if (this.operator == "!")
                   return this.expression;
               return basic_negation(this);
           });
-          def(AST_Sequence, function(compressor) {
+          def_negate(AST_Sequence, function(compressor) {
               var expressions = this.expressions.slice();
               expressions.push(expressions.pop().negate(compressor));
               return make_sequence(this, expressions);
           });
-          def(AST_Conditional, function(compressor, first_in_statement$$1) {
+          def_negate(AST_Conditional, function(compressor, first_in_statement$$1) {
               var self = this.clone();
               self.consequent = self.consequent.negate(compressor);
               self.alternative = self.alternative.negate(compressor);
               return best(this, self, first_in_statement$$1);
           });
-          def(AST_Binary, function(compressor, first_in_statement$$1) {
+          def_negate(AST_Binary, function(compressor, first_in_statement$$1) {
               var self = this.clone(), op = this.operator;
               if (compressor.option("unsafe_comps")) {
                   switch (op) {
@@ -10582,7 +10579,7 @@
               if (is_undeclared_ref(expr) && global_pure_fns(expr.name)) return true;
               if (expr instanceof AST_Dot
                   && is_undeclared_ref(expr.expression)
-                  && (static_fns[expr.expression.name] || return_false)(expr.property)) {
+                  && (static_fns.hasOwnProperty(expr.expression.name) && static_fns[expr.expression.name] || return_false)(expr.property)) {
                   return true;
               }
           }
@@ -10610,12 +10607,12 @@
       });
 
       // determine if expression has side effects
-      (function(def) {
-          def(AST_Node, return_true);
+      (function(def_has_side_effects) {
+          def_has_side_effects(AST_Node, return_true);
 
-          def(AST_EmptyStatement, return_false);
-          def(AST_Constant, return_false);
-          def(AST_This, return_false);
+          def_has_side_effects(AST_EmptyStatement, return_false);
+          def_has_side_effects(AST_Constant, return_false);
+          def_has_side_effects(AST_This, return_false);
 
           function any(list, compressor) {
               for (var i = list.length; --i >= 0;)
@@ -10624,10 +10621,10 @@
               return false;
           }
 
-          def(AST_Block, function(compressor) {
+          def_has_side_effects(AST_Block, function(compressor) {
               return any(this.body, compressor);
           });
-          def(AST_Call, function(compressor) {
+          def_has_side_effects(AST_Call, function(compressor) {
               if (!this.is_expr_pure(compressor)
                   && (!this.expression.is_call_pure(compressor)
                       || this.expression.has_side_effects(compressor))) {
@@ -10635,83 +10632,83 @@
               }
               return any(this.args, compressor);
           });
-          def(AST_Switch, function(compressor) {
+          def_has_side_effects(AST_Switch, function(compressor) {
               return this.expression.has_side_effects(compressor)
                   || any(this.body, compressor);
           });
-          def(AST_Case, function(compressor) {
+          def_has_side_effects(AST_Case, function(compressor) {
               return this.expression.has_side_effects(compressor)
                   || any(this.body, compressor);
           });
-          def(AST_Try, function(compressor) {
+          def_has_side_effects(AST_Try, function(compressor) {
               return any(this.body, compressor)
                   || this.bcatch && this.bcatch.has_side_effects(compressor)
                   || this.bfinally && this.bfinally.has_side_effects(compressor);
           });
-          def(AST_If, function(compressor) {
+          def_has_side_effects(AST_If, function(compressor) {
               return this.condition.has_side_effects(compressor)
                   || this.body && this.body.has_side_effects(compressor)
                   || this.alternative && this.alternative.has_side_effects(compressor);
           });
-          def(AST_LabeledStatement, function(compressor) {
+          def_has_side_effects(AST_LabeledStatement, function(compressor) {
               return this.body.has_side_effects(compressor);
           });
-          def(AST_SimpleStatement, function(compressor) {
+          def_has_side_effects(AST_SimpleStatement, function(compressor) {
               return this.body.has_side_effects(compressor);
           });
-          def(AST_Lambda, return_false);
-          def(AST_Class, return_false);
-          def(AST_DefClass, return_true);
-          def(AST_Binary, function(compressor) {
+          def_has_side_effects(AST_Lambda, return_false);
+          def_has_side_effects(AST_Class, return_false);
+          def_has_side_effects(AST_DefClass, return_true);
+          def_has_side_effects(AST_Binary, function(compressor) {
               return this.left.has_side_effects(compressor)
                   || this.right.has_side_effects(compressor);
           });
-          def(AST_Assign, return_true);
-          def(AST_Conditional, function(compressor) {
+          def_has_side_effects(AST_Assign, return_true);
+          def_has_side_effects(AST_Conditional, function(compressor) {
               return this.condition.has_side_effects(compressor)
                   || this.consequent.has_side_effects(compressor)
                   || this.alternative.has_side_effects(compressor);
           });
-          def(AST_Unary, function(compressor) {
+          def_has_side_effects(AST_Unary, function(compressor) {
               return unary_side_effects(this.operator)
                   || this.expression.has_side_effects(compressor);
           });
-          def(AST_SymbolRef, function(compressor) {
+          def_has_side_effects(AST_SymbolRef, function(compressor) {
               return !this.is_declared(compressor);
           });
-          def(AST_SymbolDeclaration, return_false);
-          def(AST_Object, function(compressor) {
+          def_has_side_effects(AST_SymbolDeclaration, return_false);
+          def_has_side_effects(AST_Object, function(compressor) {
               return any(this.properties, compressor);
           });
-          def(AST_ObjectProperty, function(compressor) {
+          def_has_side_effects(AST_ObjectProperty, function(compressor) {
               if (this.key instanceof AST_ObjectKeyVal &&
                       this.key.has_side_effects(compressor))
                   return true;
               return this.value.has_side_effects(compressor);
           });
-          def(AST_Array, function(compressor) {
+          def_has_side_effects(AST_Array, function(compressor) {
               return any(this.elements, compressor);
           });
-          def(AST_Dot, function(compressor) {
+          def_has_side_effects(AST_Dot, function(compressor) {
               return this.expression.may_throw_on_access(compressor)
                   || this.expression.has_side_effects(compressor);
           });
-          def(AST_Sub, function(compressor) {
+          def_has_side_effects(AST_Sub, function(compressor) {
               return this.expression.may_throw_on_access(compressor)
                   || this.expression.has_side_effects(compressor)
                   || this.property.has_side_effects(compressor);
           });
-          def(AST_Sequence, function(compressor) {
+          def_has_side_effects(AST_Sequence, function(compressor) {
               return any(this.expressions, compressor);
           });
-          def(AST_Definitions, function(compressor) {
+          def_has_side_effects(AST_Definitions, function(compressor) {
               return any(this.definitions, compressor);
           });
-          def(AST_VarDef, function(compressor) {
+          def_has_side_effects(AST_VarDef, function(compressor) {
               return this.value;
           });
-          def(AST_TemplateSegment, return_false);
-          def(AST_TemplateString, function(compressor) {
+          def_has_side_effects(AST_TemplateSegment, return_false);
+          def_has_side_effects(AST_TemplateString, function(compressor) {
               return any(this.segments, compressor);
           });
       })(function(node, func) {
@@ -10719,15 +10716,15 @@
       });
 
       // determine if expression may throw
-      (function(def) {
-          def(AST_Node, return_true);
+      (function(def_may_throw) {
+          def_may_throw(AST_Node, return_true);
 
-          def(AST_Class, return_false);
-          def(AST_Constant, return_false);
-          def(AST_EmptyStatement, return_false);
-          def(AST_Lambda, return_false);
-          def(AST_SymbolDeclaration, return_false);
-          def(AST_This, return_false);
+          def_may_throw(AST_Class, return_false);
+          def_may_throw(AST_Constant, return_false);
+          def_may_throw(AST_EmptyStatement, return_false);
+          def_may_throw(AST_Lambda, return_false);
+          def_may_throw(AST_SymbolDeclaration, return_false);
+          def_may_throw(AST_This, return_false);
 
           function any(list, compressor) {
               for (var i = list.length; --i >= 0;)
@@ -10736,10 +10733,10 @@
               return false;
           }
 
-          def(AST_Array, function(compressor) {
+          def_may_throw(AST_Array, function(compressor) {
               return any(this.elements, compressor);
           });
-          def(AST_Assign, function(compressor) {
+          def_may_throw(AST_Assign, function(compressor) {
               if (this.right.may_throw(compressor)) return true;
               if (!compressor.has_directive("use strict")
                   && this.operator == "="
@@ -10748,81 +10745,81 @@
               }
               return this.left.may_throw(compressor);
           });
-          def(AST_Binary, function(compressor) {
+          def_may_throw(AST_Binary, function(compressor) {
               return this.left.may_throw(compressor)
                   || this.right.may_throw(compressor);
           });
-          def(AST_Block, function(compressor) {
+          def_may_throw(AST_Block, function(compressor) {
               return any(this.body, compressor);
           });
-          def(AST_Call, function(compressor) {
+          def_may_throw(AST_Call, function(compressor) {
               if (any(this.args, compressor)) return true;
               if (this.is_expr_pure(compressor)) return false;
               if (this.expression.may_throw(compressor)) return true;
               return !(this.expression instanceof AST_Lambda)
                   || any(this.expression.body, compressor);
           });
-          def(AST_Case, function(compressor) {
+          def_may_throw(AST_Case, function(compressor) {
               return this.expression.may_throw(compressor)
                   || any(this.body, compressor);
           });
-          def(AST_Conditional, function(compressor) {
+          def_may_throw(AST_Conditional, function(compressor) {
               return this.condition.may_throw(compressor)
                   || this.consequent.may_throw(compressor)
                   || this.alternative.may_throw(compressor);
           });
-          def(AST_Definitions, function(compressor) {
+          def_may_throw(AST_Definitions, function(compressor) {
               return any(this.definitions, compressor);
           });
-          def(AST_Dot, function(compressor) {
+          def_may_throw(AST_Dot, function(compressor) {
               return this.expression.may_throw_on_access(compressor)
                   || this.expression.may_throw(compressor);
           });
-          def(AST_If, function(compressor) {
+          def_may_throw(AST_If, function(compressor) {
               return this.condition.may_throw(compressor)
                   || this.body && this.body.may_throw(compressor)
                   || this.alternative && this.alternative.may_throw(compressor);
           });
-          def(AST_LabeledStatement, function(compressor) {
+          def_may_throw(AST_LabeledStatement, function(compressor) {
               return this.body.may_throw(compressor);
           });
-          def(AST_Object, function(compressor) {
+          def_may_throw(AST_Object, function(compressor) {
               return any(this.properties, compressor);
           });
-          def(AST_ObjectProperty, function(compressor) {
+          def_may_throw(AST_ObjectProperty, function(compressor) {
               return this.value.may_throw(compressor);
           });
-          def(AST_Return, function(compressor) {
+          def_may_throw(AST_Return, function(compressor) {
               return this.value && this.value.may_throw(compressor);
           });
-          def(AST_Sequence, function(compressor) {
+          def_may_throw(AST_Sequence, function(compressor) {
               return any(this.expressions, compressor);
           });
-          def(AST_SimpleStatement, function(compressor) {
+          def_may_throw(AST_SimpleStatement, function(compressor) {
               return this.body.may_throw(compressor);
           });
-          def(AST_Sub, function(compressor) {
+          def_may_throw(AST_Sub, function(compressor) {
               return this.expression.may_throw_on_access(compressor)
                   || this.expression.may_throw(compressor)
                   || this.property.may_throw(compressor);
           });
-          def(AST_Switch, function(compressor) {
+          def_may_throw(AST_Switch, function(compressor) {
               return this.expression.may_throw(compressor)
                   || any(this.body, compressor);
           });
-          def(AST_SymbolRef, function(compressor) {
+          def_may_throw(AST_SymbolRef, function(compressor) {
               return !this.is_declared(compressor);
           });
-          def(AST_Try, function(compressor) {
+          def_may_throw(AST_Try, function(compressor) {
               return this.bcatch ? this.bcatch.may_throw(compressor) : any(this.body, compressor)
                   || this.bfinally && this.bfinally.may_throw(compressor);
           });
-          def(AST_Unary, function(compressor) {
+          def_may_throw(AST_Unary, function(compressor) {
               if (this.operator == "typeof" && this.expression instanceof AST_SymbolRef)
                   return false;
               return this.expression.may_throw(compressor);
           });
-          def(AST_VarDef, function(compressor) {
+          def_may_throw(AST_VarDef, function(compressor) {
               if (!this.value) return false;
               return this.value.may_throw(compressor);
           });
@@ -10831,7 +10828,7 @@
       });
 
       // determine if expression is constant
-      (function(def) {
+      (function(def_is_constant_expression) {
           function all$$1(list) {
               for (var i = list.length; --i >= 0;)
                   if (!list[i].is_constant_expression())
@@ -10871,29 +10868,29 @@
               return result;
           }
 
-          def(AST_Node, return_false);
-          def(AST_Constant, return_true);
-          def(AST_Class, function(scope) {
+          def_is_constant_expression(AST_Node, return_false);
+          def_is_constant_expression(AST_Constant, return_true);
+          def_is_constant_expression(AST_Class, function(scope) {
               var self = this;
               if (self.extends && !self.extends.is_constant_expression(scope)) {
                   return false;
               }
               return all_refs_local.call(self, scope);
           });
-          def(AST_Lambda, all_refs_local);
-          def(AST_Unary, function() {
+          def_is_constant_expression(AST_Lambda, all_refs_local);
+          def_is_constant_expression(AST_Unary, function() {
               return this.expression.is_constant_expression();
           });
-          def(AST_Binary, function() {
+          def_is_constant_expression(AST_Binary, function() {
               return this.left.is_constant_expression() && this.right.is_constant_expression();
           });
-          def(AST_Array, function() {
+          def_is_constant_expression(AST_Array, function() {
               return all$$1(this.elements);
           });
-          def(AST_Object, function() {
+          def_is_constant_expression(AST_Object, function() {
               return all$$1(this.properties);
           });
-          def(AST_ObjectProperty, function() {
+          def_is_constant_expression(AST_ObjectProperty, function() {
               return !(this.key instanceof AST_Node) && this.value.is_constant_expression();
           });
       })(function(node, func) {
@@ -10928,7 +10925,7 @@
       /* -----[ optimizers ]----- */
 
       var directives = ["use asm", "use strict"];
-      OPT(AST_Directive, function(self, compressor) {
+      def_optimize(AST_Directive, function(self, compressor) {
           if (compressor.option("directives")
               && (!member(self.value, directives) || compressor.has_directive(self.value) !== self)) {
               return make_node(AST_EmptyStatement, self);
@@ -10936,13 +10933,13 @@
           return self;
       });
 
-      OPT(AST_Debugger, function(self, compressor) {
+      def_optimize(AST_Debugger, function(self, compressor) {
           if (compressor.option("drop_debugger"))
               return make_node(AST_EmptyStatement, self);
           return self;
       });
 
-      OPT(AST_LabeledStatement, function(self, compressor) {
+      def_optimize(AST_LabeledStatement, function(self, compressor) {
           if (self.body instanceof AST_Break
               && compressor.loopcontrol_target(self.body) === self.body) {
               return make_node(AST_EmptyStatement, self);
@@ -10950,7 +10947,7 @@
           return self.label.references.length == 0 ? self.body : self;
       });
 
-      OPT(AST_Block, function(self, compressor) {
+      def_optimize(AST_Block, function(self, compressor) {
           tighten_body(self.body, compressor);
           return self;
       });
@@ -10963,7 +10960,7 @@
           );
       }
 
-      OPT(AST_BlockStatement, function(self, compressor) {
+      def_optimize(AST_BlockStatement, function(self, compressor) {
           tighten_body(self.body, compressor);
           switch (self.body.length) {
             case 1:
@@ -10988,7 +10985,7 @@
           }
           return self;
       }
-      OPT(AST_Lambda, opt_AST_Lambda);
+      def_optimize(AST_Lambda, opt_AST_Lambda);
 
       AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
           if (!compressor.option("unused")) return;
@@ -11492,10 +11489,11 @@
           return self;
       });
 
-      AST_Scope.DEFMETHOD("var_names", function() {
+      AST_Scope.DEFMETHOD("var_names", function varNames() {
           var var_names = this._var_names;
           if (!var_names) {
-              this._var_names = var_names = Object.create(null);
+              const isParentScopeAvailable = this.parent_scope && !this.parent_scope instanceof AST_Toplevel;
+              this._var_names = var_names = isParentScopeAvailable ? varNames.call(this.parent_scope) : Object.create(null);
               this.enclosed.forEach(function(def) {
                   var_names[def.name] = true;
               });
@@ -11576,7 +11574,7 @@
 
       // drop_side_effect_free()
       // remove side-effect-free parts which only affects return value
-      (function(def) {
+      (function(def_drop_side_effect_free) {
           // Drop side-effect-free elements from an array of expressions.
           // Returns an array of expressions with side-effects or null
           // if all elements were dropped. Note: original array may be
@@ -11596,10 +11594,10 @@
               return changed ? ret.length ? ret : null : nodes;
           }
 
-          def(AST_Node, return_this);
-          def(AST_Constant, return_null);
-          def(AST_This, return_null);
-          def(AST_Call, function(compressor, first_in_statement$$1) {
+          def_drop_side_effect_free(AST_Node, return_this);
+          def_drop_side_effect_free(AST_Constant, return_null);
+          def_drop_side_effect_free(AST_This, return_null);
+          def_drop_side_effect_free(AST_Call, function(compressor, first_in_statement$$1) {
               if (!this.is_expr_pure(compressor)) {
                   if (this.expression.is_call_pure(compressor)) {
                       var exprs = this.args.slice();
@@ -11621,11 +11619,11 @@
               var args = trim(this.args, compressor, first_in_statement$$1);
               return args && make_sequence(this, args);
           });
-          def(AST_Accessor, return_null);
-          def(AST_Function, return_null);
-          def(AST_Arrow, return_null);
-          def(AST_ClassExpression, return_null);
-          def(AST_Binary, function(compressor, first_in_statement$$1) {
+          def_drop_side_effect_free(AST_Accessor, return_null);
+          def_drop_side_effect_free(AST_Function, return_null);
+          def_drop_side_effect_free(AST_Arrow, return_null);
+          def_drop_side_effect_free(AST_ClassExpression, return_null);
+          def_drop_side_effect_free(AST_Binary, function(compressor, first_in_statement$$1) {
               var right = this.right.drop_side_effect_free(compressor);
               if (!right) return this.left.drop_side_effect_free(compressor, first_in_statement$$1);
               if (lazy_op(this.operator)) {
@@ -11639,7 +11637,7 @@
                   return make_sequence(this, [ left, right ]);
               }
           });
-          def(AST_Assign, function(compressor) {
+          def_drop_side_effect_free(AST_Assign, function(compressor) {
               var left = this.left;
               if (left.has_side_effects(compressor)
                   || compressor.has_directive("use strict")
@@ -11656,7 +11654,7 @@
               }
               return this;
           });
-          def(AST_Conditional, function(compressor) {
+          def_drop_side_effect_free(AST_Conditional, function(compressor) {
               var consequent = this.consequent.drop_side_effect_free(compressor);
               var alternative = this.alternative.drop_side_effect_free(compressor);
               if (consequent === this.consequent && alternative === this.alternative) return this;
@@ -11675,7 +11673,7 @@
               node.alternative = alternative;
               return node;
           });
-          def(AST_Unary, function(compressor, first_in_statement$$1) {
+          def_drop_side_effect_free(AST_Unary, function(compressor, first_in_statement$$1) {
               if (unary_side_effects(this.operator)) {
                   this.write_only = !this.expression.has_side_effects(compressor);
                   return this;
@@ -11688,25 +11686,25 @@
               }
               return expression;
           });
-          def(AST_SymbolRef, function(compressor) {
+          def_drop_side_effect_free(AST_SymbolRef, function(compressor) {
               return this.is_declared(compressor) ? null : this;
           });
-          def(AST_Object, function(compressor, first_in_statement$$1) {
+          def_drop_side_effect_free(AST_Object, function(compressor, first_in_statement$$1) {
               var values = trim(this.properties, compressor, first_in_statement$$1);
               return values && make_sequence(this, values);
           });
-          def(AST_ObjectProperty, function(compressor, first_in_statement$$1) {
+          def_drop_side_effect_free(AST_ObjectProperty, function(compressor, first_in_statement$$1) {
               return this.value.drop_side_effect_free(compressor, first_in_statement$$1);
           });
-          def(AST_Array, function(compressor, first_in_statement$$1) {
+          def_drop_side_effect_free(AST_Array, function(compressor, first_in_statement$$1) {
               var values = trim(this.elements, compressor, first_in_statement$$1);
               return values && make_sequence(this, values);
           });
-          def(AST_Dot, function(compressor, first_in_statement$$1) {
+          def_drop_side_effect_free(AST_Dot, function(compressor, first_in_statement$$1) {
               if (this.expression.may_throw_on_access(compressor)) return this;
               return this.expression.drop_side_effect_free(compressor, first_in_statement$$1);
           });
-          def(AST_Sub, function(compressor, first_in_statement$$1) {
+          def_drop_side_effect_free(AST_Sub, function(compressor, first_in_statement$$1) {
               if (this.expression.may_throw_on_access(compressor)) return this;
               var expression = this.expression.drop_side_effect_free(compressor, first_in_statement$$1);
               if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement$$1);
@@ -11714,7 +11712,7 @@
               if (!property) return expression;
               return make_sequence(this, [ expression, property ]);
           });
-          def(AST_Sequence, function(compressor) {
+          def_drop_side_effect_free(AST_Sequence, function(compressor) {
               var last = this.tail_node();
               var expr = last.drop_side_effect_free(compressor);
               if (expr === last) return this;
@@ -11722,11 +11720,11 @@
               if (expr) expressions.push(expr);
               return make_sequence(this, expressions);
           });
-          def(AST_Expansion, function(compressor, first_in_statement$$1) {
+          def_drop_side_effect_free(AST_Expansion, function(compressor, first_in_statement$$1) {
               return this.expression.drop_side_effect_free(compressor, first_in_statement$$1);
           });
-          def(AST_TemplateSegment, return_null);
-          def(AST_TemplateString, function(compressor) {
+          def_drop_side_effect_free(AST_TemplateSegment, return_null);
+          def_drop_side_effect_free(AST_TemplateString, function(compressor) {
               var values = trim(this.segments, compressor, first_in_statement);
               return values && make_sequence(this, values);
           });
@@ -11746,7 +11744,7 @@
           "document",
           "location"
       ];
-      OPT(AST_SimpleStatement, function(self, compressor) {
+      def_optimize(AST_SimpleStatement, function(self, compressor) {
           if (self.body instanceof AST_SymbolRef && pure_prop_access_globals.indexOf(self.body.name) !== -1) {
               return make_node(AST_EmptyStatement, self);
           }
@@ -11764,7 +11762,7 @@
           return self;
       });
 
-      OPT(AST_While, function(self, compressor) {
+      def_optimize(AST_While, function(self, compressor) {
           return compressor.option("loops") ? make_node(AST_For, self, self).optimize(compressor) : self;
       });
 
@@ -11782,7 +11780,7 @@
           return found;
       }
 
-      OPT(AST_Do, function(self, compressor) {
+      def_optimize(AST_Do, function(self, compressor) {
           if (!compressor.option("loops")) return self;
           var cond = self.condition.tail_node().evaluate(compressor);
           if (!(cond instanceof AST_Node)) {
@@ -11878,7 +11876,7 @@
           }
       }
 
-      OPT(AST_For, function(self, compressor) {
+      def_optimize(AST_For, function(self, compressor) {
           if (!compressor.option("loops")) return self;
           if (compressor.option("side_effects") && self.init) {
               self.init = self.init.drop_side_effect_free(compressor);
@@ -11915,7 +11913,7 @@
           return if_break_in_loop(self, compressor);
       });
 
-      OPT(AST_If, function(self, compressor) {
+      def_optimize(AST_If, function(self, compressor) {
           if (is_empty(self.alternative)) self.alternative = null;
 
           if (!compressor.option("conditionals")) return self;
@@ -12059,7 +12057,7 @@
           return self;
       });
 
-      OPT(AST_Switch, function(self, compressor) {
+      def_optimize(AST_Switch, function(self, compressor) {
           if (!compressor.option("switches")) return self;
           var branch;
           var value = self.expression.evaluate(compressor);
@@ -12165,7 +12163,7 @@
           }
       });
 
-      OPT(AST_Try, function(self, compressor) {
+      def_optimize(AST_Try, function(self, compressor) {
           tighten_body(self.body, compressor);
           if (self.bcatch && self.bfinally && all(self.bfinally.body, is_empty)) self.bfinally = null;
           if (compressor.option("dead_code") && all(self.body, is_empty)) {
@@ -12239,13 +12237,13 @@
           return make_sequence(this, assignments);
       });
 
-      OPT(AST_Definitions, function(self, compressor) {
+      def_optimize(AST_Definitions, function(self, compressor) {
           if (self.definitions.length == 0)
               return make_node(AST_EmptyStatement, self);
           return self;
       });
 
-      OPT(AST_Import, function(self, compressor) {
+      def_optimize(AST_Import, function(self, compressor) {
           return self;
       });
 
@@ -12257,7 +12255,7 @@
               && compressor.top_retain(fn.name);
       }
 
-      OPT(AST_Call, function(self, compressor) {
+      def_optimize(AST_Call, function(self, compressor) {
           var exp = self.expression;
           var fn = exp;
           inline_array_like_spread(self, compressor, self.args);
@@ -12814,24 +12812,31 @@
           }
       });
 
-      OPT(AST_New, function(self, compressor) {
-          if (compressor.option("unsafe")) {
-              var exp = self.expression;
-              if (is_undeclared_ref(exp)) {
-                  switch (exp.name) {
-                    case "Object":
-                    case "RegExp":
-                    case "Function":
-                    case "Error":
-                    case "Array":
+      def_optimize(AST_New, function(self, compressor) {
+          const {args, expression: exp} = self;
+
+          if (compressor.option("unsafe") && is_undeclared_ref(exp)) {
+              if (["Object", "RegExp", "Function", "Error"].includes(exp.name))
+                  return make_node(AST_Call, self, self).transform(compressor);
+
+              if (exp.name === "Array" && args.length < 2) {
+                  if (args.length === 0 || args[0].value === 0) return new AST_Array;
+
+                  if (args[0].value > 11) {
                       return make_node(AST_Call, self, self).transform(compressor);
                   }
+
+                  const elements = [];
+                  for (let i = 0; i < self.args[0].value; i++) elements.push(new AST_Hole);
+
+                  return new AST_Array({elements});
               }
           }
+
           return self;
       });
 
-      OPT(AST_Sequence, function(self, compressor) {
+      def_optimize(AST_Sequence, function(self, compressor) {
           if (!compressor.option("side_effects")) return self;
           var expressions = [];
           filter_for_side_effects();
@@ -12882,11 +12887,11 @@
           return this;
       });
 
-      OPT(AST_UnaryPostfix, function(self, compressor) {
+      def_optimize(AST_UnaryPostfix, function(self, compressor) {
           return self.lift_sequences(compressor);
       });
 
-      OPT(AST_UnaryPrefix, function(self, compressor) {
+      def_optimize(AST_UnaryPrefix, function(self, compressor) {
           var e = self.expression;
           if (self.operator == "delete"
               && !(e instanceof AST_SymbolRef
@@ -13002,7 +13007,7 @@
               || node instanceof AST_Class;
       }
 
-      OPT(AST_Binary, function(self, compressor) {
+      def_optimize(AST_Binary, function(self, compressor) {
           function reversible() {
               return self.left.is_constant()
                   || self.right.is_constant()
@@ -13430,7 +13435,7 @@
           return self;
       });
 
-      OPT(AST_SymbolExport, function(self, compressor) {
+      def_optimize(AST_SymbolExport, function(self, compressor) {
           return self;
       });
 
@@ -13458,7 +13463,7 @@
           return false;
       }
 
-      OPT(AST_SymbolRef, function(self, compressor) {
+      def_optimize(AST_SymbolRef, function(self, compressor) {
           if (!compressor.option("ie8")
               && is_undeclared_ref(self)
               && (!self.scope.uses_with || !compressor.find_parent(AST_With))) {
@@ -13598,7 +13603,7 @@
           return lhs instanceof AST_SymbolRef || lhs.TYPE === self.TYPE;
       }
 
-      OPT(AST_Undefined, function(self, compressor) {
+      def_optimize(AST_Undefined, function(self, compressor) {
           if (compressor.option("unsafe_undefined")) {
               var undef = find_variable(compressor, "undefined");
               if (undef) {
@@ -13621,7 +13626,7 @@
           });
       });
 
-      OPT(AST_Infinity, function(self, compressor) {
+      def_optimize(AST_Infinity, function(self, compressor) {
           var lhs = is_lhs(compressor.self(), compressor.parent());
           if (lhs && is_atomic(lhs, self)) return self;
           if (compressor.option("keep_infinity")
@@ -13639,7 +13644,7 @@
           });
       });
 
-      OPT(AST_NaN, function(self, compressor) {
+      def_optimize(AST_NaN, function(self, compressor) {
           var lhs = is_lhs(compressor.self(), compressor.parent());
           if (lhs && !is_atomic(lhs, self)
               || find_variable(compressor, "NaN")) {
@@ -13679,7 +13684,7 @@
 
       var ASSIGN_OPS = [ "+", "-", "/", "*", "%", ">>", "<<", ">>>", "|", "^", "&" ];
       var ASSIGN_OPS_COMMUTATIVE = [ "*", "|", "^", "&" ];
-      OPT(AST_Assign, function(self, compressor) {
+      def_optimize(AST_Assign, function(self, compressor) {
           var def;
           if (compressor.option("dead_code")
               && self.left instanceof AST_SymbolRef
@@ -13738,7 +13743,7 @@
           }
       });
 
-      OPT(AST_DefaultAssign, function(self, compressor) {
+      def_optimize(AST_DefaultAssign, function(self, compressor) {
           if (!compressor.option("evaluate")) {
               return self;
           }
@@ -13755,7 +13760,7 @@
           return self;
       });
 
-      OPT(AST_Conditional, function(self, compressor) {
+      def_optimize(AST_Conditional, function(self, compressor) {
           if (!compressor.option("conditionals")) return self;
           // This looks like lift_sequences(), should probably be under "sequences"
           if (self.condition instanceof AST_Sequence) {
@@ -13961,7 +13966,7 @@
           }
       });
 
-      OPT(AST_Boolean, function(self, compressor) {
+      def_optimize(AST_Boolean, function(self, compressor) {
           if (compressor.in_boolean_context()) return make_node(AST_Number, self, {
               value: +self.value
           });
@@ -14008,7 +14013,7 @@
               || !value.contains_this();
       }
 
-      OPT(AST_Sub, function(self, compressor) {
+      def_optimize(AST_Sub, function(self, compressor) {
           var expr = self.expression;
           var prop = self.property;
           if (compressor.option("properties")) {
@@ -14180,7 +14185,7 @@
           }
       });
 
-      OPT(AST_Dot, function(self, compressor) {
+      def_optimize(AST_Dot, function(self, compressor) {
           if (self.property == "arguments" || self.property == "caller") {
               compressor.warn("Function.prototype.{prop} not supported [{file}:{line},{col}]", {
                   prop: self.property,
@@ -14265,7 +14270,7 @@
           return self;
       }
 
-      OPT(AST_Array, function(self, compressor) {
+      def_optimize(AST_Array, function(self, compressor) {
           var optimized = literals_in_boolean_context(self, compressor);
           if (optimized !== self) {
               return optimized;
@@ -14273,7 +14278,7 @@
           return inline_array_like_spread(self, compressor, self.elements);
       });
 
-      OPT(AST_Object, function(self, compressor) {
+      def_optimize(AST_Object, function(self, compressor) {
           var optimized = literals_in_boolean_context(self, compressor);
           if (optimized !== self) {
               return optimized;
@@ -14299,16 +14304,16 @@
           return self;
       });
 
-      OPT(AST_RegExp, literals_in_boolean_context);
+      def_optimize(AST_RegExp, literals_in_boolean_context);
 
-      OPT(AST_Return, function(self, compressor) {
+      def_optimize(AST_Return, function(self, compressor) {
           if (self.value && is_undefined(self.value, compressor)) {
               self.value = null;
           }
           return self;
       });
 
-      OPT(AST_Arrow, function(self, compressor) {
+      def_optimize(AST_Arrow, function(self, compressor) {
           if (!(self.body instanceof AST_Node)) {
               self = opt_AST_Lambda(self, compressor);
           }
@@ -14321,7 +14326,7 @@
           return self;
       });
 
-      OPT(AST_Function, function(self, compressor) {
+      def_optimize(AST_Function, function(self, compressor) {
           self = opt_AST_Lambda(self, compressor);
           if (compressor.option("unsafe_arrows")
               && compressor.option("ecma") >= 6
@@ -14342,20 +14347,20 @@
           return self;
       });
 
-      OPT(AST_Class, function(self, compressor) {
+      def_optimize(AST_Class, function(self, compressor) {
           // HACK to avoid compress failure.
           // AST_Class is not really an AST_Scope/AST_Block as it lacks a body.
           return self;
       });
 
-      OPT(AST_Yield, function(self, compressor) {
+      def_optimize(AST_Yield, function(self, compressor) {
           if (self.expression && !self.is_star && is_undefined(self.expression, compressor)) {
               self.expression = null;
           }
           return self;
       });
 
-      OPT(AST_TemplateString, function(self, compressor) {
+      def_optimize(AST_TemplateString, function(self, compressor) {
           if (!compressor.option("evaluate")
           || compressor.parent() instanceof AST_PrefixedTemplateString)
               return self;
@@ -14380,7 +14385,7 @@
           return segments.length == 1 ? make_node(AST_String, self, segments[0]) : self;
       });
 
-      OPT(AST_PrefixedTemplateString, function(self, compressor) {
+      def_optimize(AST_PrefixedTemplateString, function(self, compressor) {
           return self;
       });
 
@@ -14406,9 +14411,9 @@
           return self;
       }
 
-      OPT(AST_ObjectProperty, lift_key);
+      def_optimize(AST_ObjectProperty, lift_key);
 
-      OPT(AST_ConciseMethod, function(self, compressor) {
+      def_optimize(AST_ConciseMethod, function(self, compressor) {
           lift_key(self, compressor);
           // p(){return x;} ---> p:()=>x
           if (compressor.option("arrows")
@@ -14432,7 +14437,7 @@
           return self;
       });
 
-      OPT(AST_ObjectKeyVal, function(self, compressor) {
+      def_optimize(AST_ObjectKeyVal, function(self, compressor) {
           lift_key(self, compressor);
           // p:function(){} ---> p(){}
           // p:function*(){} ---> *p(){}
@@ -14463,7 +14468,7 @@
           return self;
       });
 
-      OPT(AST_Destructuring, function(self, compressor) {
+      def_optimize(AST_Destructuring, function(self, compressor) {
           if (compressor.option("pure_getters") == true
               && compressor.option("unused")
               && !self.is_array
@@ -17343,6 +17348,7 @@
       "declare",
       "decode",
       "decodeAudioData",
+      "decodingInfo",
       "decodeURI",
       "decodeURIComponent",
       "decrypt",
@@ -17585,6 +17591,7 @@
       "filterResY",
       "filterUnits",
       "filters",
+      "finally",
       "find",
       "findIndex",
       "findRule",
@@ -18308,6 +18315,7 @@
       "measure",
       "measureText",
       "media",
+      "mediaCapabilities",
       "mediaDevices",
       "mediaElement",
       "mediaGroup",
@@ -19589,6 +19597,7 @@
       "slice",
       "slope",
       "small",
+      "smooth",
       "smil",
       "smoothingTimeConstant",
       "snapToLines",
@@ -20255,7 +20264,7 @@
    ***********************************************************************/
 
   function find_builtins(reserved) {
-      reserved.push.apply(reserved, domprops);
+      domprops.forEach(add);
 
       // Compatibility fix for some standard defined globals not defined on every js environment
       var new_globals = ["Symbol", "Map", "Promise", "Proxy", "Reflect", "Set", "WeakMap", "WeakSet"];
@@ -20293,7 +20302,7 @@
           }
       });
       function add(name) {
-          push_uniq(reserved, name);
+          reserved.add(name);
       }
   }
 
@@ -20338,8 +20347,9 @@
           reserved: null,
       }, true);
 
-      var reserved = options.reserved;
-      if (!Array.isArray(reserved)) reserved = [reserved];
+      var reserved_option = options.reserved;
+      if (!Array.isArray(reserved_option)) reserved_option = [reserved_option];
+      var reserved = new Set(reserved_option);
       if (!options.builtins) find_builtins(reserved);
 
       var cname = -1;
@@ -20347,7 +20357,7 @@
       if (options.cache) {
           cache = options.cache.props;
           cache.each(function(mangled_name) {
-              push_uniq(reserved, mangled_name);
+              reserved.add(mangled_name);
           });
       } else {
           cache = new Dictionary();
@@ -20364,8 +20374,8 @@
           debug_name_suffix = (options.debug === true ? "" : options.debug);
       }
 
-      var names_to_mangle = [];
-      var unmangleable = [];
+      var names_to_mangle = new Set();
+      var unmangleable = new Set();
 
       // step 1: find candidates to mangle
       ast.walk(new TreeWalker(function(node) {
@@ -20412,8 +20422,8 @@
       // only function declarations after this line
 
       function can_mangle(name) {
-          if (unmangleable.indexOf(name) >= 0) return false;
-          if (reserved.indexOf(name) >= 0) return false;
+          if (unmangleable.has(name)) return false;
+          if (reserved.has(name)) return false;
           if (options.only_cache) {
               return cache.has(name);
           }
@@ -20423,17 +20433,17 @@
 
       function should_mangle(name) {
           if (regex && !regex.test(name)) return false;
-          if (reserved.indexOf(name) >= 0) return false;
+          if (reserved.has(name)) return false;
           return cache.has(name)
-              || names_to_mangle.indexOf(name) >= 0;
+              || names_to_mangle.has(name);
       }
 
       function add(name) {
           if (can_mangle(name))
-              push_uniq(names_to_mangle, name);
+              names_to_mangle.add(name);
 
           if (!should_mangle(name)) {
-              push_uniq(unmangleable, name);
+              unmangleable.add(name);
           }
       }
 
@@ -21144,7 +21154,7 @@
                           : p.type == "ExportSpecifier" ? (p.local === M ? AST_SymbolExport : AST_SymbolExportForeign)
                           : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
                           : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
-                          : p.type == "ArrowFunctionExpression" ? (p.params.indexOf(M) !== -1) ? AST_SymbolFunarg : AST_SymbolRef
+                          : p.type == "ArrowFunctionExpression" ? (p.params.includes(M)) ? AST_SymbolFunarg : AST_SymbolRef
                           : p.type == "ClassExpression" ? (p.id === M ? AST_SymbolClass : AST_SymbolRef)
                           : p.type == "Property" ? (p.key === M && p.computed || p.value === M ? AST_SymbolRef : AST_SymbolMethod)
                           : p.type == "ClassDeclaration" ? (p.id === M ? AST_SymbolDefClass : AST_SymbolRef)