terser 5.5.1 → 5.7.0

package/lib/ast.js

@@ -522,6 +522,21 @@ var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator as
 
         if (this.name) push(this.name);
     },
+    is_braceless() {
+        return this.body[0] instanceof AST_Return && this.body[0].value;
+    },
+    // Default args and expansion don't count, so .argnames.length doesn't cut it
+    length_property() {
+        let length = 0;
+
+        for (const arg of this.argnames) {
+            if (arg instanceof AST_SymbolFunarg || arg instanceof AST_Destructuring) {
+                length++;
+            }
+        }
+
+        return length;
+    }
 }, AST_Scope);
 
 var AST_Accessor = DEFNODE("Accessor", null, {
@@ -1007,7 +1022,7 @@ var AST_PropAccess = DEFNODE("PropAccess", "expression property optional", {
     $documentation: "Base class for property access expressions, i.e. `a.foo` or `a[\"foo\"]`",
     $propdoc: {
         expression: "[AST_Node] the “container” expression",
-        property: "[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node",
+        property: "[AST_Node|string] the property to access.  For AST_Dot & AST_DotHash this is always a plain string, while for AST_Sub it's an arbitrary AST_Node",
 
         optional: "[boolean] whether this is an optional property access (IE ?.)"
     }
@@ -1028,6 +1043,18 @@ var AST_Dot = DEFNODE("Dot", "quote", {
     },
 }, AST_PropAccess);
 
+var AST_DotHash = DEFNODE("DotHash", "", {
+    $documentation: "A dotted property access to a private property",
+    _walk: function(visitor) {
+        return visitor._visit(this, function() {
+            this.expression._walk(visitor);
+        });
+    },
+    _children_backwards(push) {
+        push(this.expression);
+    },
+}, AST_PropAccess);
+
 var AST_Sub = DEFNODE("Sub", null, {
     $documentation: "Index-style property access, i.e. `a[\"foo\"]`",
     _walk: function(visitor) {
@@ -1045,7 +1072,7 @@ var AST_Sub = DEFNODE("Sub", null, {
 var AST_Chain = DEFNODE("Chain", "expression", {
     $documentation: "A chain expression like a?.b?.(c)?.[d]",
     $propdoc: {
-        expression: "[AST_Call|AST_Dot|AST_Sub] chain element."
+        expression: "[AST_Call|AST_Dot|AST_DotHash|AST_Sub] chain element."
     },
     _walk: function (visitor) {
         return visitor._visit(this, function() {
@@ -1201,6 +1228,26 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
     }
 }, AST_ObjectProperty);
 
+var AST_PrivateSetter = DEFNODE("PrivateSetter", "static", {
+    $propdoc: {
+        static: "[boolean] whether this is a static private setter"
+    },
+    $documentation: "A private setter property",
+    computed_key() {
+        return false;
+    }
+}, AST_ObjectProperty);
+
+var AST_PrivateGetter = DEFNODE("PrivateGetter", "static", {
+    $propdoc: {
+        static: "[boolean] whether this is a static private getter"
+    },
+    $documentation: "A private getter property",
+    computed_key() {
+        return false;
+    }
+}, AST_ObjectProperty);
+
 var AST_ObjectSetter = DEFNODE("ObjectSetter", "quote static", {
     $propdoc: {
         quote: "[string|undefined] the original quote character, if any",
@@ -1236,6 +1283,10 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     }
 }, AST_ObjectProperty);
 
+var AST_PrivateMethod = DEFNODE("PrivateMethod", "", {
+    $documentation: "A private class method inside a class",
+}, AST_ConciseMethod);
+
 var AST_Class = DEFNODE("Class", "name extends properties", {
     $propdoc: {
         name: "[AST_SymbolClass|AST_SymbolDefClass?] optional class name.",
@@ -1285,6 +1336,10 @@ var AST_ClassProperty = DEFNODE("ClassProperty", "static quote", {
     }
 }, AST_ObjectProperty);
 
+var AST_ClassPrivateProperty = DEFNODE("ClassProperty", "", {
+    $documentation: "A class property for a private property",
+}, AST_ClassProperty);
+
 var AST_DefClass = DEFNODE("DefClass", null, {
     $documentation: "A class definition",
 }, AST_Class);
@@ -1684,6 +1739,7 @@ export {
     AST_Chain,
     AST_Class,
     AST_ClassExpression,
+    AST_ClassPrivateProperty,
     AST_ClassProperty,
     AST_ConciseMethod,
     AST_Conditional,
@@ -1700,6 +1756,7 @@ export {
     AST_Directive,
     AST_Do,
     AST_Dot,
+    AST_DotHash,
     AST_DWLoop,
     AST_EmptyStatement,
     AST_Exit,
@@ -1737,6 +1794,9 @@ export {
     AST_ObjectProperty,
     AST_ObjectSetter,
     AST_PrefixedTemplateString,
+    AST_PrivateGetter,
+    AST_PrivateMethod,
+    AST_PrivateSetter,
     AST_PropAccess,
     AST_RegExp,
     AST_Return,

package/lib/cli.js

@@ -42,7 +42,7 @@ export async function run_cli({ program, packageJson, fs, path }) {
     program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js());
     program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js());
     program.option("-f, --format [options]", "Format options.", parse_js());
-    program.option("-b, --beautify [options]", "Alias for --format beautify=true.", parse_js());
+    program.option("-b, --beautify [options]", "Alias for --format.", parse_js());
     program.option("-o, --output <file>", "Output file (default STDOUT).");
     program.option("--comments [filter]", "Preserve copyright comments in the output.");
     program.option("--config-file <file>", "Read minify() options from JSON file.");
@@ -93,19 +93,9 @@ export async function run_cli({ program, packageJson, fs, path }) {
         else
             options.ecma = ecma;
     }
-    if (program.beautify || program.format) {
-        if (program.beautify && program.format) {
-            fatal("Please only specify one of --beautify or --format");
-        }
-        if (program.beautify) {
-            options.format = typeof program.beautify == "object" ? program.beautify : {};
-            if (!("beautify" in options.format)) {
-                options.format.beautify = true;
-            }
-        }
-        if (program.format) {
-            options.format = typeof program.format == "object" ? program.format : {};
-        }
+    if (program.format || program.beautify) {
+        const chosenOption = program.format || program.beautify;
+        options.format = typeof chosenOption === "object" ? chosenOption : {};
     }
     if (program.comments) {
         if (typeof options.format != "object") options.format = {};

package/lib/compress/index.js

@@ -209,11 +209,8 @@ const TOP       = 0b0000010000000000;
 
 const CLEAR_BETWEEN_PASSES = SQUEEZED | OPTIMIZED | TOP;
 
-/*@__INLINE__*/
 const has_flag = (node, flag) => node.flags & flag;
-/*@__INLINE__*/
 const set_flag = (node, flag) => { node.flags |= flag; };
-/*@__INLINE__*/
 const clear_flag = (node, flag) => { node.flags &= ~flag; };
 
 class Compressor extends TreeWalker {
@@ -256,7 +253,7 @@ class Compressor extends TreeWalker {
             properties    : !false_by_default,
             pure_getters  : !false_by_default && "strict",
             pure_funcs    : null,
-            reduce_funcs  : null,  // legacy
+            reduce_funcs  : !false_by_default,
             reduce_vars   : !false_by_default,
             sequences     : !false_by_default,
             side_effects  : !false_by_default,
@@ -556,7 +553,7 @@ function is_modified(compressor, tw, node, value, level, immutable) {
         && parent.expression === node
         && !(value instanceof AST_Arrow)
         && !(value instanceof AST_Class)
-        && !parent.is_expr_pure(compressor)
+        && !parent.is_callee_pure(compressor)
         && (!(value instanceof AST_Function)
             || !(parent instanceof AST_New) && value.contains_this())) {
         return true;
@@ -861,9 +858,6 @@ function is_modified(compressor, tw, node, value, level, immutable) {
         return true;
     });
     def_reduce_vars(AST_Call, function (tw) {
-        // TODO this block should just be { return } but
-        // for some reason the _walk function of AST_Call walks the callee last
-
         this.expression.walk(tw);
 
         if (this.optional) {
@@ -1416,8 +1410,11 @@ function tighten_body(statements, compressor) {
                 || node instanceof AST_Debugger
                 || node instanceof AST_Destructuring
                 || node instanceof AST_Expansion
-                   && node.expression instanceof AST_Symbol
-                   && node.expression.definition().references.length > 1
+                    && node.expression instanceof AST_Symbol
+                    && (
+                        node.expression instanceof AST_This
+                        || node.expression.definition().references.length > 1
+                    )
                 || node instanceof AST_IterationStatement && !(node instanceof AST_For)
                 || node instanceof AST_LoopControl
                 || node instanceof AST_Try
@@ -2586,7 +2583,13 @@ function is_undefined(node, compressor) {
     });
     def_may_throw_on_access(AST_Dot, function(compressor) {
         if (!is_strict(compressor)) return false;
-        if (this.expression instanceof AST_Function && this.property == "prototype") return false;
+
+        if (this.property == "prototype") {
+            return !(
+                this.expression instanceof AST_Function
+                || this.expression instanceof AST_Class
+            );
+        }
         return true;
     });
     def_may_throw_on_access(AST_Chain, function(compressor) {
@@ -2928,9 +2931,7 @@ var static_fns = convert_to_predicate({
         if (compressor.option("unsafe")) {
             var fn = function() {};
             fn.node = this;
-            fn.toString = function() {
-                return this.node.print_to_string();
-            };
+            fn.toString = () => this.print_to_string();
             return fn;
         }
         return this;
@@ -3111,6 +3112,14 @@ var static_fns = convert_to_predicate({
             "POSITIVE_INFINITY",
         ],
     });
+    const regexp_flags = new Set([
+        "dotAll",
+        "global",
+        "ignoreCase",
+        "multiline",
+        "sticky",
+        "unicode",
+    ]);
     def_eval(AST_PropAccess, function(compressor, depth) {
         if (this.optional) {
             const obj = this.expression._eval(compressor, depth);
@@ -3143,12 +3152,19 @@ var static_fns = convert_to_predicate({
                 val = global_objs[exp.name];
             } else {
                 val = exp._eval(compressor, depth + 1);
+                if (val instanceof RegExp) {
+                    if (key == "source") {
+                        return regexp_source_fix(val.source);
+                    } else if (key == "flags" || regexp_flags.has(key)) {
+                        return val[key];
+                    }
+                }
                 if (!val || val === exp || !HOP(val, key)) return this;
                 if (typeof val == "function") switch (key) {
                   case "name":
                     return val.node.name ? val.node.name.name : "";
                   case "length":
-                    return val.node.argnames.length;
+                    return val.node.length_property();
                   default:
                     return this;
                 }
@@ -3200,6 +3216,7 @@ var static_fns = convert_to_predicate({
                 var arg = this.args[i];
                 var value = arg._eval(compressor, depth);
                 if (arg === value) return this;
+                if (arg instanceof AST_Lambda) return this;
                 args.push(value);
             }
             try {
@@ -3299,7 +3316,7 @@ var static_fns = convert_to_predicate({
 });
 
 var global_pure_fns = makePredicate("Boolean decodeURI decodeURIComponent Date encodeURI encodeURIComponent Error escape EvalError isFinite isNaN Number Object parseFloat parseInt RangeError ReferenceError String SyntaxError TypeError unescape URIError");
-AST_Call.DEFMETHOD("is_expr_pure", function(compressor) {
+AST_Call.DEFMETHOD("is_callee_pure", function(compressor) {
     if (compressor.option("unsafe")) {
         var expr = this.expression;
         var first_arg = (this.args && this.args[0] && this.args[0].evaluate(compressor));
@@ -3369,7 +3386,7 @@ const pure_prop_access_globals = new Set([
     });
     def_has_side_effects(AST_Call, function(compressor) {
         if (
-            !this.is_expr_pure(compressor)
+            !this.is_callee_pure(compressor)
             && (!this.expression.is_call_pure(compressor)
                 || this.expression.has_side_effects(compressor))
         ) {
@@ -3433,7 +3450,7 @@ const pure_prop_access_globals = new Set([
     def_has_side_effects(AST_ObjectProperty, function(compressor) {
         return (
             this.computed_key() && this.key.has_side_effects(compressor)
-            || this.value.has_side_effects(compressor)
+            || this.value && this.value.has_side_effects(compressor)
         );
     });
     def_has_side_effects(AST_ClassProperty, function(compressor) {
@@ -3531,7 +3548,7 @@ const pure_prop_access_globals = new Set([
     def_may_throw(AST_Call, function(compressor) {
         if (this.optional && is_nullish(this.expression)) return false;
         if (any(this.args, compressor)) return true;
-        if (this.is_expr_pure(compressor)) return false;
+        if (this.is_callee_pure(compressor)) return false;
         if (this.expression.may_throw(compressor)) return true;
         return !(this.expression instanceof AST_Lambda)
             || any(this.expression.body, compressor);
@@ -3561,7 +3578,7 @@ const pure_prop_access_globals = new Set([
     });
     def_may_throw(AST_ObjectProperty, function(compressor) {
         // TODO key may throw too
-        return this.value.may_throw(compressor);
+        return this.value ? this.value.may_throw(compressor) : false;
     });
     def_may_throw(AST_ClassProperty, function(compressor) {
         return (
@@ -3695,7 +3712,7 @@ const pure_prop_access_globals = new Set([
         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();
+        return !!(!(this.key instanceof AST_Node) && this.value && this.value.is_constant_expression());
     });
 })(function(node, func) {
     node.DEFMETHOD("is_constant_expression", func);
@@ -4409,7 +4426,7 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
             return make_node(AST_Undefined, this);
         }
 
-        if (!this.is_expr_pure(compressor)) {
+        if (!this.is_callee_pure(compressor)) {
             if (this.expression.is_call_pure(compressor)) {
                 var exprs = this.args.slice();
                 exprs.unshift(this.expression.expression);
@@ -4522,7 +4539,7 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     def_drop_side_effect_free(AST_ObjectProperty, function(compressor, first_in_statement) {
         const computed_key = this instanceof AST_ObjectKeyVal && this.key instanceof AST_Node;
         const key = computed_key && this.key.drop_side_effect_free(compressor, first_in_statement);
-        const value = this.value.drop_side_effect_free(compressor, first_in_statement);
+        const value = this.value && this.value.drop_side_effect_free(compressor, first_in_statement);
         if (key && value) {
             return make_sequence(this, [key, value]);
         }
@@ -5429,7 +5446,7 @@ def_optimize(AST_Call, function(self, compressor) {
 
     var stat = is_func && fn.body[0];
     var is_regular_func = is_func && !fn.is_generator && !fn.async;
-    var can_inline = is_regular_func && compressor.option("inline") && !self.is_expr_pure(compressor);
+    var can_inline = is_regular_func && compressor.option("inline") && !self.is_callee_pure(compressor);
     if (can_inline && stat instanceof AST_Return) {
         let returned = stat.value;
         if (!returned || returned.is_constant_expression()) {
@@ -6455,19 +6472,26 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
         let fixed = self.fixed_value();
         let single_use = def.single_use
             && !(parent instanceof AST_Call
-                && (parent.is_expr_pure(compressor))
+                && (parent.is_callee_pure(compressor))
                     || has_annotation(parent, _NOINLINE))
             && !(parent instanceof AST_Export
                 && fixed instanceof AST_Lambda
                 && fixed.name);
 
+        if (single_use && fixed instanceof AST_Node) {
+            single_use =
+                !fixed.has_side_effects(compressor)
+                && !fixed.may_throw(compressor);
+        }
+
         if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
             if (retain_top_func(fixed, compressor)) {
                 single_use = false;
             } else if (def.scope !== self.scope
                 && (def.escaped == 1
                     || has_flag(fixed, INLINED)
-                    || within_array_or_object_literal(compressor))) {
+                    || within_array_or_object_literal(compressor)
+                    || !compressor.option("reduce_funcs"))) {
                 single_use = false;
             } else if (recursive_ref(compressor, def)) {
                 single_use = false;
@@ -6483,6 +6507,7 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
                 }
             }
         }
+
         if (single_use && fixed instanceof AST_Lambda) {
             single_use =
                 def.scope === self.scope
@@ -6492,15 +6517,6 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
                     && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
                     && !(fixed.name && fixed.name.definition().recursive_refs > 0);
         }
-        if (single_use && fixed instanceof AST_Class) {
-            const extends_inert = !fixed.extends
-                || !fixed.extends.may_throw(compressor)
-                    && !fixed.extends.has_side_effects(compressor);
-            single_use = extends_inert
-                && !fixed.properties.some(prop =>
-                    prop.may_throw(compressor) || prop.has_side_effects(compressor)
-                );
-        }
 
         if (single_use && fixed) {
             if (fixed instanceof AST_DefClass) {
@@ -6577,6 +6593,7 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
             }
         }
     }
+
     return self;
 });
 
@@ -7163,27 +7180,40 @@ function safe_to_flatten(value, compressor) {
 
 AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
     if (!compressor.option("properties")) return;
+    if (key === "__proto__") return;
+
     var arrows = compressor.option("unsafe_arrows") && compressor.option("ecma") >= 2015;
     var expr = this.expression;
     if (expr instanceof AST_Object) {
         var props = expr.properties;
+
         for (var i = props.length; --i >= 0;) {
             var prop = props[i];
+
             if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
-                if (!props.every((prop) => {
-                    return prop instanceof AST_ObjectKeyVal
-                        || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;
-                })) break;
-                if (!safe_to_flatten(prop.value, compressor)) break;
+                const all_props_flattenable = props.every((p) =>
+                    (p instanceof AST_ObjectKeyVal
+                        || arrows && p instanceof AST_ConciseMethod && !p.is_generator
+                    )
+                    && !p.computed_key()
+                );
+
+                if (!all_props_flattenable) return;
+                if (!safe_to_flatten(prop.value, compressor)) return;
+
                 return make_node(AST_Sub, this, {
                     expression: make_node(AST_Array, expr, {
                         elements: props.map(function(prop) {
                             var v = prop.value;
-                            if (v instanceof AST_Accessor) v = make_node(AST_Function, v, v);
+                            if (v instanceof AST_Accessor) {
+                                v = make_node(AST_Function, v, v);
+                            }
+
                             var k = prop.key;
                             if (k instanceof AST_Node && !(k instanceof AST_SymbolMethod)) {
                                 return make_sequence(prop, [ k, v ]);
                             }
+
                             return v;
                         })
                     }),

package/lib/minify.js

@@ -7,7 +7,7 @@ import {
     map_to_object,
     HOP,
 } from "./utils/index.js";
-import { AST_Toplevel } from "./ast.js";
+import { AST_Toplevel, AST_Node } from "./ast.js";
 import { parse } from "./parse.js";
 import { OutputStream } from "./output.js";
 import { Compressor } from "./compress/index.js";
@@ -77,6 +77,7 @@ async function minify(files, options) {
         rename: undefined,
         safari10: false,
         sourceMap: false,
+        spidermonkey: false,
         timings: false,
         toplevel: false,
         warnings: false,
@@ -148,20 +149,32 @@ async function minify(files, options) {
     if (files instanceof AST_Toplevel) {
         toplevel = files;
     } else {
-        if (typeof files == "string") {
+        if (typeof files == "string" || (options.parse.spidermonkey && !Array.isArray(files))) {
             files = [ files ];
         }
         options.parse = options.parse || {};
         options.parse.toplevel = null;
-        for (var name in files) if (HOP(files, name)) {
-            options.parse.filename = name;
-            options.parse.toplevel = parse(files[name], options.parse);
-            if (options.sourceMap && options.sourceMap.content == "inline") {
-                if (Object.keys(files).length > 1)
-                    throw new Error("inline source map only works with singular input");
-                options.sourceMap.content = read_source_map(files[name]);
+
+        if (options.parse.spidermonkey) {
+            options.parse.toplevel = AST_Node.from_mozilla_ast(Object.keys(files).reduce(function(toplevel, name) {
+                if (!toplevel) return files[name];
+                toplevel.body = toplevel.body.concat(files[name].body);
+                return toplevel;
+            }, null));
+        } else {
+            delete options.parse.spidermonkey;
+
+            for (var name in files) if (HOP(files, name)) {
+                options.parse.filename = name;
+                options.parse.toplevel = parse(files[name], options.parse);
+                if (options.sourceMap && options.sourceMap.content == "inline") {
+                    if (Object.keys(files).length > 1)
+                        throw new Error("inline source map only works with singular input");
+                    options.sourceMap.content = read_source_map(files[name]);
+                }
             }
         }
+
         toplevel = options.parse.toplevel;
     }
     if (quoted_props && options.mangle.properties.keep_quoted !== "strict") {
@@ -203,6 +216,9 @@ async function minify(files, options) {
     if (options.format.ast) {
         result.ast = toplevel;
     }
+    if (options.format.spidermonkey) {
+        result.ast = toplevel.to_mozilla_ast();
+    }
     if (!HOP(options.format, "code") || options.format.code) {
         if (options.sourceMap) {
             options.format.source_map = await SourceMap({
@@ -220,6 +236,7 @@ async function minify(files, options) {
         }
         delete options.format.ast;
         delete options.format.code;
+        delete options.format.spidermonkey;
         var stream = OutputStream(options.format);
         toplevel.print(stream);
         result.code = stream.get();