terser 5.41.0 → 5.43.0

package/lib/ast.js

@@ -2150,12 +2150,10 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", function AST_Obje
     }
 }, AST_ObjectProperty);
 
-var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator async", function AST_ConciseMethod(props) {
+var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static", function AST_ConciseMethod(props) {
     if (props) {
         this.quote = props.quote;
         this.static = props.static;
-        this.is_generator = props.is_generator;
-        this.async = props.async;
         this.key = props.key;
         this.value = props.value;
         this.start = props.start;
@@ -2168,8 +2166,6 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     $propdoc: {
         quote: "[string|undefined] the original quote character, if any",
         static: "[boolean] is this method static (classes only)",
-        is_generator: "[boolean] is this a generator method",
-        async: "[boolean] is this method async",
     },
     $documentation: "An ES6 concise method inside an object or class",
     computed_key() {
@@ -2177,11 +2173,9 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     }
 }, AST_ObjectProperty);
 
-var AST_PrivateMethod = DEFNODE("PrivateMethod", "", function AST_PrivateMethod(props) {
+var AST_PrivateMethod = DEFNODE("PrivateMethod", "static", function AST_PrivateMethod(props) {
     if (props) {
         this.static = props.static;
-        this.is_generator = props.is_generator;
-        this.async = props.async;
         this.key = props.key;
         this.value = props.value;
         this.start = props.start;
@@ -2191,6 +2185,9 @@ var AST_PrivateMethod = DEFNODE("PrivateMethod", "", function AST_PrivateMethod(
     this.flags = 0;
 }, {
     $documentation: "A private class method inside a class",
+    $propdoc: {
+        static: "[boolean] is this a static private method",
+    },
     computed_key() {
         return false;
     },
@@ -3181,6 +3178,28 @@ class TreeWalker {
         }
     }
 
+    is_within_loop() {
+        let i = this.stack.length - 1;
+        let child = this.stack[i];
+        while (i--) {
+            const node = this.stack[i];
+
+            if (node instanceof AST_Lambda) return false;
+            if (
+                node instanceof AST_IterationStatement
+                // exclude for-loop bits that only run once
+                && !((node instanceof AST_For) && child === node.init)
+                && !((node instanceof AST_ForIn || node instanceof AST_ForOf) && child === node.object)
+            ) {
+                return true;
+            }
+
+            child = node;
+        }
+
+        return false;
+    }
+
     find_scope() {
         var stack = this.stack;
         for (var i = stack.length; --i >= 0;) {

package/lib/compress/index.js

@@ -3522,7 +3522,7 @@ AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
             if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
                 const all_props_flattenable = props.every((p) =>
                     (p instanceof AST_ObjectKeyVal
-                        || arrows && p instanceof AST_ConciseMethod && !p.is_generator
+                        || arrows && p instanceof AST_ConciseMethod && !p.value.is_generator
                     )
                     && !p.computed_key()
                 );
@@ -4008,7 +4008,7 @@ def_optimize(AST_ConciseMethod, function(self, compressor) {
     // p(){return x;} ---> p:()=>x
     if (compressor.option("arrows")
         && compressor.parent() instanceof AST_Object
-        && !self.is_generator
+        && !self.value.is_generator
         && !self.value.uses_arguments
         && !self.value.pinned()
         && self.value.body.length == 1
@@ -4016,8 +4016,8 @@ def_optimize(AST_ConciseMethod, function(self, compressor) {
         && self.value.body[0].value
         && !self.value.contains_this()) {
         var arrow = make_node(AST_Arrow, self.value, self.value);
-        arrow.async = self.async;
-        arrow.is_generator = self.is_generator;
+        arrow.async = self.value.async;
+        arrow.is_generator = self.value.is_generator;
         return make_node(AST_ObjectKeyVal, self, {
             key: self.key instanceof AST_SymbolMethod ? self.key.name : self.key,
             value: arrow,
@@ -4045,8 +4045,6 @@ def_optimize(AST_ObjectKeyVal, function(self, compressor) {
             && !value.contains_this();
         if ((is_arrow_with_block || value instanceof AST_Function) && !value.name) {
             return make_node(AST_ConciseMethod, self, {
-                async: value.async,
-                is_generator: value.is_generator,
                 key: key instanceof AST_Node ? key : make_node(AST_SymbolMethod, self, {
                     name: key,
                 }),

package/lib/compress/inline.js

@@ -187,6 +187,8 @@ export function inline_into_symbolref(self, compressor) {
         return self;
     }
 
+    if (dont_inline_lambda_in_loop(compressor, fixed)) return self;
+
     let single_use = def.single_use
         && !(parent instanceof AST_Call
             && (parent.is_callee_pure(compressor))
@@ -340,6 +342,11 @@ export function inline_into_call(self, compressor) {
         fn = fixed;
     }
 
+    if (
+        dont_inline_lambda_in_loop(compressor, fn)
+        && !has_annotation(self, _INLINE)
+    ) return self;
+
     var is_func = fn instanceof AST_Lambda;
 
     var stat = is_func && fn.body[0];
@@ -667,3 +674,11 @@ export function inline_into_call(self, compressor) {
         return expressions.map(exp => exp.clone(true));
     }
 }
+
+/** prevent inlining functions into loops, for performance reasons */
+function dont_inline_lambda_in_loop(compressor, maybe_lambda) {
+    return (
+        (maybe_lambda instanceof AST_Lambda || maybe_lambda instanceof AST_Class)
+        && !!compressor.is_within_loop()
+    );
+}

package/lib/equivalent-to.js

@@ -249,11 +249,11 @@ AST_ObjectGetter.prototype.shallow_cmp = function(other) {
 };
 
 AST_ConciseMethod.prototype.shallow_cmp = function(other) {
-    return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
+    return this.static === other.static;
 };
 
 AST_PrivateMethod.prototype.shallow_cmp = function(other) {
-    return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
+    return this.static === other.static;
 };
 
 AST_Class.prototype.shallow_cmp = function(other) {