terser 3.7.6 → 3.8.1

package/lib/propmangle.js

@@ -74,7 +74,7 @@ function find_builtins(reserved) {
       objects.Reflect, objects.Set, SyntaxError, TypeError, Uint8Array,
       Uint8ClampedArray, Uint16Array, Uint32Array, URIError,
       objects.WeakMap, objects.WeakSet
-    ].forEach(function(ctor){
+    ].forEach(function(ctor) {
         Object.getOwnPropertyNames(ctor).map(add);
         if (ctor.prototype) {
             Object.getOwnPropertyNames(ctor.prototype).map(add);
@@ -156,7 +156,7 @@ function mangle_properties(ast, options) {
     var unmangleable = [];
 
     // step 1: find candidates to mangle
-    ast.walk(new TreeWalker(function(node){
+    ast.walk(new TreeWalker(function(node) {
         if (node instanceof AST_ObjectKeyVal) {
             add(node.key);
         }
@@ -177,7 +177,7 @@ function mangle_properties(ast, options) {
     }));
 
     // step 2: transform the tree, renaming properties
-    return ast.transform(new TreeTransformer(function(node){
+    return ast.transform(new TreeTransformer(function(node) {
         if (node instanceof AST_ObjectKeyVal) {
             node.key = mangle(node.key);
         }
@@ -254,7 +254,7 @@ function mangle_properties(ast, options) {
     }
 
     function mangleStrings(node) {
-        return node.transform(new TreeTransformer(function(node){
+        return node.transform(new TreeTransformer(function(node) {
             if (node instanceof AST_Sequence) {
                 var last = node.expressions.length - 1;
                 node.expressions[last] = mangleStrings(node.expressions[last]);

package/lib/scope.js

@@ -56,7 +56,7 @@ function SymbolDef(scope, orig, init) {
     this.mangled_name = null;
     this.undeclared = false;
     this.id = SymbolDef.next_id++;
-};
+}
 
 SymbolDef.next_id = 1;
 
@@ -101,7 +101,7 @@ SymbolDef.prototype = {
     }
 };
 
-AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
+AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     options = defaults(options, {
         cache: null,
         ie8: false,
@@ -115,7 +115,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     var defun = null;
     var in_destructuring = null;
     var for_scopes = [];
-    var tw = new TreeWalker(function(node, descend){
+    var tw = new TreeWalker(function(node, descend) {
         if (node.is_block_scope()) {
             var save_scope = scope;
             node.block_scope = scope = new AST_Scope(node);
@@ -269,7 +269,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
 
     // pass 2: find back references and eval
     self.globals = new Dictionary();
-    var tw = new TreeWalker(function(node, descend){
+    var tw = new TreeWalker(function(node, descend) {
         if (node instanceof AST_LoopControl && node.label) {
             node.label.thedef.references.push(node);
             return true;
@@ -342,7 +342,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     }
 });
 
-AST_Toplevel.DEFMETHOD("def_global", function(node){
+AST_Toplevel.DEFMETHOD("def_global", function(node) {
     var globals = this.globals, name = node.name;
     if (globals.has(name)) {
         return globals.get(name);
@@ -355,7 +355,7 @@ AST_Toplevel.DEFMETHOD("def_global", function(node){
     }
 });
 
-AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
+AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope) {
     this.variables = new Dictionary();  // map name to AST_SymbolVar (variables defined in this scope; includes functions)
     this.functions = new Dictionary();  // map name to AST_SymbolDefun (functions defined in this scope)
     this.uses_with = false;             // will be set to true if this or some nested scope uses the `with` statement
@@ -373,7 +373,7 @@ AST_SwitchBranch.DEFMETHOD("is_block_scope", return_false);
 AST_Block.DEFMETHOD("is_block_scope", return_true);
 AST_IterationStatement.DEFMETHOD("is_block_scope", return_true);
 
-AST_Lambda.DEFMETHOD("init_scope_vars", function(){
+AST_Lambda.DEFMETHOD("init_scope_vars", function() {
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
     this.def_variable(new AST_SymbolFunarg({
@@ -383,7 +383,7 @@ AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     }));
 });
 
-AST_Arrow.DEFMETHOD("init_scope_vars", function(){
+AST_Arrow.DEFMETHOD("init_scope_vars", function() {
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
 });
@@ -408,20 +408,20 @@ AST_Symbol.DEFMETHOD("reference", function(options) {
     this.mark_enclosed(options);
 });
 
-AST_Scope.DEFMETHOD("find_variable", function(name){
+AST_Scope.DEFMETHOD("find_variable", function(name) {
     if (name instanceof AST_Symbol) name = name.name;
     return this.variables.get(name)
         || (this.parent_scope && this.parent_scope.find_variable(name));
 });
 
-AST_Scope.DEFMETHOD("def_function", function(symbol, init){
+AST_Scope.DEFMETHOD("def_function", function(symbol, init) {
     var def = this.def_variable(symbol, init);
     if (!def.init || def.init instanceof AST_Defun) def.init = init;
     this.functions.set(symbol.name, def);
     return def;
 });
 
-AST_Scope.DEFMETHOD("def_variable", function(symbol, init){
+AST_Scope.DEFMETHOD("def_variable", function(symbol, init) {
     var def = this.variables.get(symbol.name);
     if (def) {
         def.orig.push(symbol);
@@ -458,11 +458,11 @@ function next_mangled(scope, options) {
     }
 }
 
-AST_Scope.DEFMETHOD("next_mangled", function(options){
+AST_Scope.DEFMETHOD("next_mangled", function(options) {
     return next_mangled(this, options);
 });
 
-AST_Toplevel.DEFMETHOD("next_mangled", function(options){
+AST_Toplevel.DEFMETHOD("next_mangled", function(options) {
     var name;
     do {
         name = next_mangled(this, options);
@@ -470,7 +470,7 @@ AST_Toplevel.DEFMETHOD("next_mangled", function(options){
     return name;
 });
 
-AST_Function.DEFMETHOD("next_mangled", function(options, def){
+AST_Function.DEFMETHOD("next_mangled", function(options, def) {
     // #179, #326
     // in Safari strict mode, something like (function x(x){...}) is a syntax error;
     // a function expression's argument cannot shadow the function expression's name
@@ -526,7 +526,7 @@ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
     return options;
 });
 
-AST_Toplevel.DEFMETHOD("mangle_names", function(options){
+AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     options = this._default_mangler_options(options);
 
     // We only need to mangle declaration nodes.  Special logic wired
@@ -546,7 +546,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
         }
     }
 
-    var tw = new TreeWalker(function(node, descend){
+    var tw = new TreeWalker(function(node, descend) {
         if (node instanceof AST_LabeledStatement) {
             // lname is incremented when we get to the AST_Label
             var save_nesting = lname;
@@ -574,7 +574,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
         }
     });
     this.walk(tw);
-    to_mangle.forEach(function(def){ def.mangle(options) });
+    to_mangle.forEach(function(def) { def.mangle(options); });
 
     function collect(symbol) {
         if (!member(symbol.name, options.reserved)) {
@@ -646,7 +646,7 @@ AST_Sequence.DEFMETHOD("tail_node", function() {
     return this.expressions[this.expressions.length - 1];
 });
 
-AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
+AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) {
     options = this._default_mangler_options(options);
     try {
         AST_Node.prototype.print = function(stream, force_parens) {
@@ -715,6 +715,6 @@ var base54 = (function() {
             base = 64;
         } while (num > 0);
         return ret;
-    };
+    }
     return base54;
 })();

package/lib/sourcemap.js

@@ -88,10 +88,10 @@ function SourceMap(options) {
             source    : source,
             name      : name
         });
-    };
+    }
     return {
         add        : add,
-        get        : function() { return generator },
+        get        : function() { return generator; },
         toString   : function() { return JSON.stringify(generator.toJSON()); }
     };
-};
+}

package/lib/transform.js

@@ -52,10 +52,10 @@ function TreeTransformer(before, after) {
 }
 TreeTransformer.prototype = new TreeWalker;
 
-(function(undefined){
+(function(undefined) {
 
     function _(node, descend) {
-        node.DEFMETHOD("transform", function(tw, in_list){
+        node.DEFMETHOD("transform", function(tw, in_list) {
             var x, y;
             tw.push(this);
             if (tw.before) x = tw.before(this, descend, in_list);
@@ -70,97 +70,97 @@ TreeTransformer.prototype = new TreeWalker;
             tw.pop();
             return x;
         });
-    };
+    }
 
     function do_list(list, tw) {
-        return MAP(list, function(node){
+        return MAP(list, function(node) {
             return node.transform(tw, true);
         });
-    };
+    }
 
     _(AST_Node, noop);
 
-    _(AST_LabeledStatement, function(self, tw){
+    _(AST_LabeledStatement, function(self, tw) {
         self.label = self.label.transform(tw);
         self.body = self.body.transform(tw);
     });
 
-    _(AST_SimpleStatement, function(self, tw){
+    _(AST_SimpleStatement, function(self, tw) {
         self.body = self.body.transform(tw);
     });
 
-    _(AST_Block, function(self, tw){
+    _(AST_Block, function(self, tw) {
         self.body = do_list(self.body, tw);
     });
 
-    _(AST_Do, function(self, tw){
+    _(AST_Do, function(self, tw) {
         self.body = self.body.transform(tw);
         self.condition = self.condition.transform(tw);
     });
 
-    _(AST_While, function(self, tw){
+    _(AST_While, function(self, tw) {
         self.condition = self.condition.transform(tw);
         self.body = self.body.transform(tw);
     });
 
-    _(AST_For, function(self, tw){
+    _(AST_For, function(self, tw) {
         if (self.init) self.init = self.init.transform(tw);
         if (self.condition) self.condition = self.condition.transform(tw);
         if (self.step) self.step = self.step.transform(tw);
         self.body = self.body.transform(tw);
     });
 
-    _(AST_ForIn, function(self, tw){
+    _(AST_ForIn, function(self, tw) {
         self.init = self.init.transform(tw);
         self.object = self.object.transform(tw);
         self.body = self.body.transform(tw);
     });
 
-    _(AST_With, function(self, tw){
+    _(AST_With, function(self, tw) {
         self.expression = self.expression.transform(tw);
         self.body = self.body.transform(tw);
     });
 
-    _(AST_Exit, function(self, tw){
+    _(AST_Exit, function(self, tw) {
         if (self.value) self.value = self.value.transform(tw);
     });
 
-    _(AST_LoopControl, function(self, tw){
+    _(AST_LoopControl, function(self, tw) {
         if (self.label) self.label = self.label.transform(tw);
     });
 
-    _(AST_If, function(self, tw){
+    _(AST_If, function(self, tw) {
         self.condition = self.condition.transform(tw);
         self.body = self.body.transform(tw);
         if (self.alternative) self.alternative = self.alternative.transform(tw);
     });
 
-    _(AST_Switch, function(self, tw){
+    _(AST_Switch, function(self, tw) {
         self.expression = self.expression.transform(tw);
         self.body = do_list(self.body, tw);
     });
 
-    _(AST_Case, function(self, tw){
+    _(AST_Case, function(self, tw) {
         self.expression = self.expression.transform(tw);
         self.body = do_list(self.body, tw);
     });
 
-    _(AST_Try, function(self, tw){
+    _(AST_Try, function(self, tw) {
         self.body = do_list(self.body, tw);
         if (self.bcatch) self.bcatch = self.bcatch.transform(tw);
         if (self.bfinally) self.bfinally = self.bfinally.transform(tw);
     });
 
-    _(AST_Catch, function(self, tw){
+    _(AST_Catch, function(self, tw) {
         self.argname = self.argname.transform(tw);
         self.body = do_list(self.body, tw);
     });
 
-    _(AST_Definitions, function(self, tw){
+    _(AST_Definitions, function(self, tw) {
         self.definitions = do_list(self.definitions, tw);
     });
 
-    _(AST_VarDef, function(self, tw){
+    _(AST_VarDef, function(self, tw) {
         self.name = self.name.transform(tw);
         if (self.value) self.value = self.value.transform(tw);
     });
@@ -169,7 +169,7 @@ TreeTransformer.prototype = new TreeWalker;
         self.names = do_list(self.names, tw);
     });
 
-    _(AST_Lambda, function(self, tw){
+    _(AST_Lambda, function(self, tw) {
         if (self.name) self.name = self.name.transform(tw);
         self.argnames = do_list(self.argnames, tw);
         if (self.body instanceof AST_Node) {
@@ -179,69 +179,69 @@ TreeTransformer.prototype = new TreeWalker;
         }
     });
 
-    _(AST_Call, function(self, tw){
+    _(AST_Call, function(self, tw) {
         self.expression = self.expression.transform(tw);
         self.args = do_list(self.args, tw);
     });
 
-    _(AST_Sequence, function(self, tw){
+    _(AST_Sequence, function(self, tw) {
         self.expressions = do_list(self.expressions, tw);
     });
 
-    _(AST_Dot, function(self, tw){
+    _(AST_Dot, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
 
-    _(AST_Sub, function(self, tw){
+    _(AST_Sub, function(self, tw) {
         self.expression = self.expression.transform(tw);
         self.property = self.property.transform(tw);
     });
 
-    _(AST_Yield, function(self, tw){
+    _(AST_Yield, function(self, tw) {
         if (self.expression) self.expression = self.expression.transform(tw);
     });
 
-    _(AST_Await, function(self, tw){
+    _(AST_Await, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
 
-    _(AST_Unary, function(self, tw){
+    _(AST_Unary, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
 
-    _(AST_Binary, function(self, tw){
+    _(AST_Binary, function(self, tw) {
         self.left = self.left.transform(tw);
         self.right = self.right.transform(tw);
     });
 
-    _(AST_Conditional, function(self, tw){
+    _(AST_Conditional, function(self, tw) {
         self.condition = self.condition.transform(tw);
         self.consequent = self.consequent.transform(tw);
         self.alternative = self.alternative.transform(tw);
     });
 
-    _(AST_Array, function(self, tw){
+    _(AST_Array, function(self, tw) {
         self.elements = do_list(self.elements, tw);
     });
 
-    _(AST_Object, function(self, tw){
+    _(AST_Object, function(self, tw) {
         self.properties = do_list(self.properties, tw);
     });
 
-    _(AST_ObjectProperty, function(self, tw){
+    _(AST_ObjectProperty, function(self, tw) {
         if (self.key instanceof AST_Node) {
             self.key = self.key.transform(tw);
         }
         self.value = self.value.transform(tw);
     });
 
-    _(AST_Class, function(self, tw){
+    _(AST_Class, function(self, tw) {
         if (self.name) self.name = self.name.transform(tw);
         if (self.extends) self.extends = self.extends.transform(tw);
         self.properties = do_list(self.properties, tw);
     });
 
-    _(AST_Expansion, function(self, tw){
+    _(AST_Expansion, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
 

package/lib/utils.js

@@ -45,18 +45,18 @@
 
 function characters(str) {
     return str.split("");
-};
+}
 
 function member(name, array) {
     return array.indexOf(name) >= 0;
-};
+}
 
 function find_if(func, array) {
     for (var i = 0, n = array.length; i < n; ++i) {
         if (func(array[i]))
             return array[i];
     }
-};
+}
 
 function repeat_string(str, i) {
     if (i <= 0) return "";
@@ -65,7 +65,7 @@ function repeat_string(str, i) {
     d += d;
     if (i & 1) d += str;
     return d;
-};
+}
 
 function configure_error_stack(fn) {
     Object.defineProperty(fn.prototype, "stack", {
@@ -84,7 +84,7 @@ function configure_error_stack(fn) {
 function DefaultsError(msg, defs) {
     this.message = msg;
     this.defs = defs;
-};
+}
 DefaultsError.prototype = Object.create(Error.prototype);
 DefaultsError.prototype.constructor = DefaultsError;
 DefaultsError.prototype.name = "DefaultsError";
@@ -104,7 +104,7 @@ function defaults(args, defs, croak) {
         ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
     }
     return ret;
-};
+}
 
 function merge(obj, ext) {
     var count = 0;
@@ -113,7 +113,7 @@ function merge(obj, ext) {
         count++;
     }
     return count;
-};
+}
 
 function noop() {}
 function return_false() { return false; }
@@ -121,7 +121,7 @@ function return_true() { return true; }
 function return_this() { return this; }
 function return_null() { return null; }
 
-var MAP = (function(){
+var MAP = (function() {
     function MAP(a, f, backwards) {
         var ret = [], top = [], i;
         function doit() {
@@ -144,7 +144,7 @@ var MAP = (function(){
                 }
             }
             return is_last;
-        };
+        }
         if (a instanceof Array) {
             if (backwards) {
                 for (i = a.length; --i >= 0;) if (doit()) break;
@@ -158,33 +158,33 @@ var MAP = (function(){
             for (i in a) if (HOP(a, i)) if (doit()) break;
         }
         return top.concat(ret);
-    };
-    MAP.at_top = function(val) { return new AtTop(val) };
-    MAP.splice = function(val) { return new Splice(val) };
-    MAP.last = function(val) { return new Last(val) };
+    }
+    MAP.at_top = function(val) { return new AtTop(val); };
+    MAP.splice = function(val) { return new Splice(val); };
+    MAP.last = function(val) { return new Last(val); };
     var skip = MAP.skip = {};
-    function AtTop(val) { this.v = val };
-    function Splice(val) { this.v = val };
-    function Last(val) { this.v = val };
+    function AtTop(val) { this.v = val; }
+    function Splice(val) { this.v = val; }
+    function Last(val) { this.v = val; }
     return MAP;
 })();
 
 function push_uniq(array, el) {
     if (array.indexOf(el) < 0)
         array.push(el);
-};
+}
 
 function string_template(text, props) {
-    return text.replace(/\{(.+?)\}/g, function(str, p){
+    return text.replace(/\{(.+?)\}/g, function(str, p) {
         return props && props[p];
     });
-};
+}
 
 function remove(array, el) {
     for (var i = array.length; --i >= 0;) {
         if (array[i] === el) array.splice(i, 1);
     }
-};
+}
 
 function mergeSort(array, cmp) {
     if (array.length < 2) return array.slice();
@@ -198,7 +198,7 @@ function mergeSort(array, cmp) {
         if (ai < a.length) r.push.apply(r, a.slice(ai));
         if (bi < b.length) r.push.apply(r, b.slice(bi));
         return r;
-    };
+    }
     function _ms(a) {
         if (a.length <= 1)
             return a;
@@ -206,9 +206,9 @@ function mergeSort(array, cmp) {
         left = _ms(left);
         right = _ms(right);
         return merge(left, right);
-    };
+    }
     return _ms(array);
-};
+}
 
 // this function is taken from Acorn [1], written by Marijn Haverbeke
 // [1] https://github.com/marijnh/acorn
@@ -254,19 +254,19 @@ function makePredicate(words) {
         compareTo(words);
     }
     return new Function("str", f);
-};
+}
 
 function all(array, predicate) {
     for (var i = array.length; --i >= 0;)
         if (!predicate(array[i]))
             return false;
     return true;
-};
+}
 
 function Dictionary() {
     this._values = Object.create(null);
     this._size = 0;
-};
+}
 Dictionary.prototype = {
     set: function(key, val) {
         if (!this.has(key)) ++this._size;
@@ -281,7 +281,7 @@ Dictionary.prototype = {
         }
         return this;
     },
-    get: function(key) { return this._values["$" + key] },
+    get: function(key) { return this._values["$" + key]; },
     del: function(key) {
         if (this.has(key)) {
             --this._size;
@@ -289,7 +289,7 @@ Dictionary.prototype = {
         }
         return this;
     },
-    has: function(key) { return ("$" + key) in this._values },
+    has: function(key) { return ("$" + key) in this._values; },
     each: function(f) {
         for (var i in this._values)
             f(this._values[i], i.substr(1));
@@ -310,7 +310,7 @@ Dictionary.prototype = {
         ret._size = this._size;
         return ret;
     },
-    toObject: function() { return this._values }
+    toObject: function() { return this._values; }
 };
 Dictionary.fromObject = function(obj) {
     var dict = new Dictionary();