terser 4.0.1 → 4.1.2

package/dist/bundle.js

@@ -57,13 +57,6 @@
       return array.includes(name);
   }
 
-  function find_if(func, array) {
-      for (var i = 0, n = array.length; i < n; ++i) {
-          if (func(array[i]))
-              return array[i];
-      }
-  }
-
   class DefaultsError extends Error {
       constructor(msg, defs) {
           super();
@@ -86,15 +79,6 @@
       return ret;
   }
 
-  function merge(obj, ext) {
-      var count = 0;
-      for (var i in ext) if (HOP(ext, i)) {
-          obj[i] = ext[i];
-          count++;
-      }
-      return count;
-  }
-
   function noop() {}
   function return_false() { return false; }
   function return_true() { return true; }
@@ -194,13 +178,6 @@
       return new Set(words);
   }
 
-  function all(array, predicate) {
-      for (var i = array.length; --i >= 0;)
-          if (!predicate(array[i]))
-              return false;
-      return true;
-  }
-
   function map_add(map, key, value) {
       if (map.has(key)) {
           map.get(key).push(value);
@@ -231,29 +208,6 @@
       return Object.prototype.hasOwnProperty.call(obj, prop);
   }
 
-  // return true if the node at the top of the stack (that means the
-  // innermost node in the current output) is lexically the first in
-  // a statement.
-  function first_in_statement(stack) {
-      var node = stack.parent(-1);
-      for (var i = 0, p; p = stack.parent(i); i++) {
-          if (p instanceof AST_Statement && p.body === node)
-              return true;
-          if ((p instanceof AST_Sequence      && p.expressions[0] === node) ||
-              (p.TYPE == "Call"               && p.expression === node ) ||
-              (p instanceof AST_Dot           && p.expression === node ) ||
-              (p instanceof AST_Sub           && p.expression === node ) ||
-              (p instanceof AST_Conditional   && p.condition === node  ) ||
-              (p instanceof AST_Binary        && p.left === node       ) ||
-              (p instanceof AST_UnaryPostfix  && p.expression === node )
-          ) {
-              node = p;
-          } else {
-              return false;
-          }
-      }
-  }
-
   function keep_name(keep_setting, name) {
       return keep_setting === true
           || (keep_setting instanceof RegExp && keep_setting.test(name));
@@ -321,6 +275,7 @@
   var RE_ES6_OCT_NUMBER = /^0o[0-7]+$/i;
   var RE_BIN_NUMBER = /^0b[01]+$/i;
   var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
+  var RE_BIG_INT = /^(0[xob])?[0-9]+n$/i;
 
   var OPERATORS = makePredicate([
       "in",
@@ -644,8 +599,10 @@
       }
 
       function read_num(prefix) {
-          var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
+          var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".", is_big_int = false;
           var num = read_while(function(ch, i) {
+              if (is_big_int) return false;
+
               var code = ch.charCodeAt(0);
               switch (code) {
                 case 98: case 66: // bB
@@ -662,12 +619,24 @@
                 case (after_e = false, 46): // .
                   return (!has_dot && !has_x && !has_e) ? (has_dot = true) : false;
               }
+
+              if (ch === "n") {
+                  is_big_int = true;
+
+                  return true;
+              }
+
               return RE_NUM_LITERAL.test(ch);
           });
           if (prefix) num = prefix + num;
           if (RE_OCT_NUMBER.test(num) && next_token.has_directive("use strict")) {
               parse_error("Legacy octal literals are not allowed in strict mode");
           }
+          if (num.endsWith("n")) {
+              if (!has_dot && RE_BIG_INT.test(num))
+                  return token("big_int", num.replace("n", ""));
+              parse_error("Invalid or unexpected token");
+          }
           var valid = parse_js_number(num);
           if (!isNaN(valid)) {
               return token("num", valid);
@@ -1111,7 +1080,7 @@
       {}
   );
 
-  var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "string", "regexp", "name" ]);
+  var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "big_int", "string", "regexp", "name" ]);
 
   /* -----[ Parser ]----- */
 
