terser 5.6.0-beta → 5.7.1

package/lib/parse.js

@@ -102,7 +102,6 @@ import {
     AST_Label,
     AST_LabeledStatement,
     AST_LabelRef,
-    AST_Lambda,
     AST_Let,
     AST_NameMapping,
     AST_New,
@@ -1293,7 +1292,7 @@ function parse($TEXT, options) {
                 if (is_if_body) {
                     croak("classes are not allowed as the body of an if");
                 }
-                return class_(AST_DefClass);
+                return class_(AST_DefClass, is_export_default);
 
               case "function":
                 next();
@@ -2488,7 +2487,7 @@ function parse($TEXT, options) {
         return new AST_Object({ properties: a });
     });
 
-    function class_(KindOfClass) {
+    function class_(KindOfClass, is_export_default) {
         var start, method, class_name, extends_, a = [];
 
         S.input.push_directives_stack(); // Push directive stack, but not scope stack
@@ -2499,7 +2498,11 @@ function parse($TEXT, options) {
         }
 
         if (KindOfClass === AST_DefClass && !class_name) {
-            unexpected();
+            if (is_export_default) {
+                KindOfClass = AST_ClassExpression;
+            } else {
+                unexpected();
+            }
         }
 
         if (S.token.value == "extends") {
@@ -2532,9 +2535,9 @@ function parse($TEXT, options) {
     }
 
     function concise_method_or_getset(name, start, is_class) {
-        var get_method_name_ast = function(name, start) {
+        const get_symbol_ast = (name, SymbolClass = AST_SymbolMethod) => {
             if (typeof name === "string" || typeof name === "number") {
-                return new AST_SymbolMethod({
+                return new SymbolClass({
                     start,
                     name: "" + name,
                     end: prev()
@@ -2544,47 +2547,71 @@ function parse($TEXT, options) {
             }
             return name;
         };
-        const get_class_property_key_ast = (name) => {
-            if (typeof name === "string" || typeof name === "number") {
-                return new AST_SymbolClassProperty({
-                    start: property_token,
-                    end: property_token,
-                    name: "" + name
-                });
-            } else if (name === null) {
-                unexpected();
-            }
-            return name;
-        };
-        var privatename = start.type == "privatename";
+
+        const is_not_method_start = () =>
+            !is("punc", "(") && !is("punc", ",") && !is("punc", "}") && !is("operator", "=");
+
         var is_async = false;
         var is_static = false;
         var is_generator = false;
-        var property_token = start;
-        if (is_class && name === "static" && !is("punc", "(")) {
+        var is_private = false;
+        var accessor_type = null;
+
+        if (is_class && name === "static" && is_not_method_start()) {
             is_static = true;
-            property_token = S.token;
-            privatename = property_token.type == "privatename";
             name = as_property_name();
         }
-        if (name === "async" && !is("punc", "(") && !is("punc", ",") && !is("punc", "}") && !is("operator", "=")) {
+        if (name === "async" && is_not_method_start()) {
             is_async = true;
-            property_token = S.token;
-            privatename = property_token.type == "privatename";
             name = as_property_name();
         }
-        if (name === null) {
+        if (prev().type === "operator" && prev().value === "*") {
             is_generator = true;
-            property_token = S.token;
-            privatename = property_token.type == "privatename";
             name = as_property_name();
-            if (name === null) {
-                unexpected();
+        }
+        if ((name === "get" || name === "set") && is_not_method_start()) {
+            accessor_type = name;
+            name = as_property_name();
+        }
+        if (prev().type === "privatename") {
+            is_private = true;
+        }
+
+        const property_token = prev();
+
+        if (accessor_type != null) {
+            if (!is_private) {
+                const AccessorClass = accessor_type === "get"
+                    ? AST_ObjectGetter
+                    : AST_ObjectSetter;
+
+                name = get_symbol_ast(name);
+                return new AccessorClass({
+                    start,
+                    static: is_static,
+                    key: name,
+                    quote: name instanceof AST_SymbolMethod ? property_token.quote : undefined,
+                    value: create_accessor(),
+                    end: prev()
+                });
+            } else {
+                const AccessorClass = accessor_type === "get"
+                    ? AST_PrivateGetter
+                    : AST_PrivateSetter;
+
+                return new AccessorClass({
+                    start,
+                    static: is_static,
+                    key: get_symbol_ast(name),
+                    value: create_accessor(),
+                    end: prev(),
+                });
             }
         }
+
         if (is("punc", "(")) {
-            name = get_method_name_ast(name, start);
-            const AST_MethodVariant = privatename
+            name = get_symbol_ast(name);
+            const AST_MethodVariant = is_private
                 ? AST_PrivateMethod
                 : AST_ConciseMethod;
             var node = new AST_MethodVariant({
@@ -2600,57 +2627,13 @@ function parse($TEXT, options) {
             });
             return node;
         }
-        const setter_token = S.token;
-        if ((name === "get" || name === "set") && setter_token.type === "privatename") {
-            next();
-
-            const AST_AccessorVariant =
-                name === "get"
-                    ? AST_PrivateGetter
-                    : AST_PrivateSetter;
-
-            return new AST_AccessorVariant({
-                start,
-                static: is_static,
-                key: get_method_name_ast(setter_token.value, start),
-                value: create_accessor(),
-                end: prev(),
-            });
-        }
 
-        if (name == "get") {
-            if (!is("punc") || is("punc", "[")) {
-                name = get_method_name_ast(as_property_name(), start);
-                return new AST_ObjectGetter({
-                    start : start,
-                    static: is_static,
-                    key   : name,
-                    quote : name instanceof AST_SymbolMethod ?
-                            setter_token.quote : undefined,
-                    value : create_accessor(),
-                    end   : prev()
-                });
-            }
-        } else if (name == "set") {
-            if (!is("punc") || is("punc", "[")) {
-                name = get_method_name_ast(as_property_name(), start);
-                return new AST_ObjectSetter({
-                    start : start,
-                    static: is_static,
-                    key   : name,
-                    quote : name instanceof AST_SymbolMethod ?
-                            setter_token.quote : undefined,
-                    value : create_accessor(),
-                    end   : prev()
-                });
-            }
-        }
         if (is_class) {
-            const key = get_class_property_key_ast(name, property_token);
+            const key = get_symbol_ast(name, AST_SymbolClassProperty);
             const quote = key instanceof AST_SymbolClassProperty
                 ? property_token.quote
                 : undefined;
-            const AST_ClassPropertyVariant = privatename
+            const AST_ClassPropertyVariant = is_private
                 ? AST_ClassPrivateProperty
                 : AST_ClassProperty;
             if (is("operator", "=")) {
@@ -2872,8 +2855,17 @@ function parse($TEXT, options) {
             semicolon();
         } else if ((node = statement(is_default)) instanceof AST_Definitions && is_default) {
             unexpected(node.start);
-        } else if (node instanceof AST_Definitions || node instanceof AST_Lambda || node instanceof AST_DefClass) {
+        } else if (
+            node instanceof AST_Definitions
+            || node instanceof AST_Defun
+            || node instanceof AST_DefClass
+        ) {
             exported_definition = node;
+        } else if (
+            node instanceof AST_ClassExpression
+            || node instanceof AST_Function
+        ) {
+            exported_value = node;
         } else if (node instanceof AST_SimpleStatement) {
             exported_value = node.body;
         } else {

package/lib/scope.js

@@ -299,7 +299,14 @@ AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = null,
             // scope when we encounter the AST_Defun node (which is
             // instanceof AST_Scope) but we get to the symbol a bit
             // later.
-            mark_export((node.scope = defun.parent_scope.get_defun_scope()).def_function(node, defun), 1);
+            const closest_scope = defun.parent_scope;
+
+            // In strict mode, function definitions are block-scoped
+            node.scope = tw.directives["use strict"]
+                ? closest_scope
+                : closest_scope.get_defun_scope();
+
+            mark_export(node.scope.def_function(node, defun), 1);
         } else if (node instanceof AST_SymbolClass) {
             mark_export(defun.def_variable(node, defun), 1);
         } else if (node instanceof AST_SymbolImport) {
@@ -478,7 +485,6 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
 
 AST_Scope.DEFMETHOD("init_scope_vars", function(parent_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
@@ -641,7 +647,6 @@ AST_Scope.DEFMETHOD("find_variable", function(name) {
 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;
 });
 

package/lib/size.js

@@ -92,6 +92,12 @@ AST_Node.prototype.size = function (compressor, stack) {
     let size = 0;
     walk_parent(this, (node, info) => {
         size += node._size(info);
+
+        // Braceless arrow functions have fake "return" statements
+        if (node instanceof AST_Arrow && node.is_braceless()) {
+            size += node.body[0].value._size(info);
+            return true;
+        }
     }, stack || (compressor && compressor.stack));
 
     // just to save a bit of memory
@@ -136,7 +142,6 @@ AST_With.prototype._size = () => 6;
 
 AST_Expansion.prototype._size = () => 3;
 
-/*#__INLINE__*/
 const lambda_modifiers = func =>
     (func.is_generator ? 1 : 0) + (func.async ? 6 : 0);
 
@@ -165,7 +170,9 @@ AST_Arrow.prototype._size = function () {
         args_and_arrow += 2;
     }
 
-    return lambda_modifiers(this) + args_and_arrow + (Array.isArray(this.body) ? list_overhead(this.body) : this.body._size());
+    const body_overhead = this.is_braceless() ? 0 : list_overhead(this.body) + 2;
+
+    return lambda_modifiers(this) + args_and_arrow + body_overhead;
 };
 
 AST_Destructuring.prototype._size = () => 2;

package/lib/utils/index.js

@@ -64,10 +64,8 @@ class DefaultsError extends Error {
 function defaults(args, defs, croak) {
     if (args === true) {
         args = {};
-    }
-
-    if (args != null && typeof args === "object") {
-        args = Object.assign({}, args);
+    } else if (args != null && typeof args === "object") {
+        args = {...args};
     }
 
     const ret = args || {};
@@ -196,7 +194,7 @@ function mergeSort(array, cmp) {
 function makePredicate(words) {
     if (!Array.isArray(words)) words = words.split(" ");
 
-    return new Set(words);
+    return new Set(words.sort());
 }
 
 function map_add(map, key, value) {
@@ -235,6 +233,7 @@ function keep_name(keep_setting, name) {
 }
 
 var lineTerminatorEscape = {
+    "\0": "0",
     "\n": "n",
     "\r": "r",
     "\u2028": "u2028",
@@ -242,7 +241,8 @@ var lineTerminatorEscape = {
 };
 function regexp_source_fix(source) {
     // V8 does not escape line terminators in regexp patterns in node 12
-    return source.replace(/[\n\r\u2028\u2029]/g, function (match, offset) {
+    // We'll also remove literal \0
+    return source.replace(/[\0\n\r\u2028\u2029]/g, function (match, offset) {
         var escaped = source[offset - 1] == "\\"
             && (source[offset - 2] != "\\"
             || /(?:^|[^\\])(?:\\{2})*$/.test(source.slice(0, offset - 1)));

package/package.json

@@ -4,7 +4,7 @@
   "homepage": "https://terser.org",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "5.6.0-beta",
+  "version": "5.7.1",
   "engines": {
     "node": ">=10"
   },
@@ -24,7 +24,8 @@
       "./dist/bundle.min.js"
     ],
     "./package": "./package.json",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./bin/terser": "./bin/terser"
   },
   "types": "tools/terser.d.ts",
   "bin": {
@@ -124,7 +125,7 @@
       "no-unused-vars": [
         "error",
         {
-          "varsIgnorePattern": "^_$"
+          "varsIgnorePattern": "^_"
         }
       ],
       "no-tabs": "error",

package/tools/domprops.js

@@ -4120,6 +4120,7 @@ export var domprops = [
     "exponent",
     "exponentialRampToValueAtTime",
     "exportKey",
+    "exports",
     "extend",
     "extensions",
     "extentNode",