terser 3.17.0 → 4.0.0

package/dist/bundle.js

@@ -150,7 +150,7 @@
               }
               return is_last;
           }
-          if (a instanceof Array) {
+          if (Array.isArray(a)) {
               if (backwards) {
                   for (i = a.length; --i >= 0;) if (doit()) break;
                   ret.reverse();
@@ -214,50 +214,10 @@
       return _ms(array);
   }
 
-  // this function is taken from Acorn [1], written by Marijn Haverbeke
-  // [1] https://github.com/marijnh/acorn
   function makePredicate(words) {
-      if (!(words instanceof Array)) words = words.split(" ");
-      var f = "", cats = [];
-      out: for (var i = 0; i < words.length; ++i) {
-          for (var j = 0; j < cats.length; ++j)
-              if (cats[j][0].length == words[i].length) {
-                  cats[j].push(words[i]);
-                  continue out;
-              }
-          cats.push([words[i]]);
-      }
-      function quote(word) {
-          return JSON.stringify(word).replace(/[\u2028\u2029]/g, function(s) {
-              switch (s) {
-                  case "\u2028": return "\\u2028";
-                  case "\u2029": return "\\u2029";
-              }
-              return s;
-          });
-      }
-      function compareTo(arr) {
-          if (arr.length == 1) return f += "return str === " + quote(arr[0]) + ";";
-          f += "switch(str){";
-          for (var i = 0; i < arr.length; ++i) f += "case " + quote(arr[i]) + ":";
-          f += "return true}return false;";
-      }
-      // When there are more than three length categories, an outer
-      // switch first dispatches on the lengths, to save on comparisons.
-      if (cats.length > 3) {
-          cats.sort(function(a, b) {return b.length - a.length;});
-          f += "switch(str.length){";
-          for (var i = 0; i < cats.length; ++i) {
-              var cat = cats[i];
-              f += "case " + cat[0].length + ":";
-              compareTo(cat);
-          }
-          f += "}";
-          // Otherwise, simply generate a flat `switch` statement.
-      } else {
-          compareTo(words);
-      }
-      return new Function("str", f);
+      if (!Array.isArray(words)) words = words.split(" ");
+
+      return new Set(words);
   }
 
   function all(array, predicate) {
@@ -267,60 +227,31 @@
       return true;
   }
 
-  function Dictionary() {
-      this._values = Object.create(null);
-      this._size = 0;
+  function map_add(map, key, value) {
+      if (map.has(key)) {
+          map.get(key).push(value);
+      } else {
+          map.set(key, [ value ]);
+      }
   }
-  Dictionary.prototype = {
-      set: function(key, val) {
-          if (!this.has(key)) ++this._size;
-          this._values["$" + key] = val;
-          return this;
-      },
-      add: function(key, val) {
-          if (this.has(key)) {
-              this.get(key).push(val);
-          } else {
-              this.set(key, [ val ]);
-          }
-          return this;
-      },
-      get: function(key) { return this._values["$" + key]; },
-      del: function(key) {
-          if (this.has(key)) {
-              --this._size;
-              delete this._values["$" + key];
+
+  function map_from_object(obj) {
+      var map = new Map();
+      for (var key in obj) {
+          if (HOP(obj, key) && key.charAt(0) === "$") {
+              map.set(key.substr(1), obj[key]);
           }
-          return this;
-      },
-      has: function(key) { return ("$" + key) in this._values; },
-      each: function(f) {
-          for (var i in this._values)
-              f(this._values[i], i.substr(1));
-      },
-      size: function() {
-          return this._size;
-      },
-      map: function(f) {
-          var ret = [];
-          for (var i in this._values)
-              ret.push(f(this._values[i], i.substr(1)));
-          return ret;
-      },
-      clone: function() {
-          var ret = new Dictionary();
-          for (var i in this._values)
-              ret._values[i] = this._values[i];
-          ret._size = this._size;
-          return ret;
-      },
-      toObject: function() { return this._values; }
-  };
-  Dictionary.fromObject = function(obj) {
-      var dict = new Dictionary();
-      dict._size = merge(dict._values, obj);
-      return dict;
-  };
+      }
+      return map;
+  }
+
+  function map_to_object(map) {
+      var obj = Object.create(null);
+      map.forEach(function (value, key) {
+          obj["$" + key] = value;
+      });
+      return obj;
+  }
 
   function HOP(obj, prop) {
       return Object.prototype.hasOwnProperty.call(obj, prop);
@@ -551,10 +482,6 @@
       return code >= 48 && code <= 57;
   }
 
-  function is_identifier(name) {
-      return typeof name === "string" && !RESERVED_WORDS(name);
-  }
-
   function is_identifier_start(ch) {
       var code = ch.charCodeAt(0);
       return UNICODE.ID_Start.test(ch) || code == 36 || code == 95;
@@ -639,7 +566,7 @@
           var ch = get_full_char(S.text, S.pos++);
           if (signal_eof && !ch)
               throw EX_EOF;
-          if (NEWLINE_CHARS(ch)) {
+          if (NEWLINE_CHARS.has(ch)) {
               S.newline_before = S.newline_before || !in_string;
               ++S.line;
               S.col = 0;
@@ -670,7 +597,7 @@
           var text = S.text;
           for (var i = S.pos, n = S.text.length; i < n; ++i) {
               var ch = text[i];
-              if (NEWLINE_CHARS(ch))
+              if (NEWLINE_CHARS.has(ch))
                   return i;
           }
           return -1;
@@ -691,9 +618,9 @@
       var prev_was_dot = false;
       var previous_token = null;
       function token(type, value, is_comment) {
-          S.regex_allowed = ((type == "operator" && !UNARY_POSTFIX(value)) ||
-                             (type == "keyword" && KEYWORDS_BEFORE_EXPRESSION(value)) ||
-                             (type == "punc" && PUNC_BEFORE_EXPRESSION(value))) ||
+          S.regex_allowed = ((type == "operator" && !UNARY_POSTFIX.has(value)) ||
+                             (type == "keyword" && KEYWORDS_BEFORE_EXPRESSION.has(value)) ||
+                             (type == "punc" && PUNC_BEFORE_EXPRESSION.has(value))) ||
                              (type == "arrow");
           if (type == "punc" && value == ".") {
               prev_was_dot = true;
@@ -726,7 +653,7 @@
       }
 
       function skip_whitespace() {
-          while (WHITESPACE_CHARS(peek()))
+          while (WHITESPACE_CHARS.has(peek()))
               next();
       }
 
@@ -851,7 +778,7 @@
           for (;;) {
               var ch = next(true, true);
               if (ch == "\\") ch = read_escaped_char(true, true);
-              else if (NEWLINE_CHARS(ch)) parse_error("Unterminated string constant");
+              else if (NEWLINE_CHARS.has(ch)) parse_error("Unterminated string constant");
               else if (ch == quote) break;
               ret += ch;
           }
@@ -927,7 +854,7 @@
       });
 
       var read_name = with_eof_error("Unterminated identifier name", function() {
-          var name = "", ch, escaped = false;
+          var name, ch, escaped = false;
           var read_escaped_identifier_char = function() {
               escaped = true;
               next();
@@ -964,7 +891,7 @@
               }
               name += ch;
           }
-          if (RESERVED_WORDS(name) && escaped) {
+          if (RESERVED_WORDS.has(name) && escaped) {
               parse_error("Escaped characters are not allowed in keywords");
           }
           return name;
@@ -972,7 +899,7 @@
 
       var read_regexp = with_eof_error("Unterminated regular expression", function(source) {
           var prev_backslash = false, ch, in_class = false;
-          while ((ch = next(true))) if (NEWLINE_CHARS(ch)) {
+          while ((ch = next(true))) if (NEWLINE_CHARS.has(ch)) {
               parse_error("Unexpected line terminator");
           } else if (prev_backslash) {
               source += "\\" + ch;
@@ -1004,7 +931,7 @@
           function grow(op) {
               if (!peek()) return op;
               var bigger = op + peek();
-              if (OPERATORS(bigger)) {
+              if (OPERATORS.has(bigger)) {
                   next();
                   return grow(bigger);
               } else {
@@ -1054,9 +981,9 @@
       function read_word() {
           var word = read_name();
           if (prev_was_dot) return token("name", word);
-          return KEYWORDS_ATOM(word) ? token("atom", word)
-              : !KEYWORDS(word) ? token("name", word)
-              : OPERATORS(word) ? token("operator", word)
+          return KEYWORDS_ATOM.has(word) ? token("atom", word)
+              : !KEYWORDS.has(word) ? token("name", word)
+              : OPERATORS.has(word) ? token("operator", word)
               : token("keyword", word);
       }
 
@@ -1118,8 +1045,8 @@
                   break;
               }
               if (is_digit(code)) return read_num();
-              if (PUNC_CHARS(ch)) return token("punc", next());
-              if (OPERATOR_CHARS(ch)) return read_operator();
+              if (PUNC_CHARS.has(ch)) return token("punc", next());
+              if (OPERATOR_CHARS.has(ch)) return read_operator();
               if (code == 92 || is_identifier_start(ch)) return read_word();
               break;
           }
@@ -1732,20 +1659,20 @@
       };
 
       function track_used_binding_identifiers(is_parameter, strict) {
-          var parameters = {};
+          var parameters = new Set();
           var duplicate = false;
           var default_assignment = false;
           var spread = false;
           var strict_mode = !!strict;
           var tracker = {
               add_parameter: function(token) {
-                  if (parameters["$" + token.value] !== undefined) {
+                  if (parameters.has(token.value)) {
                       if (duplicate === false) {
                           duplicate = token;
                       }
                       tracker.check_strict();
                   } else {
-                      parameters["$" + token.value] = true;
+                      parameters.add(token.value);
                       if (is_parameter) {
                           switch (token.value) {
                             case "arguments":
@@ -1756,7 +1683,7 @@
                               }
                               break;
                             default:
-                              if (RESERVED_WORDS(token.value)) {
+                              if (RESERVED_WORDS.has(token.value)) {
                                   unexpected();
                               }
                           }
@@ -2127,7 +2054,7 @@
           // Note 2: If there is a nlb between yield and star, it is interpret as
           //         yield <explicit undefined> <inserted automatic semicolon> *
           if (can_insert_semicolon() ||
-              (is("punc") && PUNC_AFTER_EXPRESSION(S.token.value))) {
+              (is("punc") && PUNC_AFTER_EXPRESSION.has(S.token.value))) {
               has_expression = false;
 
           } else if (is("operator", "*")) {
@@ -2498,7 +2425,7 @@
           if (is("template_head")) {
               return subscripts(template_string(false), allow_calls);
           }
-          if (ATOMIC_START_TOKEN(S.token.type)) {
+          if (ATOMIC_START_TOKEN.has(S.token.type)) {
               return subscripts(as_atom_node(), allow_calls);
           }
           unexpected();
@@ -3126,7 +3053,7 @@
                   token_error(S.token, "Unexpected await identifier inside strict mode");
               }
           }
-          if (is("operator") && UNARY_PREFIX(start.value)) {
+          if (is("operator") && UNARY_PREFIX.has(start.value)) {
               next();
               handle_regexp();
               var ex = make_unary(AST_UnaryPrefix, start, maybe_unary(allow_calls));
@@ -3135,7 +3062,7 @@
               return ex;
           }
           var val = expr_atom(allow_calls, allow_arrows);
-          while (is("operator") && UNARY_POSTFIX(S.token.value) && !has_newline_before(S.token)) {
+          while (is("operator") && UNARY_POSTFIX.has(S.token.value) && !has_newline_before(S.token)) {
               if (val instanceof AST_Arrow) unexpected();
               val = make_unary(AST_UnaryPostfix, S.token, val);
               val.start = start;
@@ -3270,7 +3197,7 @@
           var left = maybe_conditional(no_in);
           var val = S.token.value;
 
-          if (is("operator") && ASSIGNMENT(val)) {
+          if (is("operator") && ASSIGNMENT.has(val)) {
               if (is_assignable(left) || (left = to_destructuring(left)) instanceof AST_Destructuring) {
                   next();
                   return new AST_Assign({
@@ -3650,8 +3577,8 @@
   var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent_scope enclosed cname", {
       $documentation: "Base class for all statements introducing a lexical scope",
       $propdoc: {
-          variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
-          functions: "[Object/S] like `variables`, but only lists function declarations",
+          variables: "[Map/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
+          functions: "[Map/S] like `variables`, but only lists function declarations",
           uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
           uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`",
           parent_scope: "[AST_Scope?/S] link to the parent scope",
@@ -3667,8 +3594,8 @@
       },
       clone: function(deep) {
           var node = this._clone(deep);
-          if (this.variables) node.variables = this.variables.clone();
-          if (this.functions) node.functions = this.functions.clone();
+          if (this.variables) node.variables = new Map(this.variables);
+          if (this.functions) node.functions = new Map(this.functions);
           if (this.enclosed) node.enclosed = this.enclosed.slice();
           return node;
       },
@@ -3680,7 +3607,7 @@
   var AST_Toplevel = DEFNODE("Toplevel", "globals", {
       $documentation: "The toplevel scope",
       $propdoc: {
-          globals: "[Object/S] a map of name -> SymbolDef for all undeclared names",
+          globals: "[Map/S] a map of name -> SymbolDef for all undeclared names",
       },
       wrap_commonjs: function(name) {
           var body = this.body;
@@ -4121,8 +4048,11 @@
       }
   });
 
-  var AST_Dot = DEFNODE("Dot", null, {
+  var AST_Dot = DEFNODE("Dot", "quote", {
       $documentation: "A dotted property access expression",
+      $propdoc: {
+          quote: "[string] the original quote character when transformed from AST_Sub",
+      },
       _walk: function(visitor) {
           return visitor._visit(this, function() {
               this.expression._walk(visitor);
@@ -4762,7 +4692,7 @@
 
    ***********************************************************************/
 
-  (function(undefined) {
+  (function() {
 
       function _(node, descend) {
           node.DEFMETHOD("transform", function(tw, in_list) {
@@ -5278,16 +5208,18 @@
               might_need_semicolon = false;
 
               if (prev === ":" && ch === "}" || (!ch || !";}".includes(ch)) && prev !== ";") {
-                  if (options.semicolons || requireSemicolonChars(ch)) {
+                  if (options.semicolons || requireSemicolonChars.has(ch)) {
                       OUTPUT += ";";
                       current_col++;
                       current_pos++;
                   } else {
                       ensure_line_len();
-                      OUTPUT += "\n";
-                      current_pos++;
-                      current_line++;
-                      current_col = 0;
+                      if (current_col > 0) {
+                          OUTPUT += "\n";
+                          current_pos++;
+                          current_line++;
+                          current_col = 0;
+                      }
 
                       if (/^\s+$/.test(str)) {
                           // reset the semicolon flag, since we didn't print one
@@ -6120,7 +6052,7 @@
       AST_Arrow.DEFMETHOD("_do_print", function(output) {
           var self = this;
           var parent = output.parent();
-          var needs_parens = parent instanceof AST_Binary ||
+          var needs_parens = (parent instanceof AST_Binary && !(parent instanceof AST_Assign)) ||
               parent instanceof AST_Unary ||
               (parent instanceof AST_Call && self === parent.expression);
           if (needs_parens) { output.print("("); }
@@ -6528,7 +6460,7 @@
           var expr = self.expression;
           expr.print(output);
           var prop = self.property;
-          if (output.option("ie8") && RESERVED_WORDS(prop)) {
+          if (output.option("ie8") && RESERVED_WORDS.has(prop)) {
               output.print("[");
               output.add_mapping(self.end);
               output.print_string(prop);
@@ -6682,7 +6614,7 @@
               output.print_string(key);
           } else if ("" + +key == key && key >= 0) {
               output.print(make_num(key));
-          } else if (RESERVED_WORDS(key) ? !output.option("ie8") : is_identifier_string(key)) {
+          } else if (RESERVED_WORDS.has(key) ? !output.option("ie8") : is_identifier_string(key)) {
               if (quote && output.option("keep_quoted_props")) {
                   output.print_string(key, quote);
               } else {
@@ -6704,7 +6636,7 @@
               self.value instanceof AST_Symbol &&
               is_identifier_string(self.key) &&
               get_name(self.value) === self.key &&
-              is_identifier(self.key)
+              !RESERVED_WORDS.has(self.key)
           ) {
               print_property_name(self.key, self.quote, output);
 
@@ -7027,7 +6959,7 @@
       // pass 1: setup scope chaining and handle definitions
       var self = this;
       var scope = self.parent_scope = null;
-      var labels = new Dictionary();
+      var labels = new Map();
       var defun = null;
       var in_destructuring = null;
       var for_scopes = [];
@@ -7062,7 +6994,7 @@
               var save_defun = defun;
               var save_labels = labels;
               defun = scope = node;
-              labels = new Dictionary();
+              labels = new Map();
               descend();
               scope = save_scope;
               defun = save_defun;
@@ -7076,7 +7008,7 @@
               }
               labels.set(l.name, l);
               descend();
-              labels.del(l.name);
+              labels.delete(l.name);
               return true;        // no descend again
           }
           if (node instanceof AST_With) {
@@ -7182,7 +7114,7 @@
       self.walk(tw);
 
       // pass 2: find back references and eval
-      self.globals = new Dictionary();
+      self.globals = new Map();
       var tw = new TreeWalker(function(node, descend) {
           if (node instanceof AST_LoopControl && node.label) {
               node.label.thedef.references.push(node);
@@ -7250,7 +7182,7 @@
       if (options.safari10) {
           for (var i = 0; i < for_scopes.length; i++) {
               var scope = for_scopes[i];
-              scope.parent_scope.variables.each(function(def) {
+              scope.parent_scope.variables.forEach(function(def) {
                   push_uniq(scope.enclosed, def);
               });
           }
@@ -7271,8 +7203,8 @@
   });
 
   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.variables = new Map();         // map name to AST_SymbolVar (variables defined in this scope; includes functions)
+      this.functions = new Map();         // 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
@@ -7309,7 +7241,7 @@
       while (s) {
           push_uniq(s.enclosed, def);
           if (options.keep_fnames) {
-              s.functions.each(function(d) {
+              s.functions.forEach(function(d) {
                   if (keep_name(options.keep_fnames, d.name)) {
                       push_uniq(def.scope.enclosed, d);
                   }
@@ -7357,7 +7289,7 @@
       var ext = scope.enclosed;
       out: while (true) {
           var m = base54(++scope.cname);
-          if (!is_identifier(m)) continue; // skip over "do"
+          if (RESERVED_WORDS.has(m)) continue; // skip over "do"
 
           // https://github.com/mishoo/UglifyJS2/issues/242 -- do not
           // shadow a name reserved from mangling.
@@ -7455,9 +7387,9 @@
 
       var mangled_names = this.mangled_names = new Set();
       if (options.cache) {
-          this.globals.each(collect);
+          this.globals.forEach(collect);
           if (options.cache.props) {
-              options.cache.props.each(function(mangled_name) {
+              options.cache.props.forEach(function(mangled_name) {
                   mangled_names.add(mangled_name);
               });
           }
@@ -7472,16 +7404,16 @@
               return true;        // don't descend again in TreeWalker
           }
           if (node instanceof AST_Scope) {
-              node.variables.each(collect);
+              node.variables.forEach(collect);
               return;
           }
           if (node.is_block_scope()) {
-              node.block_scope.variables.each(collect);
+              node.block_scope.variables.forEach(collect);
               return;
           }
           if (node instanceof AST_Label) {
               var name;
-              do name = base54(++lname); while (!is_identifier(name));
+              do name = base54(++lname); while (RESERVED_WORDS.has(name));
               node.mangled_name = name;
               return true;
           }
@@ -7504,17 +7436,17 @@
 
   AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) {
       var cache = options.cache && options.cache.props;
-      var avoid = Object.create(null);
+      var avoid = new Set();
       options.reserved.forEach(to_avoid);
-      this.globals.each(add_def);
+      this.globals.forEach(add_def);
       this.walk(new TreeWalker(function(node) {
-          if (node instanceof AST_Scope) node.variables.each(add_def);
+          if (node instanceof AST_Scope) node.variables.forEach(add_def);
           if (node instanceof AST_SymbolCatch) add_def(node.definition());
       }));
       return avoid;
 
       function to_avoid(name) {
-          avoid[name] = true;
+          avoid.add(name);
       }
 
       function add_def(def) {
@@ -7531,9 +7463,9 @@
       options = this._default_mangler_options(options);
       var avoid = this.find_colliding_names(options);
       var cname = 0;
-      this.globals.each(rename);
+      this.globals.forEach(rename);
       this.walk(new TreeWalker(function(node) {
-          if (node instanceof AST_Scope) node.variables.each(rename);
+          if (node instanceof AST_Scope) node.variables.forEach(rename);
           if (node instanceof AST_SymbolCatch) rename(node.definition());
       }));
 
@@ -7541,7 +7473,7 @@
           var name;
           do {
               name = base54(cname++);
-          } while (avoid[name] || !is_identifier(name));
+          } while (avoid.has(name) || RESERVED_WORDS.has(name));
           return name;
       }
 
@@ -7603,21 +7535,21 @@
       var digits = "0123456789".split("");
       var chars, frequency;
       function reset() {
-          frequency = Object.create(null);
+          frequency = new Map();
           leading.forEach(function(ch) {
-              frequency[ch] = 0;
+              frequency.set(ch, 0);
           });
           digits.forEach(function(ch) {
-              frequency[ch] = 0;
+              frequency.set(ch, 0);
           });
       }
       base54.consider = function(str, delta) {
           for (var i = str.length; --i >= 0;) {
-              frequency[str[i]] += delta;
+              frequency.set(str[i], frequency.get(str[i]) + delta);
           }
       };
       function compare(a, b) {
-          return frequency[b] - frequency[a];
+          return frequency.get(b) - frequency.get(a);
       }
       base54.sort = function() {
           chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));
@@ -8061,7 +7993,7 @@
           }
 
           function reset_variables(tw, compressor, node) {
-              node.variables.each(function(def) {
+              node.variables.forEach(function(def) {
                   reset_def(compressor, def);
                   if (def.fixed === null) {
                       def.safe_ids = tw.safe_ids;
@@ -8074,7 +8006,7 @@
           }
 
           function reset_block_variables(compressor, node) {
-              if (node.block_scope) node.block_scope.variables.each(function(def) {
+              if (node.block_scope) node.block_scope.variables.forEach(function(def) {
                   reset_def(compressor, def);
               });
           }
@@ -8152,7 +8084,7 @@
                   return;
               } else if (parent instanceof AST_Array
                   || parent instanceof AST_Await
-                  || parent instanceof AST_Binary && lazy_op(parent.operator)
+                  || parent instanceof AST_Binary && lazy_op.has(parent.operator)
                   || parent instanceof AST_Conditional && node !== parent.condition
                   || parent instanceof AST_Expansion
                   || parent instanceof AST_Sequence && node === parent.tail_node()) {
@@ -8221,7 +8153,7 @@
               return true;
           });
           def_reduce_vars(AST_Binary, function(tw) {
-              if (!lazy_op(this.operator)) return;
+              if (!lazy_op.has(this.operator)) return;
               this.left.walk(tw);
               push(tw);
               this.right.walk(tw);
@@ -8409,7 +8341,7 @@
               mark_escaped(tw, d, this.scope, this, value, 0, 1);
           });
           def_reduce_vars(AST_Toplevel, function(tw, descend, compressor) {
-              this.globals.each(function(def) {
+              this.globals.forEach(function(def) {
                   reset_def(compressor, def);
               });
               reset_variables(tw, compressor, this);
@@ -8686,7 +8618,7 @@
       var global_names = makePredicate("Array Boolean clearInterval clearTimeout console Date decodeURI decodeURIComponent encodeURI encodeURIComponent Error escape eval EvalError Function isFinite isNaN JSON Math Number parseFloat parseInt RangeError ReferenceError RegExp Object setInterval setTimeout String SyntaxError TypeError unescape URIError");
       AST_SymbolRef.DEFMETHOD("is_declared", function(compressor) {
           return !this.definition().undeclared
-              || compressor.option("unsafe") && global_names(this.name);
+              || compressor.option("unsafe") && global_names.has(this.name);
       });
 
       var identifier_atom = makePredicate("Infinity NaN undefined");
@@ -8786,7 +8718,7 @@
                   }
                   // Stop only if candidate is found within conditional branches
                   if (!stop_if_hit && (!lhs_local || !replace_all)
-                      && (parent instanceof AST_Binary && lazy_op(parent.operator) && parent.left !== node
+                      && (parent instanceof AST_Binary && lazy_op.has(parent.operator) && parent.left !== node
                           || parent instanceof AST_Conditional && parent.condition !== node
                           || parent instanceof AST_If && parent.condition !== node)) {
                       stop_if_hit = parent;
@@ -8847,11 +8779,11 @@
                       || node instanceof AST_PropAccess
                           && (side_effects || node.expression.may_throw_on_access(compressor))
                       || node instanceof AST_SymbolRef
-                          && (lvalues[node.name] || side_effects && may_modify(node))
+                          && (lvalues.get(node.name) || side_effects && may_modify(node))
                       || node instanceof AST_VarDef && node.value
-                          && (node.name.name in lvalues || side_effects && may_modify(node.name))
+                          && (lvalues.has(node.name.name) || side_effects && may_modify(node.name))
                       || (sym = is_lhs(node.left, node))
-                          && (sym instanceof AST_PropAccess || sym.name in lvalues)
+                          && (sym instanceof AST_PropAccess || lvalues.has(sym.name))
                       || may_throw
                           && (in_try ? node.has_side_effects(compressor) : side_effects_external(node))) {
                       stop_after = node;
@@ -8906,7 +8838,7 @@
                       // Locate symbols which may execute code outside of scanning range
                       var lvalues = get_lvalues(candidate);
                       var lhs_local = is_lhs_local(lhs);
-                      if (lhs instanceof AST_SymbolRef) lvalues[lhs.name] = false;
+                      if (lhs instanceof AST_SymbolRef) lvalues.set(lhs.name, false);
                       var side_effects = value_has_side_effects(candidate);
                       var replace_all = replace_all_symbols();
                       var may_throw = candidate.may_throw(compressor);
@@ -9001,7 +8933,7 @@
                       if (fn_strict && !member(fn_strict, fn.body)) fn_strict = false;
                       var len = fn.argnames.length;
                       args = iife.args.slice(len);
-                      var names = Object.create(null);
+                      var names = new Set();
                       for (var i = len; --i >= 0;) {
                           var sym = fn.argnames[i];
                           var arg = iife.args[i];
@@ -9009,8 +8941,8 @@
                               name: sym,
                               value: arg
                           }));
-                          if (sym.name in names) continue;
-                          names[sym.name] = true;
+                          if (names.has(sym.name)) continue;
+                          names.add(sym.name);
                           if (sym instanceof AST_Expansion) {
                               var elements = iife.args.slice(i);
                               if (all(elements, function(arg) {
@@ -9119,13 +9051,13 @@
                   if (parent instanceof AST_Assign) {
                       if (write_only
                           && !(parent.left instanceof AST_PropAccess
-                              || parent.left.name in lvalues)) {
+                              || lvalues.has(parent.left.name))) {
                           return find_stop(parent, level + 1, write_only);
                       }
                       return node;
                   }
                   if (parent instanceof AST_Binary) {
-                      if (write_only && (!lazy_op(parent.operator) || parent.left === node)) {
+                      if (write_only && (!lazy_op.has(parent.operator) || parent.left === node)) {
                           return find_stop(parent, level + 1, write_only);
                       }
                       return node;
@@ -9193,13 +9125,13 @@
               }
 
               function get_lvalues(expr) {
-                  var lvalues = Object.create(null);
+                  var lvalues = new Map();
                   if (expr instanceof AST_Unary) return lvalues;
                   var tw = new TreeWalker(function(node, descend) {
                       var sym = node;
                       while (sym instanceof AST_PropAccess) sym = sym.expression;
                       if (sym instanceof AST_SymbolRef || sym instanceof AST_This) {
-                          lvalues[sym.name] = lvalues[sym.name] || is_modified(compressor, tw, node, node, 0);
+                          lvalues.set(sym.name, lvalues.get(sym.name) || is_modified(compressor, tw, node, node, 0));
                       }
                   });
                   get_rvalue(expr).walk(tw);
@@ -9244,7 +9176,7 @@
                   return lhs instanceof AST_SymbolRef
                       && lhs.definition().scope === scope
                       && !(in_loop
-                          && (lhs.name in lvalues
+                          && (lvalues.has(lhs.name)
                               || candidate instanceof AST_Unary
                               || candidate instanceof AST_Assign && candidate.operator != "="));
               }
@@ -9917,15 +9849,15 @@
 
       // methods to determine whether an expression has a boolean result type
       (function(def_is_boolean) {
-          var unary_bool = [ "!", "delete" ];
-          var binary_bool = [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ];
+          const unary_bool = makePredicate("! delete");
+          const binary_bool = makePredicate("in instanceof == != === !== < <= >= >");
           def_is_boolean(AST_Node, return_false);
           def_is_boolean(AST_UnaryPrefix, function() {
-              return member(this.operator, unary_bool);
+              return unary_bool.has(this.operator);
           });
           def_is_boolean(AST_Binary, function() {
-              return member(this.operator, binary_bool)
-                  || lazy_op(this.operator)
+              return binary_bool.has(this.operator)
+                  || lazy_op.has(this.operator)
                       && this.left.is_boolean()
                       && this.right.is_boolean();
           });
@@ -9950,16 +9882,16 @@
           def_is_number(AST_Number, return_true);
           var unary = makePredicate("+ - ~ ++ --");
           def_is_number(AST_Unary, function() {
-              return unary(this.operator);
+              return unary.has(this.operator);
           });
           var binary = makePredicate("- * / % & | ^ << >> >>>");
           def_is_number(AST_Binary, function(compressor) {
-              return binary(this.operator) || this.operator == "+"
+              return binary.has(this.operator) || this.operator == "+"
                   && this.left.is_number(compressor)
                   && this.right.is_number(compressor);
           });
           def_is_number(AST_Assign, function(compressor) {
-              return binary(this.operator.slice(0, -1))
+              return binary.has(this.operator.slice(0, -1))
                   || this.operator == "=" && this.right.is_number(compressor);
           });
           def_is_number(AST_Sequence, function(compressor) {
@@ -10003,7 +9935,7 @@
       var unary_side_effects = makePredicate("delete ++ --");
 
       function is_lhs(node, parent) {
-          if (parent instanceof AST_Unary && unary_side_effects(parent.operator)) return parent.expression;
+          if (parent instanceof AST_Unary && unary_side_effects.has(parent.operator)) return parent.expression;
           if (parent instanceof AST_Assign && parent.left === node) return node;
       }
 
@@ -10090,7 +10022,7 @@
       }
 
       function convert_to_predicate(obj) {
-          for (var key in obj) {
+          for (var key of Object.keys(obj)) {
               obj[key] = makePredicate(obj[key]);
           }
       }
@@ -10204,7 +10136,7 @@
               } else {
                   return this instanceof AST_UnaryPrefix
                       && this.expression instanceof AST_Constant
-                      && unaryPrefix(this.operator);
+                      && unaryPrefix.has(this.operator);
               }
           });
           def_eval(AST_Statement, function() {
@@ -10280,7 +10212,7 @@
                           && e.fixed_value() instanceof AST_Lambda)) {
                   return typeof function() {};
               }
-              if (!non_converting_unary(this.operator)) depth++;
+              if (!non_converting_unary.has(this.operator)) depth++;
               e = e._eval(compressor, depth);
               if (e === this.expression) return this;
               switch (this.operator) {
@@ -10299,7 +10231,7 @@
           });
           var non_converting_binary = makePredicate("&& || === !==");
           def_eval(AST_Binary, function(compressor, depth) {
-              if (!non_converting_binary(this.operator)) depth++;
+              if (!non_converting_binary.has(this.operator)) depth++;
               var left = this.left._eval(compressor, depth);
               if (left === this.left) return this;
               var right = this.right._eval(compressor, depth);
@@ -10415,7 +10347,8 @@
                       if (first_arg == null || first_arg.thedef && first_arg.thedef.undeclared) {
                           return this.clone();
                       }
-                      if (!(static_values[exp.name] || return_false)(key)) return this;
+                      var static_value = static_values[exp.name];
+                      if (!static_value || !static_value.has(key)) return this;
                       val = global_objs[exp.name];
                   } else {
                       val = exp._eval(compressor, depth + 1);
@@ -10454,11 +10387,14 @@
                       if ((first_arg == null || first_arg.thedef && first_arg.thedef.undeclared)) {
                           return this.clone();
                       }
-                      if (!(static_fns[e.name] || return_false)(key)) return this;
+                      var static_fn = static_fns[e.name];
+                      if (!static_fn || !static_fn.has(key)) return this;
                       val = global_objs[e.name];
                   } else {
                       val = e._eval(compressor, depth + 1);
-                      if (val === e || !(val && native_fns[val.constructor.name] || return_false)(key)) return this;
+                      if (val === e || !val) return this;
+                      var native_fn = native_fns[val.constructor.name];
+                      if (!native_fn || !native_fn.has(key)) return this;
                   }
                   var args = [];
                   for (var i = 0, len = this.args.length; i < len; i++) {
@@ -10576,10 +10512,11 @@
               ) {
                   return false;
               }
-              if (is_undeclared_ref(expr) && global_pure_fns(expr.name)) return true;
+              if (is_undeclared_ref(expr) && global_pure_fns.has(expr.name)) return true;
               if (expr instanceof AST_Dot
                   && is_undeclared_ref(expr.expression)
-                  && (static_fns.hasOwnProperty(expr.expression.name) && static_fns[expr.expression.name] || return_false)(expr.property)) {
+                  && static_fns.hasOwnProperty(expr.expression.name)
+                  && static_fns[expr.expression.name].has(expr.property)) {
                   return true;
               }
           }
@@ -10588,22 +10525,22 @@
       AST_Node.DEFMETHOD("is_call_pure", return_false);
       AST_Dot.DEFMETHOD("is_call_pure", function(compressor) {
           if (!compressor.option("unsafe")) return;
-          var expr = this.expression;
-          var fns = return_false;
+          const expr = this.expression;
+          let map;
           if (expr instanceof AST_Array) {
-              fns = native_fns.Array;
+              map = native_fns.Array;
           } else if (expr.is_boolean()) {
-              fns = native_fns.Boolean;
+              map = native_fns.Boolean;
           } else if (expr.is_number(compressor)) {
-              fns = native_fns.Number;
+              map = native_fns.Number;
           } else if (expr instanceof AST_RegExp) {
-              fns = native_fns.RegExp;
+              map = native_fns.RegExp;
           } else if (expr.is_string(compressor)) {
-              fns = native_fns.String;
+              map = native_fns.String;
           } else if (!this.may_throw_on_access(compressor)) {
-              fns = native_fns.Object;
+              map = native_fns.Object;
           }
-          return fns(this.property);
+          return map && map.has(this.property);
       });
 
       // determine if expression has side effects
@@ -10670,7 +10607,7 @@
                   || this.alternative.has_side_effects(compressor);
           });
           def_has_side_effects(AST_Unary, function(compressor) {
-              return unary_side_effects(this.operator)
+              return unary_side_effects.has(this.operator)
                   || this.expression.has_side_effects(compressor);
           });
           def_has_side_effects(AST_SymbolRef, function(compressor) {
@@ -11000,19 +10937,17 @@
               }
               if (node instanceof AST_Unary && node.write_only) return node.expression;
           };
-          var in_use = [];
-          var in_use_ids = Object.create(null); // avoid expensive linear scans of in_use
-          var fixed_ids = Object.create(null);
+          var in_use_ids = new Map();
+          var fixed_ids = new Map();
           if (self instanceof AST_Toplevel && compressor.top_retain) {
-              self.variables.each(function(def) {
-                  if (compressor.top_retain(def) && !(def.id in in_use_ids)) {
-                      in_use_ids[def.id] = true;
-                      in_use.push(def);
+              self.variables.forEach(function(def) {
+                  if (compressor.top_retain(def) && !in_use_ids.has(def.id)) {
+                      in_use_ids.set(def.id, def);
                   }
               });
           }
-          var var_defs_by_id = new Dictionary();
-          var initializations = new Dictionary();
+          var var_defs_by_id = new Map();
+          var initializations = new Map();
           var destructuring_value = null;
           // pass 1: find out which symbols are directly used in
           // this scope (not in nested scopes).
@@ -11022,9 +10957,8 @@
                   node.argnames.forEach(function(argname) {
                       if (!(argname instanceof AST_SymbolDeclaration)) return;
                       var def = argname.definition();
-                      if (!(def.id in in_use_ids)) {
-                          in_use_ids[def.id] = true;
-                          in_use.push(def);
+                      if (!in_use_ids.has(def.id)) {
+                          in_use_ids.set(def.id, def);
                       }
                   });
               }
@@ -11033,30 +10967,28 @@
                   var node_def = node.name.definition();
                   var in_export = tw.parent() instanceof AST_Export;
                   if (in_export || !drop_funcs && scope === self) {
-                      if (node_def.global && !(node_def.id in in_use_ids)) {
-                          in_use_ids[node_def.id] = true;
-                          in_use.push(node_def);
+                      if (node_def.global && !in_use_ids.has(node_def.id)) {
+                          in_use_ids.set(node_def.id, node_def);
                       }
                   }
-                  initializations.add(node_def.id, node);
+                  map_add(initializations, node_def.id, node);
                   return true; // don't go in nested scopes
               }
               if (node instanceof AST_SymbolFunarg && scope === self) {
-                  var_defs_by_id.add(node.definition().id, node);
+                  map_add(var_defs_by_id, node.definition().id, node);
               }
               if (node instanceof AST_Definitions && scope === self) {
                   var in_export = tw.parent() instanceof AST_Export;
                   node.definitions.forEach(function(def) {
                       if (def.name instanceof AST_SymbolVar) {
-                          var_defs_by_id.add(def.name.definition().id, def);
+                          map_add(var_defs_by_id, def.name.definition().id, def);
                       }
                       if (in_export || !drop_vars) {
                           def.name.walk(new TreeWalker(function(node) {
                               if (node instanceof AST_SymbolDeclaration) {
                                   var def = node.definition();
-                                  if ((in_export || def.global) && !(def.id in in_use_ids)) {
-                                      in_use_ids[def.id] = true;
-                                      in_use.push(def);
+                                  if ((in_export || def.global) && !in_use_ids.has(def.id)) {
+                                      in_use_ids.set(def.id, def);
                                   }
                               }
                           }));
@@ -11069,9 +11001,9 @@
                               destructuring_value = destructuring_cache;
                           } else {
                               var node_def = def.name.definition();
-                              initializations.add(node_def.id, def.value);
+                              map_add(initializations, node_def.id, def.value);
                               if (!node_def.chained && def.name.fixed_value() === def.value) {
-                                  fixed_ids[node_def.id] = def;
+                                  fixed_ids.set(node_def.id, def);
                               }
                           }
                           if (def.value.has_side_effects(compressor)) {
@@ -11082,7 +11014,7 @@
                   return true;
               }
               if (node.destructuring && destructuring_value) {
-                  initializations.add(node.name, destructuring_value);
+                  map_add(initializations, node.name, destructuring_value);
               }
               return scan_ref_scoped(node, descend);
           });
@@ -11091,12 +11023,12 @@
           // initialization code to figure out if it uses other
           // symbols (that may not be in_use).
           tw = new TreeWalker(scan_ref_scoped);
-          for (var i = 0; i < in_use.length; i++) {
-              var init = initializations.get(in_use[i].id);
+          in_use_ids.forEach(function (def) {
+              var init = initializations.get(def.id);
               if (init) init.forEach(function(init) {
                   init.walk(tw);
               });
-          }
+          });
           // pass 3: we should drop declarations not in_use
           var tt = new TreeTransformer(
               function before(node, descend, in_list) {
@@ -11105,9 +11037,9 @@
                       var sym = assign_as_unused(node);
                       if (sym instanceof AST_SymbolRef) {
                           var def = sym.definition();
-                          var in_use = def.id in in_use_ids;
+                          var in_use = in_use_ids.has(def.id);
                           if (node instanceof AST_Assign) {
-                              if (!in_use || def.id in fixed_ids && fixed_ids[def.id] !== node) {
+                              if (!in_use || fixed_ids.has(def.id) && fixed_ids.get(def.id) !== node) {
                                   return maintain_this_binding(parent, node, node.right.transform(tt));
                               }
                           } else if (!in_use) return make_node(AST_Number, node, {
@@ -11125,7 +11057,7 @@
                       // any declarations with same name will overshadow
                       // name of this anonymous function and can therefore
                       // never be used anywhere
-                      if (!(def.id in in_use_ids) || def.orig.length > 1) node.name = null;
+                      if (!in_use_ids.has(def.id) || def.orig.length > 1) node.name = null;
                   }
                   if (node instanceof AST_Lambda && !(node instanceof AST_Accessor)) {
                       var trim = !compressor.option("keep_fargs");
@@ -11142,7 +11074,7 @@
                           // them would stop that TypeError which would happen
                           // if someone called it with an incorrectly formatted
                           // parameter.
-                          if (!(sym instanceof AST_Destructuring) && !(sym.definition().id in in_use_ids)) {
+                          if (!(sym instanceof AST_Destructuring) && !in_use_ids.has(sym.definition().id)) {
                               sym.__unused = true;
                               if (trim) {
                                   a.pop();
@@ -11155,7 +11087,7 @@
                   }
                   if ((node instanceof AST_Defun || node instanceof AST_DefClass) && node !== self) {
                       var def = node.name.definition();
-                      var keep = (def.id in in_use_ids) || !drop_funcs && def.global;
+                      var keep = in_use_ids.has(def.id) || !drop_funcs && def.global;
                       if (!keep) {
                           compressor[node.name.unreferenced() ? "warn" : "info"]("Dropping unused function {name} [{file}:{line},{col}]", template(node.name));
                           def.eliminated++;
@@ -11182,8 +11114,8 @@
                                   && (def.name.names.length
                                       || def.name.is_array
                                       || compressor.option("pure_getters") != true)
-                              || sym.id in in_use_ids) {
-                              if (def.value && sym.id in fixed_ids && fixed_ids[sym.id] !== def) {
+                              || in_use_ids.has(sym.id)) {
+                              if (def.value && fixed_ids.has(sym.id) && fixed_ids.get(sym.id) !== def) {
                                   def.value = def.value.drop_side_effect_free(compressor);
                               }
                               if (def.name instanceof AST_SymbolVar) {
@@ -11198,8 +11130,8 @@
                                               left: ref,
                                               right: def.value
                                           });
-                                          if (fixed_ids[sym.id] === def) {
-                                              fixed_ids[sym.id] = assign;
+                                          if (fixed_ids.get(sym.id) === def) {
+                                              fixed_ids.set(sym.id, assign);
                                           }
                                           side_effects.push(assign.transform(tt));
                                       }
@@ -11326,19 +11258,17 @@
                   if (node instanceof AST_Assign) {
                       node.right.walk(tw);
                       if (!node_def.chained && node.left.fixed_value() === node.right) {
-                          fixed_ids[node_def.id] = node;
+                          fixed_ids.set(node_def.id, node);
                       }
                   }
                   return true;
               }
               if (node instanceof AST_SymbolRef) {
                   node_def = node.definition();
-                  if (!(node_def.id in in_use_ids)) {
-                      in_use_ids[node_def.id] = true;
-                      in_use.push(node_def);
+                  if (!in_use_ids.has(node_def.id)) {
+                      in_use_ids.set(node_def.id, node_def);
                       if (node_def = node_def.redefined()) {
-                          in_use_ids[node_def.id] = true;
-                          in_use.push(node_def);
+                          in_use_ids.set(node_def.id, node_def);
                       }
                   }
                   return true;
@@ -11365,7 +11295,7 @@
           if (hoist_funs || hoist_vars) {
               var dirs = [];
               var hoisted = [];
-              var vars = new Dictionary(), vars_found = 0, var_decl = 0;
+              var vars = new Map(), vars_found = 0, var_decl = 0;
               // let's count var_decl first, we seem to waste a lot of
               // space if we hoist `var` when there's only one.
               self.walk(new TreeWalker(function(node) {
@@ -11422,11 +11352,11 @@
               if (vars_found > 0) {
                   // collect only vars which don't show up in self's arguments list
                   var defs = [];
-                  vars.each(function(def, name) {
+                  vars.forEach(function(def, name) {
                       if (self instanceof AST_Lambda
                           && find_if(function(x) { return x.name == def.name.name; },
                                      self.args_as_names())) {
-                          vars.del(name);
+                          vars.delete(name);
                       } else {
                           def = def.clone();
                           def.value = null;
@@ -11492,13 +11422,12 @@
       AST_Scope.DEFMETHOD("var_names", function varNames() {
           var var_names = this._var_names;
           if (!var_names) {
-              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._var_names = var_names = new Set(this.parent_scope ? varNames.call(this.parent_scope) : null);
               this.enclosed.forEach(function(def) {
-                  var_names[def.name] = true;
+                  var_names.add(def.name);
               });
-              this.variables.each(function(def, name) {
-                  var_names[name] = true;
+              this.variables.forEach(function(def, name) {
+                  var_names.add(name);
               });
           }
           return var_names;
@@ -11508,8 +11437,8 @@
           var var_names = this.var_names();
           prefix = prefix.replace(/(?:^[^a-z_$]|[^a-z0-9_$])/ig, "_");
           var name = prefix;
-          for (var i = 0; var_names[name]; i++) name = prefix + "$" + i;
-          var_names[name] = true;
+          for (var i = 0; var_names.has(name); i++) name = prefix + "$" + i;
+          var_names.add(name);
           return name;
       });
 
@@ -11517,7 +11446,7 @@
           var self = this;
           if (!compressor.option("hoist_props") || compressor.has_directive("use asm")) return self;
           var top_retain = self instanceof AST_Toplevel && compressor.top_retain || return_false;
-          var defs_by_id = Object.create(null);
+          var defs_by_id = new Map();
           var tt = new TreeTransformer(function(node, descend) {
               if (node instanceof AST_Definitions && tt.parent() instanceof AST_Export) return node;
               if (node instanceof AST_VarDef) {
@@ -11532,7 +11461,7 @@
                       && (value = sym.fixed_value()) === node.value
                       && value instanceof AST_Object) {
                       descend(node, this);
-                      var defs = new Dictionary();
+                      var defs = new Map();
                       var assignments = [];
                       value.properties.forEach(function(prop) {
                           assignments.push(make_node(AST_VarDef, node, {
@@ -11540,14 +11469,14 @@
                               value: prop.value
                           }));
                       });
-                      defs_by_id[def.id] = defs;
+                      defs_by_id.set(def.id, defs);
                       return MAP.splice(assignments);
                   }
               }
               if (node instanceof AST_PropAccess && node.expression instanceof AST_SymbolRef) {
-                  var defs = defs_by_id[node.expression.definition().id];
+                  var defs = defs_by_id.get(node.expression.definition().id);
                   if (defs) {
-                      var def = defs.get(get_value(node.property));
+                      var def = defs.get(String(get_value(node.property)));
                       var sym = make_node(AST_SymbolRef, node, {
                           name: def.name,
                           scope: node.expression.scope,
@@ -11564,7 +11493,7 @@
                       scope: self
                   });
                   var def = self.def_variable(new_var);
-                  defs.set(key, def);
+                  defs.set(String(key), def);
                   self.enclosed.push(def);
                   return new_var;
               }
@@ -11626,7 +11555,7 @@
           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)) {
+              if (lazy_op.has(this.operator)) {
                   if (right === this.right) return this;
                   var node = this.clone();
                   node.right = right;
@@ -11674,7 +11603,7 @@
               return node;
           });
           def_drop_side_effect_free(AST_Unary, function(compressor, first_in_statement$$1) {
-              if (unary_side_effects(this.operator)) {
+              if (unary_side_effects.has(this.operator)) {
                   this.write_only = !this.expression.has_side_effects(compressor);
                   return this;
               }
@@ -12311,6 +12240,10 @@
                       return make_node(AST_Array, self, {
                           elements: self.args
                       }).optimize(compressor);
+                  } else if (self.args[0] instanceof AST_Number && self.args[0].value <= 11) {
+                      const elements = [];
+                      for (let i = 0; i < self.args[0].value; i++) elements.push(new AST_Hole);
+                      return new AST_Array({ elements });
                   }
                   break;
                 case "Object":
@@ -12670,9 +12603,9 @@
                   }
                   if (arg.__unused) continue;
                   if (!safe_to_inject
-                      || block_scoped[arg.name]
-                      || identifier_atom(arg.name)
-                      || scope.var_names()[arg.name]) {
+                      || block_scoped.has(arg.name)
+                      || identifier_atom.has(arg.name)
+                      || scope.var_names().has(arg.name)) {
                       return false;
                   }
                   if (in_loop) in_loop.push(arg.definition());
@@ -12689,9 +12622,9 @@
                   for (var j = stat.definitions.length; --j >= 0;) {
                       var name = stat.definitions[j].name;
                       if (name instanceof AST_Destructuring
-                          || block_scoped[name.name]
-                          || identifier_atom(name.name)
-                          || scope.var_names()[name.name]) {
+                          || block_scoped.has(name.name)
+                          || identifier_atom.has(name.name)
+                          || scope.var_names().has(name.name)) {
                           return false;
                       }
                       if (in_loop) in_loop.push(name.definition());
@@ -12701,21 +12634,21 @@
           }
 
           function can_inject_symbols() {
-              var block_scoped = Object.create(null);
+              var block_scoped = new Set();
               do {
                   scope = compressor.parent(++level);
                   if (scope.is_block_scope() && !(compressor.parent(level - 1) instanceof AST_Scope)) {
                       if (scope.block_scope) {
                           // TODO this is sometimes undefined during compression.
                           // But it should always have a value!
-                          scope.block_scope.variables.each(function (variable) {
-                              block_scoped[variable.name] = true;
+                          scope.block_scope.variables.forEach(function (variable) {
+                              block_scoped.add(variable.name);
                           });
                       }
                   }
                   if (scope instanceof AST_Catch) {
                       if (scope.argname) {
-                          block_scoped[scope.argname.name] = true;
+                          block_scoped.add(scope.argname.name);
                       }
                   } else if (scope instanceof AST_IterationStatement) {
                       in_loop = [];
@@ -12734,8 +12667,8 @@
               var def = name.definition();
               scope.variables.set(name.name, def);
               scope.enclosed.push(def);
-              if (!scope.var_names()[name.name]) {
-                  scope.var_names()[name.name] = true;
+              if (!scope.var_names().has(name.name)) {
+                  scope.var_names().add(name.name);
                   decls.push(make_node(AST_VarDef, name, {
                       name: name,
                       value: null
@@ -12758,7 +12691,7 @@
               for (i = len; --i >= 0;) {
                   var name = fn.argnames[i];
                   var value = self.args[i];
-                  if (name.__unused || !name.name || scope.var_names()[name.name]) {
+                  if (name.__unused || !name.name || scope.var_names().has(name.name)) {
                       if (value) expressions.push(value);
                   } else {
                       var symbol = make_node(AST_SymbolVar, name, name);
@@ -12813,26 +12746,11 @@
       });
 
       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});
-              }
-          }
-
+          if (
+              compressor.option("unsafe") &&
+              is_undeclared_ref(self.expression) &&
+              ["Object", "RegExp", "Function", "Error", "Array"].includes(self.expression.name)
+          ) return make_node(AST_Call, self, self).transform(compressor);
           return self;
       });
 
@@ -13022,7 +12940,7 @@
                   self.right = tmp;
               }
           }
-          if (commutativeOperators(self.operator)) {
+          if (commutativeOperators.has(self.operator)) {
               if (self.right.is_constant()
                   && !self.left.is_constant()) {
                   // if right is a constant, whatever side effects the
@@ -13413,7 +13331,7 @@
           // "x" + (y + "z")==>  "x" + y + "z"
           if (self.right instanceof AST_Binary
               && self.right.operator == self.operator
-              && (lazy_op(self.operator)
+              && (lazy_op.has(self.operator)
                   || (self.operator == "+"
                       && (self.right.left.is_string(compressor)
                           || (self.left.is_string(compressor)
@@ -13682,8 +13600,8 @@
           return reachable;
       }
 
-      var ASSIGN_OPS = [ "+", "-", "/", "*", "%", ">>", "<<", ">>>", "|", "^", "&" ];
-      var ASSIGN_OPS_COMMUTATIVE = [ "*", "|", "^", "&" ];
+      const ASSIGN_OPS = makePredicate("+ - / * % >> << >>> | ^ &");
+      const ASSIGN_OPS_COMMUTATIVE = makePredicate("* | ^ &");
       def_optimize(AST_Assign, function(self, compressor) {
           var def;
           if (compressor.option("dead_code")
@@ -13712,13 +13630,13 @@
               // x = expr1 OP expr2
               if (self.right.left instanceof AST_SymbolRef
                   && self.right.left.name == self.left.name
-                  && member(self.right.operator, ASSIGN_OPS)) {
+                  && ASSIGN_OPS.has(self.right.operator)) {
                   // x = x - 2  --->  x -= 2
                   self.operator = self.right.operator + "=";
                   self.right = self.right.right;
               } else if (self.right.right instanceof AST_SymbolRef
                   && self.right.right.name == self.left.name
-                  && member(self.right.operator, ASSIGN_OPS_COMMUTATIVE)
+                  && ASSIGN_OPS_COMMUTATIVE.has(self.right.operator)
                   && !self.right.left.has_side_effects(compressor)) {
                   // x = 2 & x  --->  x &= 2
                   self.operator = self.right.operator + "=";
@@ -14035,7 +13953,8 @@
                       && property.length <= prop.print_to_string().length + 1) {
                       return make_node(AST_Dot, self, {
                           expression: expr,
-                          property: property
+                          property: property,
+                          quote: prop.quote,
                       }).optimize(compressor);
                   }
               }
@@ -14050,17 +13969,17 @@
               && !(fn instanceof AST_Arrow)
               && prop instanceof AST_Number) {
               var index = prop.getValue();
-              var params = Object.create(null);
+              var params = new Set();
               var argnames = fn.argnames;
               for (var n = 0; n < argnames.length; n++) {
                   if (!(argnames[n] instanceof AST_SymbolFunarg)) {
                       break OPT_ARGUMENTS; // destructuring parameter - bail
                   }
                   var param = argnames[n].name;
-                  if (param in params) {
+                  if (params.has(param)) {
                       break OPT_ARGUMENTS; // duplicate parameter - bail
                   }
-                  params[param] = true;
+                  params.add(param);
               }
               var argname = fn.argnames[index];
               if (argname && compressor.has_directive("use strict")) {
@@ -20356,14 +20275,14 @@
       var cache;
       if (options.cache) {
           cache = options.cache.props;
-          cache.each(function(mangled_name) {
+          cache.forEach(function(mangled_name) {
               reserved.add(mangled_name);
           });
       } else {
-          cache = new Dictionary();
+          cache = new Map();
       }
 
-      var regex = options.regex;
+      var regex = options.regex && new RegExp(options.regex);
 
       // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
       // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
@@ -20377,23 +20296,33 @@
       var names_to_mangle = new Set();
       var unmangleable = new Set();
 
+      var keep_quoted_strict = options.keep_quoted === "strict";
+
       // step 1: find candidates to mangle
       ast.walk(new TreeWalker(function(node) {
           if (node instanceof AST_ObjectKeyVal) {
-              if (typeof node.key == "string") {
+              if (typeof node.key == "string" &&
+                  (!keep_quoted_strict || !node.quote)) {
                   add(node.key);
               }
           } else if (node instanceof AST_ObjectProperty) {
               // setter or getter, since KeyVal is handled above
-              add(node.key.name);
+              if (!keep_quoted_strict || !node.key.end.quote) {
+                  add(node.key.name);
+              }
           } else if (node instanceof AST_Dot) {
               var root = node;
               while (root.expression) {
                   root = root.expression;
               }
-              if (!(root.thedef && root.thedef.undeclared)) add(node.property);
+              if (!(root.thedef && root.thedef.undeclared) &&
+                  (!keep_quoted_strict || !node.quote)) {
+                  add(node.property);
+              }
           } else if (node instanceof AST_Sub) {
-              addStrings(node.property, add);
+              if (!keep_quoted_strict) {
+                  addStrings(node.property, add);
+              }
           } else if (node instanceof AST_Call
               && node.expression.print_to_string() == "Object.defineProperty") {
               addStrings(node.args[1], add);
@@ -20403,14 +20332,19 @@
       // step 2: transform the tree, renaming properties
       return ast.transform(new TreeTransformer(function(node) {
           if (node instanceof AST_ObjectKeyVal) {
-              if (typeof node.key == "string") {
+              if (typeof node.key == "string" &&
+                  (!keep_quoted_strict || !node.quote)) {
                   node.key = mangle(node.key);
               }
           } else if (node instanceof AST_ObjectProperty) {
               // setter or getter
-              node.key.name = mangle(node.key.name);
+              if (!keep_quoted_strict || !node.key.end.quote) {
+                  node.key.name = mangle(node.key.name);
+              }
           } else if (node instanceof AST_Dot) {
-              node.property = mangle(node.property);
+              if (!keep_quoted_strict || !node.quote) {
+                  node.property = mangle(node.property);
+              }
           } else if (!options.keep_quoted && node instanceof AST_Sub) {
               node.property = mangleStrings(node.property);
           } else if (node instanceof AST_Call
@@ -20521,15 +20455,15 @@
   function init_cache(cache) {
       if (!cache) return;
       if (!("props" in cache)) {
-          cache.props = new Dictionary();
-      } else if (!(cache.props instanceof Dictionary)) {
-          cache.props = Dictionary.fromObject(cache.props);
+          cache.props = new Map();
+      } else if (!(cache.props instanceof Map)) {
+          cache.props = map_from_object(cache.props);
       }
   }
 
   function to_json(cache) {
       return {
-          props: cache.props.toObject()
+          props: map_to_object(cache.props)
       };
   }
 
@@ -20639,7 +20573,7 @@
               }
               toplevel = options.parse.toplevel;
           }
-          if (quoted_props) {
+          if (quoted_props && options.mangle.properties.keep_quoted !== "strict") {
               reserve_quoted_keys(toplevel, quoted_props);
           }
           if (options.wrap) {
@@ -20730,6 +20664,24 @@
       }
   }
 
+  function default_options() {
+      const defs = {};
+
+      Object.keys(infer_options({ 0: 0 })).forEach((component) => {
+          const options = infer_options({
+              [component]: {0: 0}
+          });
+
+          if (options) defs[component] = options;
+      });
+      return defs;
+  }
+
+  function infer_options(options) {
+      var result = minify("", options);
+      return result.error && result.error.defs;
+  }
+
   /***********************************************************************
 
     A JavaScript tokenizer / parser / beautifier / compressor.
@@ -21830,126 +21782,16 @@
   exports.TreeTransformer = TreeTransformer;
   exports.TreeWalker = TreeWalker;
   exports.defaults = defaults;
-  exports.Dictionary = Dictionary;
   exports.push_uniq = push_uniq;
   exports.string_template = string_template;
   exports.base54 = base54;
   exports.Compressor = Compressor;
+  exports.to_ascii = to_ascii;
   exports.OutputStream = OutputStream;
   exports.parse = parse;
   exports.mangle_properties = mangle_properties;
   exports.reserve_quoted_keys = reserve_quoted_keys;
-  exports.JS_Parse_Error = JS_Parse_Error;
-  exports.tokenizer = tokenizer;
-  exports.to_ascii = to_ascii;
-  exports.AST_Accessor = AST_Accessor;
-  exports.AST_Arrow = AST_Arrow;
-  exports.AST_Atom = AST_Atom;
-  exports.AST_Await = AST_Await;
-  exports.AST_Binary = AST_Binary;
-  exports.AST_Block = AST_Block;
-  exports.AST_BlockStatement = AST_BlockStatement;
-  exports.AST_Boolean = AST_Boolean;
-  exports.AST_Break = AST_Break;
-  exports.AST_Call = AST_Call;
-  exports.AST_Case = AST_Case;
-  exports.AST_Catch = AST_Catch;
-  exports.AST_Class = AST_Class;
-  exports.AST_ClassExpression = AST_ClassExpression;
-  exports.AST_ConciseMethod = AST_ConciseMethod;
-  exports.AST_Conditional = AST_Conditional;
-  exports.AST_Const = AST_Const;
-  exports.AST_Continue = AST_Continue;
-  exports.AST_Debugger = AST_Debugger;
-  exports.AST_Default = AST_Default;
-  exports.AST_DefaultAssign = AST_DefaultAssign;
-  exports.AST_DefClass = AST_DefClass;
-  exports.AST_Definitions = AST_Definitions;
-  exports.AST_Defun = AST_Defun;
-  exports.AST_Destructuring = AST_Destructuring;
-  exports.AST_Directive = AST_Directive;
-  exports.AST_Do = AST_Do;
-  exports.AST_Dot = AST_Dot;
-  exports.AST_DWLoop = AST_DWLoop;
-  exports.AST_EmptyStatement = AST_EmptyStatement;
-  exports.AST_Exit = AST_Exit;
-  exports.AST_Expansion = AST_Expansion;
-  exports.AST_Export = AST_Export;
-  exports.AST_False = AST_False;
-  exports.AST_Finally = AST_Finally;
-  exports.AST_For = AST_For;
-  exports.AST_ForIn = AST_ForIn;
-  exports.AST_ForOf = AST_ForOf;
-  exports.AST_Function = AST_Function;
-  exports.AST_Hole = AST_Hole;
-  exports.AST_If = AST_If;
-  exports.AST_Import = AST_Import;
-  exports.AST_Infinity = AST_Infinity;
-  exports.AST_IterationStatement = AST_IterationStatement;
-  exports.AST_Jump = AST_Jump;
-  exports.AST_Label = AST_Label;
-  exports.AST_LabeledStatement = AST_LabeledStatement;
-  exports.AST_LabelRef = AST_LabelRef;
-  exports.AST_Lambda = AST_Lambda;
-  exports.AST_Let = AST_Let;
-  exports.AST_LoopControl = AST_LoopControl;
-  exports.AST_NameMapping = AST_NameMapping;
-  exports.AST_NaN = AST_NaN;
-  exports.AST_New = AST_New;
-  exports.AST_NewTarget = AST_NewTarget;
-  exports.AST_Null = AST_Null;
-  exports.AST_Number = AST_Number;
-  exports.AST_Object = AST_Object;
-  exports.AST_ObjectGetter = AST_ObjectGetter;
-  exports.AST_ObjectKeyVal = AST_ObjectKeyVal;
-  exports.AST_ObjectProperty = AST_ObjectProperty;
-  exports.AST_ObjectSetter = AST_ObjectSetter;
-  exports.AST_PrefixedTemplateString = AST_PrefixedTemplateString;
-  exports.AST_RegExp = AST_RegExp;
-  exports.AST_Return = AST_Return;
-  exports.AST_Scope = AST_Scope;
-  exports.AST_SimpleStatement = AST_SimpleStatement;
-  exports.AST_Statement = AST_Statement;
-  exports.AST_StatementWithBody = AST_StatementWithBody;
-  exports.AST_String = AST_String;
-  exports.AST_Sub = AST_Sub;
-  exports.AST_Super = AST_Super;
-  exports.AST_Switch = AST_Switch;
-  exports.AST_SwitchBranch = AST_SwitchBranch;
-  exports.AST_SymbolBlockDeclaration = AST_SymbolBlockDeclaration;
-  exports.AST_SymbolCatch = AST_SymbolCatch;
-  exports.AST_SymbolClass = AST_SymbolClass;
-  exports.AST_SymbolConst = AST_SymbolConst;
-  exports.AST_SymbolDeclaration = AST_SymbolDeclaration;
-  exports.AST_SymbolDefClass = AST_SymbolDefClass;
-  exports.AST_SymbolDefun = AST_SymbolDefun;
-  exports.AST_SymbolExport = AST_SymbolExport;
-  exports.AST_SymbolExportForeign = AST_SymbolExportForeign;
-  exports.AST_SymbolFunarg = AST_SymbolFunarg;
-  exports.AST_SymbolImport = AST_SymbolImport;
-  exports.AST_SymbolImportForeign = AST_SymbolImportForeign;
-  exports.AST_SymbolLambda = AST_SymbolLambda;
-  exports.AST_SymbolLet = AST_SymbolLet;
-  exports.AST_SymbolMethod = AST_SymbolMethod;
-  exports.AST_SymbolRef = AST_SymbolRef;
-  exports.AST_SymbolVar = AST_SymbolVar;
-  exports.AST_TemplateSegment = AST_TemplateSegment;
-  exports.AST_TemplateString = AST_TemplateString;
-  exports.AST_This = AST_This;
-  exports.AST_Throw = AST_Throw;
-  exports.AST_Toplevel = AST_Toplevel;
-  exports.AST_True = AST_True;
-  exports.AST_Try = AST_Try;
-  exports.AST_Unary = AST_Unary;
-  exports.AST_UnaryPostfix = AST_UnaryPostfix;
-  exports.AST_UnaryPrefix = AST_UnaryPrefix;
-  exports.AST_Undefined = AST_Undefined;
-  exports.AST_Var = AST_Var;
-  exports.AST_VarDef = AST_VarDef;
-  exports.AST_While = AST_While;
-  exports.AST_With = AST_With;
-  exports.AST_Yield = AST_Yield;
-  exports.walk_body = walk_body;
+  exports.default_options = default_options;
 
 }));
 //# sourceMappingURL=bundle.js.map