@@ -1198,9 +1167,7 @@
       function expect(punc) { return expect_token("punc", punc); }
 
       function has_newline_before(token) {
-          return token.nlb || !all(token.comments_before, function(comment) {
-              return !comment.nlb;
-          });
+          return token.nlb || !token.comments_before.every((comment) => !comment.nlb);
       }
 
       function can_insert_semicolon() {
@@ -1266,6 +1233,7 @@
               return dir && stat.body instanceof AST_String ? new AST_Directive(stat.body) : stat;
             case "template_head":
             case "num":
+            case "big_int":
             case "regexp":
             case "operator":
             case "atom":
@@ -1448,7 +1416,7 @@
           if (label.name === "await" && is_in_async()) {
               token_error(S.prev, "await cannot be used as label inside async function");
           }
-          if (find_if(function(l) { return l.name == label.name; }, S.labels)) {
+          if (S.labels.some((l) => l.name === label.name)) {
               // ECMA-262, 12.12: An ECMAScript program is considered
               // syntactically incorrect if it contains a
               // LabelledStatement that is enclosed by a
@@ -1484,7 +1452,7 @@
               label = as_symbol(AST_LabelRef, true);
           }
           if (label != null) {
-              ldef = find_if(function(l) { return l.name == label.name; }, S.labels);
+              ldef = S.labels.find((l) => l.name === label.name);
               if (!ldef)
                   croak("Undefined label " + label.name);
               label.thedef = ldef;
@@ -2235,6 +2203,9 @@
             case "num":
               ret = new AST_Number({ start: tok, end: tok, value: tok.value });
               break;
+            case "big_int":
+              ret = new AST_BigInt({ start: tok, end: tok, value: tok.value });
+              break;
             case "string":
               ret = new AST_String({
                   start : tok,
@@ -2398,7 +2369,7 @@
               return subscripts(cls, allow_calls);
           }
           if (is("template_head")) {
-              return subscripts(template_string(false), allow_calls);
+              return subscripts(template_string(), allow_calls);
           }
           if (ATOMIC_START_TOKEN.has(S.token.type)) {
               return subscripts(as_atom_node(), allow_calls);
@@ -2886,6 +2857,7 @@
               }
             case "string":
             case "num":
+            case "big_int":
             case "keyword":
             case "atom":
               next();
@@ -2989,7 +2961,7 @@
               return subscripts(new AST_PrefixedTemplateString({
                   start: start,
                   prefix: expr,
-                  template_string: template_string(true),
+                  template_string: template_string(),
                   end: prev()
               }), allow_calls);
           }
@@ -3279,8 +3251,7 @@
 
    ***********************************************************************/
 
-  function DEFNODE(type, props, methods, base) {
-      if (arguments.length < 4) base = AST_Node;
+  function DEFNODE(type, props, methods, base = AST_Node) {
       if (!props) props = [];
       else props = props.split(/\s+/);
       var self_props = props;
@@ -4342,6 +4313,13 @@
       }
   }, AST_Constant);
 
+  var AST_BigInt = DEFNODE("BigInt", "value", {
+      $documentation: "A big int literal",
+      $propdoc: {
+          value: "[string] big int value"
+      }
+  }, AST_Constant);
+
   var AST_RegExp = DEFNODE("RegExp", "value", {
       $documentation: "A regexp literal",
       $propdoc: {
@@ -4496,12 +4474,13 @@
   };
 
   // Tree transformer helpers.
-  function TreeTransformer(before, after) {
-      TreeWalker.call(this);
-      this.before = before;
-      this.after = after;
+  class TreeTransformer extends TreeWalker {
+      constructor(before, after) {
+          super();
+          this.before = before;
+          this.after = after;
+      }
   }
-  TreeTransformer.prototype = new TreeWalker;
 
   var ast = /*#__PURE__*/Object.freeze({
     AST_Accessor: AST_Accessor,
@@ -4510,6 +4489,7 @@
     AST_Assign: AST_Assign,
     AST_Atom: AST_Atom,
     AST_Await: AST_Await,
+    AST_BigInt: AST_BigInt,
     AST_Binary: AST_Binary,
     AST_Block: AST_Block,
     AST_BlockStatement: AST_BlockStatement,
@@ -4889,6 +4869,29 @@
 
   })();
 
+  // return true if the node at the top of the stack (that means the
+  // innermost node in the current output) is lexically the first in
+  // a statement.
+  function first_in_statement(stack) {
+      let node = stack.parent(-1);
+      for (let i = 0, p; p = stack.parent(i); i++) {
+          if (p instanceof AST_Statement && p.body === node)
+              return true;
+          if ((p instanceof AST_Sequence && p.expressions[0] === node) ||
+              (p.TYPE === "Call" && p.expression === node) ||
+              (p instanceof AST_Dot && p.expression === node) ||
+              (p instanceof AST_Sub && p.expression === node) ||
+              (p instanceof AST_Conditional && p.condition === node) ||
+              (p instanceof AST_Binary && p.left === node) ||
+              (p instanceof AST_UnaryPostfix && p.expression === node)
+          ) {
+              node = p;
+          } else {
+              return false;
+          }
+      }
+  }
+
   /***********************************************************************
 
     A JavaScript tokenizer / parser / beautifier / compressor.
@@ -5452,9 +5455,9 @@
           if (!token) return;
           var comments = token[tail ? "comments_before" : "comments_after"];
           if (!comments || comments._dumped === self) return;
-          if (!(node instanceof AST_Statement || all(comments, function(c) {
-              return !/comment[134]/.test(c.type);
-          }))) return;
+          if (!(node instanceof AST_Statement || comments.every((c) =>
+              !/comment[134]/.test(c.type)
+          ))) return;
           comments._dumped = self;
           var insert = OUTPUT.length;
           comments.filter(comment_filter, node).forEach(function(c, i) {
@@ -5770,6 +5773,16 @@
           }
       });
 
+      PARENS(AST_BigInt, function(output) {
+          var p = output.parent();
+          if (p instanceof AST_PropAccess && p.expression === this) {
+              var value = this.getValue();
+              if (value.startsWith("-")) {
+                  return true;
+              }
+          }
+      });
+
       PARENS([ AST_Assign, AST_Conditional ], function(output) {
           var p = output.parent();
           // !(a = false) → true
@@ -6714,6 +6727,9 @@
               output.print(make_num(self.getValue()));
           }
       });
+      DEFPRINT(AST_BigInt, function(self, output) {
+          output.print(self.getValue() + "n");
+      });
 
       DEFPRINT(AST_RegExp, function(self, output) {
           var regexp = self.getValue();
@@ -6756,18 +6772,27 @@
       }
 
       function make_num(num) {
-          var str = num.toString(10), a = [ str.replace(/^0\./, ".").replace("e+", "e") ], m;
+          var str = num.toString(10).replace(/^0\./, ".").replace("e+", "e");
+          var candidates = [ str ];
           if (Math.floor(num) === 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);
+              if (num < 0) {
+                  candidates.push("-0x" + (-num).toString(16).toLowerCase());
+              } else {
+                  candidates.push("0x" + num.toString(16).toLowerCase());
               }
-          } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) {
-              a.push(m[2] + "e-" + (m[1].length + m[2].length));
           }
-          return best_of(a);
+          var match, len, digits;
+          if (match = /^\.0+/.exec(str)) {
+              len = match[0].length;
+              digits = str.slice(len);
+              candidates.push(digits + "e-" + (digits.length + len - 1));
+          } else if (match = /0+$/.exec(str)) {
+              len = match[0].length;
+              candidates.push(str.slice(0, -len) + "e" + len);
+          } else if (match = /^(\d)\.(\d+)e(-?\d+)$/.exec(str)) {
+              candidates.push(match[1] + match[2] + "e" + (match[3] - match[2].length));
+          }
+          return best_of(candidates);
       }
 
       function make_block(stmt, output) {
@@ -7037,7 +7062,7 @@
               } else {
                   def = defun.def_variable(node, node.TYPE == "SymbolVar" ? null : undefined);
               }
-              if (!all(def.orig, function(sym) {
+              if (!def.orig.every((sym) => {
                   if (sym === node) return true;
                   if (node instanceof AST_SymbolBlockDeclaration) {
                       return sym instanceof AST_SymbolLambda;
@@ -7601,127 +7626,128 @@
 
    ***********************************************************************/
 
-  function Compressor(options, false_by_default) {
-      if (!(this instanceof Compressor))
-          return new Compressor(options, false_by_default);
-      TreeTransformer.call(this, this.before, this.after);
-      if (options.defaults !== undefined && !options.defaults) false_by_default = true;
-      this.options = defaults(options, {
-          arguments     : false,
-          arrows        : !false_by_default,
-          booleans      : !false_by_default,
-          booleans_as_integers : false,
-          collapse_vars : !false_by_default,
-          comparisons   : !false_by_default,
-          computed_props: !false_by_default,
-          conditionals  : !false_by_default,
-          dead_code     : !false_by_default,
-          defaults      : true,
-          directives    : !false_by_default,
-          drop_console  : false,
-          drop_debugger : !false_by_default,
-          ecma          : 5,
-          evaluate      : !false_by_default,
-          expression    : false,
-          global_defs   : false,
-          hoist_funs    : false,
-          hoist_props   : !false_by_default,
-          hoist_vars    : false,
-          ie8           : false,
-          if_return     : !false_by_default,
-          inline        : !false_by_default,
-          join_vars     : !false_by_default,
-          keep_classnames: false,
-          keep_fargs    : true,
-          keep_fnames   : false,
-          keep_infinity : false,
-          loops         : !false_by_default,
-          module        : false,
-          negate_iife   : !false_by_default,
-          passes        : 1,
-          properties    : !false_by_default,
-          pure_getters  : !false_by_default && "strict",
-          pure_funcs    : null,
-          reduce_funcs  : !false_by_default,
-          reduce_vars   : !false_by_default,
-          sequences     : !false_by_default,
-          side_effects  : !false_by_default,
-          switches      : !false_by_default,
-          top_retain    : null,
-          toplevel      : !!(options && options["top_retain"]),
-          typeofs       : !false_by_default,
-          unsafe        : false,
-          unsafe_arrows : false,
-          unsafe_comps  : false,
-          unsafe_Function: false,
-          unsafe_math   : false,
-          unsafe_methods: false,
-          unsafe_proto  : false,
-          unsafe_regexp : false,
-          unsafe_undefined: false,
-          unused        : !false_by_default,
-          warnings      : false,
-      }, true);
-      var global_defs = this.options["global_defs"];
-      if (typeof global_defs == "object") for (var key in global_defs) {
-          if (key[0] === "@" && HOP(global_defs, key)) {
-              global_defs[key.slice(1)] = parse(global_defs[key], {
-                  expression: true
-              });
+  class Compressor extends TreeWalker {
+      constructor(options, false_by_default) {
+          super();
+          if (options.defaults !== undefined && !options.defaults) false_by_default = true;
+          this.options = defaults(options, {
+              arguments     : false,
+              arrows        : !false_by_default,
+              booleans      : !false_by_default,
+              booleans_as_integers : false,
+              collapse_vars : !false_by_default,
+              comparisons   : !false_by_default,
+              computed_props: !false_by_default,
+              conditionals  : !false_by_default,
+              dead_code     : !false_by_default,
+              defaults      : true,
+              directives    : !false_by_default,
+              drop_console  : false,
+              drop_debugger : !false_by_default,
+              ecma          : 5,
+              evaluate      : !false_by_default,
+              expression    : false,
+              global_defs   : false,
+              hoist_funs    : false,
+              hoist_props   : !false_by_default,
+              hoist_vars    : false,
+              ie8           : false,
+              if_return     : !false_by_default,
+              inline        : !false_by_default,
+              join_vars     : !false_by_default,
+              keep_classnames: false,
+              keep_fargs    : true,
+              keep_fnames   : false,
+              keep_infinity : false,
+              loops         : !false_by_default,
+              module        : false,
+              negate_iife   : !false_by_default,
+              passes        : 1,
+              properties    : !false_by_default,
+              pure_getters  : !false_by_default && "strict",
+              pure_funcs    : null,
+              reduce_funcs  : !false_by_default,
+              reduce_vars   : !false_by_default,
+              sequences     : !false_by_default,
+              side_effects  : !false_by_default,
+              switches      : !false_by_default,
+              top_retain    : null,
+              toplevel      : !!(options && options["top_retain"]),
+              typeofs       : !false_by_default,
+              unsafe        : false,
+              unsafe_arrows : false,
+              unsafe_comps  : false,
+              unsafe_Function: false,
+              unsafe_math   : false,
+              unsafe_methods: false,
+              unsafe_proto  : false,
+              unsafe_regexp : false,
+              unsafe_undefined: false,
+              unused        : !false_by_default,
+              warnings      : false,
+          }, true);
+          var global_defs = this.options["global_defs"];
+          if (typeof global_defs == "object") for (var key in global_defs) {
+              if (key[0] === "@" && HOP(global_defs, key)) {
+                  global_defs[key.slice(1)] = parse(global_defs[key], {
+                      expression: true
+                  });
+              }
           }
-      }
-      if (this.options["inline"] === true) this.options["inline"] = 3;
-      var pure_funcs = this.options["pure_funcs"];
-      if (typeof pure_funcs == "function") {
-          this.pure_funcs = pure_funcs;
-      } else {
-          this.pure_funcs = pure_funcs ? function(node) {
-              return !pure_funcs.includes(node.expression.print_to_string());
-          } : return_true;
-      }
-      var top_retain = this.options["top_retain"];
-      if (top_retain instanceof RegExp) {
-          this.top_retain = function(def) {
-              return top_retain.test(def.name);
-          };
-      } else if (typeof top_retain == "function") {
-          this.top_retain = top_retain;
-      } else if (top_retain) {
-          if (typeof top_retain == "string") {
-              top_retain = top_retain.split(/,/);
-          }
-          this.top_retain = function(def) {
-              return top_retain.includes(def.name);
+          if (this.options["inline"] === true) this.options["inline"] = 3;
+          var pure_funcs = this.options["pure_funcs"];
+          if (typeof pure_funcs == "function") {
+              this.pure_funcs = pure_funcs;
+          } else {
+              this.pure_funcs = pure_funcs ? function(node) {
+                  return !pure_funcs.includes(node.expression.print_to_string());
+              } : return_true;
+          }
+          var top_retain = this.options["top_retain"];
+          if (top_retain instanceof RegExp) {
+              this.top_retain = function(def) {
+                  return top_retain.test(def.name);
+              };
+          } else if (typeof top_retain == "function") {
+              this.top_retain = top_retain;
+          } else if (top_retain) {
+              if (typeof top_retain == "string") {
+                  top_retain = top_retain.split(/,/);
+              }
+              this.top_retain = function(def) {
+                  return top_retain.includes(def.name);
+              };
+          }
+          if (this.options["module"]) {
+              this.directives["use strict"] = true;
+              this.options["toplevel"] = true;
+          }
+          var toplevel = this.options["toplevel"];
+          this.toplevel = typeof toplevel == "string" ? {
+              funcs: /funcs/.test(toplevel),
+              vars: /vars/.test(toplevel)
+          } : {
+              funcs: toplevel,
+              vars: toplevel
           };
+          var sequences = this.options["sequences"];
+          this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
+          this.warnings_produced = {};
+      }
+
+      option(key) {
+          return this.options[key];
       }
-      if (this.options["module"]) {
-          this.directives["use strict"] = true;
-          this.options["toplevel"] = true;
-      }
-      var toplevel = this.options["toplevel"];
-      this.toplevel = typeof toplevel == "string" ? {
-          funcs: /funcs/.test(toplevel),
-          vars: /vars/.test(toplevel)
-      } : {
-          funcs: toplevel,
-          vars: toplevel
-      };
-      var sequences = this.options["sequences"];
-      this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
-      this.warnings_produced = {};
-  }
 
-  Compressor.prototype = new TreeTransformer;
-  merge(Compressor.prototype, {
-      option: function(key) { return this.options[key]; },
-      exposed: function(def) {
+      exposed(def) {
           if (def.export) return true;
           if (def.global) for (var i = 0, len = def.orig.length; i < len; i++)
               if (!this.toplevel[def.orig[i] instanceof AST_SymbolDefun ? "funcs" : "vars"])
                   return true;
           return false;
-      },
-      in_boolean_context: function() {
+      }
+
+      in_boolean_context() {
           if (!this.option("booleans")) return false;
           var self = this.self();
           for (var i = 0, p; p = this.parent(i); i++) {
@@ -7741,8 +7767,9 @@
                   return false;
               }
           }
-      },
-      compress: function(node) {
+      }
+
+      compress(node) {
           node = node.resolve_defines(this);
           if (this.option("expression")) {
               node.process_expression(true);
@@ -7780,13 +7807,15 @@
               node.process_expression(false);
           }
           return node;
-      },
-      info: function() {
+      }
+
+      info() {
           if (this.options.warnings == "verbose") {
               AST_Node.warn.apply(AST_Node, arguments);
           }
-      },
-      warn: function(text, props) {
+      }
+
+      warn(text, props) {
           if (this.options.warnings) {
               // only emit unique warnings
               var message = string_template(text, props);
@@ -7795,11 +7824,12 @@
                   AST_Node.warn.apply(AST_Node, arguments);
               }
           }
-      },
-      clear_warnings: function() {
+      }
+
+      clear_warnings() {
           this.warnings_produced = {};
-      },
-      before: function(node, descend, in_list) {
+      }
+      before(node, descend, in_list) {
           if (node._squeezed) return node;
           var was_scope = false;
           if (node instanceof AST_Scope) {
@@ -7827,7 +7857,7 @@
           if (opt === node) opt._squeezed = true;
           return opt;
       }
-  });
+  }
 
   (function() {
 
@@ -8035,7 +8065,7 @@
               if (!safe_to_read(tw, def)) return false;
               if (def.fixed === false) return false;
               if (def.fixed != null && (!value || def.references.length > def.assignments)) return false;
-              return all(def.orig, function(sym) {
+              return def.orig.every((sym) => {
                   return !(sym instanceof AST_SymbolConst
                       || sym instanceof AST_SymbolDefun
                       || sym instanceof AST_SymbolLambda);
@@ -8705,6 +8735,7 @@
                       || node instanceof AST_Try
                       || node instanceof AST_With
                       || node instanceof AST_Yield
+                      || node instanceof AST_Export
                       || parent instanceof AST_For && node !== parent.init
                       || !replace_all
                           && (node instanceof AST_SymbolRef && !node.is_declared(compressor))) {
@@ -8921,9 +8952,9 @@
                       && !fn.pinned()
                       && (iife = compressor.parent()) instanceof AST_Call
                       && iife.expression === fn
-                      && all(iife.args, function(arg) {
-                          return !(arg instanceof AST_Expansion);
-                      })) {
+                      && iife.args.every((arg) =>
+                          !(arg instanceof AST_Expansion)
+                      )) {
                       var fn_strict = compressor.has_directive("use strict");
                       if (fn_strict && !member(fn_strict, fn.body)) fn_strict = false;
                       var len = fn.argnames.length;
@@ -8940,9 +8971,9 @@
                           names.add(sym.name);
                           if (sym instanceof AST_Expansion) {
                               var elements = iife.args.slice(i);
-                              if (all(elements, function(arg) {
-                                  return !has_overlapping_symbol(fn, arg, fn_strict);
-                              })) {
+                              if (elements.every((arg) =>
+                                  !has_overlapping_symbol(fn, arg, fn_strict)
+                              )) {
                                   candidates.unshift([ make_node(AST_VarDef, sym, {
                                       name: sym.expression,
                                       value: make_node(AST_Array, iife, {
@@ -9198,7 +9229,7 @@
                   var def = sym.definition();
                   if (def.orig.length == 1 && def.orig[0] instanceof AST_SymbolDefun) return false;
                   if (def.scope.get_defun_scope() !== scope) return true;
-                  return !all(def.references, function(ref) {
+                  return !def.references.every((ref) => {
                       var s = ref.scope.get_defun_scope();
                       // "block" scope within AST_Catch
                       if (s.TYPE == "Scope") s = s.parent_scope;
@@ -9223,7 +9254,7 @@
               var seen_dirs = [];
               for (var i = 0; i < statements.length;) {
                   var stat = statements[i];
-                  if (stat instanceof AST_BlockStatement && all(stat.body, can_be_evicted_from_block)) {
+                  if (stat instanceof AST_BlockStatement && stat.body.every(can_be_evicted_from_block)) {
                       CHANGED = true;
                       eliminate_spurious_blocks(stat.body);
                       [].splice.apply(statements, [i, 1].concat(stat.body));
@@ -9325,7 +9356,7 @@
                           CHANGED = true;
                           stat = stat.clone();
                           stat.alternative = next;
-                          statements.splice(i, 1, stat.transform(compressor));
+                          statements[i] = stat.transform(compressor);
                           statements.splice(j, 1);
                           continue;
                       }
@@ -9339,7 +9370,7 @@
                           stat.alternative = next || make_node(AST_Return, stat, {
                               value: null
                           });
-                          statements.splice(i, 1, stat.transform(compressor));
+                          statements[i] = stat.transform(compressor);
                           if (next) statements.splice(j, 1);
                           continue;
                       }
@@ -9363,7 +9394,7 @@
                                   })
                               ]
                           });
-                          statements.splice(i, 1, stat.transform(compressor));
+                          statements[i] = stat.transform(compressor);
                           statements.splice(j, 1);
                           continue;
                       }
@@ -9474,9 +9505,9 @@
           }
 
           function declarations_only(node) {
-              return all(node.definitions, function(var_def) {
-                  return !var_def.value;
-              });
+              return node.definitions.every((var_def) =>
+                  !var_def.value
+              );
           }
 
           function sequencesize(statements, compressor) {
@@ -9627,7 +9658,7 @@
                   } : function(node) {
                       return node.key && node.key.name != prop;
                   };
-                  if (!all(def.value.properties, diff)) break;
+                  if (!def.value.properties.every(diff)) break;
                   var p = def.value.properties.filter(function (p) { return p.key === prop; })[0];
                   if (!p) {
                       def.value.properties.push(make_node(AST_ObjectKeyVal, node, {
@@ -10761,13 +10792,6 @@
 
       // determine if expression is constant
       (function(def_is_constant_expression) {
-          function all(list) {
-              for (var i = list.length; --i >= 0;)
-                  if (!list[i].is_constant_expression())
-                      return false;
-              return true;
-          }
-
           function all_refs_local(scope) {
               var self = this;
               var result = true;
@@ -10817,10 +10841,10 @@
               return this.left.is_constant_expression() && this.right.is_constant_expression();
           });
           def_is_constant_expression(AST_Array, function() {
-              return all(this.elements);
+              return this.elements.every((l) => l.is_constant_expression());
           });
           def_is_constant_expression(AST_Object, function() {
-              return all(this.properties);
+              return this.properties.every((l) => l.is_constant_expression());
           });
           def_is_constant_expression(AST_ObjectProperty, function() {
               return !(this.key instanceof AST_Node) && this.value.is_constant_expression();
@@ -11220,7 +11244,7 @@
                   }
                   if (node instanceof AST_BlockStatement) {
                       descend(node, this);
-                      if (in_list && all(node.body, can_be_evicted_from_block)) {
+                      if (in_list && node.body.every(can_be_evicted_from_block)) {
                           return MAP.splice(node.body);
                       }
                       return node;
@@ -11347,10 +11371,10 @@
               if (vars_found > 0) {
                   // collect only vars which don't show up in self's arguments list
                   var defs = [];
-                  vars.forEach(function(def, name) {
-                      if (self instanceof AST_Lambda
-                          && find_if(function(x) { return x.name == def.name.name; },
-                                     self.args_as_names())) {
+                  const is_lambda = self instanceof AST_Lambda;
+                  const args_as_names = is_lambda ? self.args_as_names() : null;
+                  vars.forEach((def, name) => {
+                      if (is_lambda && args_as_names.some((x) => x.name === def.name.name)) {
                           vars.delete(name);
                       } else {
                           def = def.clone();
@@ -12089,8 +12113,8 @@
 
       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)) {
+          if (self.bcatch && self.bfinally && self.bfinally.body.every(is_empty)) self.bfinally = null;
+          if (compressor.option("dead_code") && self.body.every(is_empty)) {
               var body = [];
               if (self.bcatch) {
                   extract_declarations_from_unreachable_code(compressor, self.bcatch, body);
@@ -12183,9 +12207,9 @@
           var exp = self.expression;
           var fn = exp;
           inline_array_like_spread(self, compressor, self.args);
-          var simple_args = all(self.args, function(arg) {
-              return !(arg instanceof AST_Expansion);
-          });
+          var simple_args = self.args.every((arg) =>
+              !(arg instanceof AST_Expansion)
+          );
           if (compressor.option("reduce_vars") && fn instanceof AST_SymbolRef) {
               fn = fn.fixed_value();
               if (retain_top_func(fn, compressor)) fn = exp;
@@ -12278,9 +12302,9 @@
                   break;
                 case "RegExp":
                   var params = [];
-                  if (all(self.args, function(arg) {
+                  if (self.args.every((arg) => {
                       var value = arg.evaluate(compressor);
-                      params.unshift(value);
+                      params.push(value);
                       return arg !== value;
                   })) {
                       try {
@@ -12426,9 +12450,9 @@
                   argnames: [],
                   body: []
               }).optimize(compressor);
-              if (all(self.args, function(x) {
-                  return x instanceof AST_String;
-              })) {
+              if (self.args.every((x) =>
+                  x instanceof AST_String
+              )) {
                   // quite a corner-case, but we can handle it:
                   //   https://github.com/mishoo/UglifyJS2/issues/203
                   // if the code argument is a constant, then we can minify it.
@@ -12529,7 +12553,7 @@
                   fn._squeezed = true;
                   return make_sequence(self, flatten_fn()).optimize(compressor);
               }
-              if (compressor.option("side_effects") && !(fn.body instanceof AST_Node) && all(fn.body, is_empty)) {
+              if (compressor.option("side_effects") && !(fn.body instanceof AST_Node) && fn.body.every(is_empty)) {
                   var args = self.args.concat(make_node(AST_Undefined, self));
                   return make_sequence(self, args).optimize(compressor);
               }
@@ -12570,14 +12594,14 @@
               for (var i = 0; i < len; i++) {
                   var line = body[i];
                   if (line instanceof AST_Var) {
-                      if (stat && !all(line.definitions, function(var_def) {
-                          return !var_def.value;
-                      })) {
+                      if (stat && !line.definitions.every((var_def) =>
+                          !var_def.value
+                      )) {
                           return false;
                       }
                   } else if (stat) {
                       return false;
-                  } else {
+                  } else if (!(line instanceof AST_EmptyStatement)) {
                       stat = line;
                   }
               }
@@ -12752,9 +12776,9 @@
                       var var_def = stat.definitions[j];
                       var name = var_def.name;
                       append_var(decls, expressions, name, var_def.value);
-                      if (in_loop && all(fn.argnames, function(argname) {
-                          return argname.name != name.name;
-                      })) {
+                      if (in_loop && fn.argnames.every((argname) =>
+                          argname.name != name.name
+                      )) {
                           var def = fn.variables.get(name.name);
                           var sym = make_node(AST_SymbolRef, name, name);
                           def.references.push(sym);
@@ -12912,7 +12936,7 @@
           }
           // avoids infinite recursion of numerals
           if (self.operator != "-"
-              || !(e instanceof AST_Number || e instanceof AST_Infinity)) {
+              || !(e instanceof AST_Number || e instanceof AST_Infinity || e instanceof AST_BigInt)) {
               var ev = self.evaluate(compressor);
               if (ev !== self) {
                   ev = make_node_from_constant(ev, self).optimize(compressor);
@@ -13504,9 +13528,9 @@
                   var init;
                   if (fixed instanceof AST_This) {
                       if (!(d.orig[0] instanceof AST_SymbolFunarg)
-                          && all(d.references, function(ref) {
-                              return d.scope === ref.scope;
-                          })) {
+                          && d.references.every((ref) =>
+                              d.scope === ref.scope
+                          )) {
                           init = fixed;
                       }
                   } else {
@@ -14117,7 +14141,7 @@
               for (var i = props.length; --i >= 0;) {
                   var prop = props[i];
                   if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
-                      if (!all(props, function(prop) {
+                      if (!props.every((prop) => {
                           return prop instanceof AST_ObjectKeyVal
                               || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;
                       })) break;
@@ -14545,21 +14569,12 @@
       }
 
       function add(source, gen_line, gen_col, orig_line, orig_col, name) {
-          var generatedPos = { line: gen_line + options.dest_line_diff, column: gen_col };
           if (orig_map) {
               var info = orig_map.originalPositionFor({
                   line: orig_line,
                   column: orig_col
               });
               if (info.source === null) {
-                  if (generatedPos.column !== 0) {
-                      generator.addMapping({
-                          generated: generatedPos,
-                          original: null,
-                          source: null,
-                          name: null
-                      });
-                  }
                   return;
               }
               source = info.source;
@@ -14568,7 +14583,7 @@
               name = info.name || name;
           }
           generator.addMapping({
-              generated : generatedPos,
+              generated : { line: gen_line + options.dest_line_diff, column: gen_col },
               original  : { line: orig_line + options.orig_line_diff, column: orig_col },
               source    : source,
               name      : name
@@ -20637,6 +20652,12 @@
               toplevel = toplevel.wrap_enclose(options.enclose);
           }
           if (timings) timings.rename = Date.now();
+          // disable rename on harmony due to expand_names bug in for-of loops
+          // https://github.com/mishoo/UglifyJS2/issues/2794
+          if (0 && options.rename) {
+              toplevel.figure_out_scope(options.mangle);
+              toplevel.expand_names(options.mangle);
+          }
           if (timings) timings.compress = Date.now();
           if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
           if (timings) timings.scope = Date.now();
@@ -21181,6 +21202,13 @@
                               end   : my_end_token(M),
                               name  : M.name
                           });
+          },
+          BigIntLiteral(M) {
+              return new AST_BigInt({
+                  start : my_start_token(M),
+                  end   : my_end_token(M),
+                  value : M.value
+              });
           }
       };
 
@@ -21650,6 +21678,11 @@
           };
       });
 
+      def_to_moz(AST_BigInt, M => ({
+          type: "BigIntLiteral",
+          value: M.value
+      }));
+
       AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
       AST_Null.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
       AST_Hole.DEFMETHOD("to_mozilla_ast", function To_Moz_ArrayHole() { return null; });
@@ -21831,9 +21864,6 @@
       }
   })();
 
-  // API
-
-  exports.minify = minify;
   exports.AST_Accessor = AST_Accessor;
   exports.AST_Array = AST_Array;
   exports.AST_Arrow = AST_Arrow;
@@ -21855,17 +21885,17 @@
   exports.AST_Const = AST_Const;
   exports.AST_Constant = AST_Constant;
   exports.AST_Continue = AST_Continue;
+  exports.AST_DWLoop = AST_DWLoop;
   exports.AST_Debugger = AST_Debugger;
+  exports.AST_DefClass = AST_DefClass;
   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;
@@ -21883,13 +21913,13 @@
   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_LabeledStatement = AST_LabeledStatement;
   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_NameMapping = AST_NameMapping;
   exports.AST_New = AST_New;
   exports.AST_NewTarget = AST_NewTarget;
   exports.AST_Node = AST_Node;
@@ -21949,19 +21979,20 @@
   exports.AST_While = AST_While;
   exports.AST_With = AST_With;
   exports.AST_Yield = AST_Yield;
+  exports.Compressor = Compressor;
+  exports.OutputStream = OutputStream;
   exports.TreeTransformer = TreeTransformer;
   exports.TreeWalker = TreeWalker;
+  exports.base54 = base54;
+  exports.default_options = default_options;
   exports.defaults = defaults;
+  exports.mangle_properties = mangle_properties;
+  exports.minify = minify;
+  exports.parse = parse;
   exports.push_uniq = push_uniq;
+  exports.reserve_quoted_keys = reserve_quoted_keys;
   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.default_options = default_options;
 
 }));
 //# sourceMappingURL=bundle.js.map