terser 5.6.0-beta → 5.7.1

package/lib/ast.js

@@ -214,8 +214,6 @@ function walk_body(node, visitor) {
 function clone_block_scope(deep) {
     var clone = this._clone(deep);
     if (this.block_scope) {
-        // TODO this is sometimes undefined during compression.
-        // But it should always have a value!
         clone.block_scope = this.block_scope.clone();
     }
     return clone;
@@ -399,7 +397,6 @@ var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent
     $documentation: "Base class for all statements introducing a lexical scope",
     $propdoc: {
         variables: "[Map/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
-        functions: "[Map/S] like `variables`, but only lists function declarations",
         uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
         uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`",
         parent_scope: "[AST_Scope?/S] link to the parent scope",
@@ -422,7 +419,6 @@ var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent
             });
         } else {
             if (this.variables) node.variables = new Map(this.variables);
-            if (this.functions) node.functions = new Map(this.functions);
             if (this.enclosed) node.enclosed = this.enclosed.slice();
             if (this._block_scope) node._block_scope = this._block_scope;
         }
@@ -522,6 +518,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, {

package/lib/cli.js

@@ -264,7 +264,6 @@ export async function run_cli({ program, packageJson, fs, path }) {
                   case "enclosed":
                     return value.length ? value.map(symdef) : undefined;
                   case "variables":
-                  case "functions":
                   case "globals":
                     return value.size ? collect_from_map(value, symdef) : undefined;
                 }
@@ -277,7 +276,6 @@ export async function run_cli({ program, packageJson, fs, path }) {
                     };
                     if (value.block_scope) {
                         result.variables = value.block_scope.variables;
-                        result.functions = value.block_scope.functions;
                         result.enclosed = value.block_scope.enclosed;
                     }
                     value.CTOR.PROPS.forEach(function(prop) {

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
@@ -1511,6 +1508,7 @@ function tighten_body(statements, compressor) {
             if (stop_after === node) abort = true;
             if (stop_if_hit === node) stop_if_hit = null;
         });
+
         var multi_replacer = new TreeTransformer(function(node) {
             if (abort) return node;
             // Skip nodes before `candidate` as quickly as possible
@@ -1533,6 +1531,7 @@ function tighten_body(statements, compressor) {
             // Skip (non-executed) functions and (leading) default case in switch statements
             if (node instanceof AST_Default || node instanceof AST_Scope) return node;
         });
+
         while (--stat_index >= 0) {
             // Treat parameters as collapsible in IIFE, i.e.
             //   function(a, b){ ... }(x());
@@ -1708,7 +1707,10 @@ function tighten_body(statements, compressor) {
         function extract_candidates(expr) {
             hit_stack.push(expr);
             if (expr instanceof AST_Assign) {
-                if (!expr.left.has_side_effects(compressor)) {
+                if (
+                    !expr.left.has_side_effects(compressor)
+                    && !(expr.right instanceof AST_Chain)
+                ) {
                     candidates.push(hit_stack.slice());
                 }
                 extract_candidates(expr.right);
@@ -1771,7 +1773,7 @@ function tighten_body(statements, compressor) {
                     candidates.push(hit_stack.slice());
                 }
             } else if (expr instanceof AST_VarDef) {
-                if (expr.value) {
+                if (expr.value && !(expr.value instanceof AST_Chain)) {
                     candidates.push(hit_stack.slice());
                     extract_candidates(expr.value);
                 }
@@ -2586,7 +2588,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 +2936,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 +3117,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 +3157,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 +3221,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 +3321,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 +3391,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))
         ) {
@@ -3459,7 +3481,7 @@ const pure_prop_access_globals = new Set([
             || this.expression.has_side_effects(compressor);
     });
     def_has_side_effects(AST_Sub, function(compressor) {
-        if (this.optional && is_nullish(this.expression)) {
+        if (this.optional && is_nullish(this.expression, compressor)) {
             return false;
         }
 
@@ -3529,9 +3551,9 @@ const pure_prop_access_globals = new Set([
         return any(this.body, compressor);
     });
     def_may_throw(AST_Call, function(compressor) {
-        if (this.optional && is_nullish(this.expression)) return false;
+        if (this.optional && is_nullish(this.expression, compressor)) 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);
@@ -3592,7 +3614,7 @@ const pure_prop_access_globals = new Set([
             || this.expression.may_throw(compressor);
     });
     def_may_throw(AST_Sub, function(compressor) {
-        if (this.optional && is_nullish(this.expression)) return false;
+        if (this.optional && is_nullish(this.expression, compressor)) return false;
 
         return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.may_throw(compressor)
@@ -4405,11 +4427,11 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     def_drop_side_effect_free(AST_Constant, return_null);
     def_drop_side_effect_free(AST_This, return_null);
     def_drop_side_effect_free(AST_Call, function(compressor, first_in_statement) {
-        if (this.optional && is_nullish(this.expression)) {
+        if (this.optional && is_nullish(this.expression, 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);
@@ -4552,7 +4574,7 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     });
     def_drop_side_effect_free(AST_Dot, function(compressor, first_in_statement) {
         if (this.optional) {
-            return is_nullish(this.expression) ? make_node(AST_Undefined, this) : this;
+            return is_nullish(this.expression, compressor) ? make_node(AST_Undefined, this) : this;
         }
         if (this.expression.may_throw_on_access(compressor)) return this;
 
@@ -4560,7 +4582,7 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     });
     def_drop_side_effect_free(AST_Sub, function(compressor, first_in_statement) {
         if (this.optional) {
-            return is_nullish(this.expression) ? make_node(AST_Undefined, this): this;
+            return is_nullish(this.expression, compressor) ? make_node(AST_Undefined, this): this;
         }
         if (this.expression.may_throw_on_access(compressor)) return this;
 
@@ -5085,11 +5107,11 @@ def_optimize(AST_Definitions, function(self) {
     return self;
 });
 
-def_optimize(AST_VarDef, function(self) {
+def_optimize(AST_VarDef, function(self, compressor) {
     if (
         self.name instanceof AST_SymbolLet
         && self.value != null
-        && is_undefined(self.value)
+        && is_undefined(self.value, compressor)
     ) {
         self.value = null;
     }
@@ -5127,7 +5149,7 @@ def_optimize(AST_Call, function(self, compressor) {
         }
     }
 
-    if (self.optional && is_nullish(fn)) {
+    if (self.optional && is_nullish(fn, compressor)) {
         return make_node(AST_Undefined, self);
     }
 
@@ -5429,7 +5451,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()) {
@@ -6153,7 +6175,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             }
             break;
           case "??":
-            if (is_nullish(self.left)) {
+            if (is_nullish(self.left, compressor)) {
                 return self.right;
             }
 
@@ -6455,19 +6477,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 +6512,7 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
                 }
             }
         }
+
         if (single_use && fixed instanceof AST_Lambda) {
             single_use =
                 def.scope === self.scope
@@ -6492,15 +6522,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 +6598,7 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
             }
         }
     }
+
     return self;
 });
 
@@ -6761,20 +6783,20 @@ def_optimize(AST_DefaultAssign, function(self, compressor) {
     return self;
 });
 
-function is_nullish(node) {
+function is_nullish(node, compressor) {
     let fixed;
     return (
         node instanceof AST_Null
-        || is_undefined(node)
+        || is_undefined(node, compressor)
         || (
             node instanceof AST_SymbolRef
             && (fixed = node.definition().fixed) instanceof AST_Node
-            && is_nullish(fixed)
+            && is_nullish(fixed, compressor)
         )
         // Recurse into those optional chains!
-        || node instanceof AST_PropAccess && node.optional && is_nullish(node.expression)
-        || node instanceof AST_Call && node.optional && is_nullish(node.expression)
-        || node instanceof AST_Chain && is_nullish(node.expression)
+        || node instanceof AST_PropAccess && node.optional && is_nullish(node.expression, compressor)
+        || node instanceof AST_Call && node.optional && is_nullish(node.expression, compressor)
+        || node instanceof AST_Chain && is_nullish(node.expression, compressor)
     );
 }
 
@@ -6789,8 +6811,8 @@ function is_nullish_check(check, check_subject, compressor) {
         && check.operator === "=="
         // which side is nullish?
         && (
-            (nullish_side = is_nullish(check.left) && check.left)
-            || (nullish_side = is_nullish(check.right) && check.right)
+            (nullish_side = is_nullish(check.left, compressor) && check.left)
+            || (nullish_side = is_nullish(check.right, compressor) && check.right)
         )
         // is the other side the same as the check_subject
         && (
@@ -6828,12 +6850,12 @@ function is_nullish_check(check, check_subject, compressor) {
                 null_cmp = cmp;
                 defined_side = cmp.left;
             }
-            if (is_undefined(cmp.left)) {
+            if (is_undefined(cmp.left, compressor)) {
                 found++;
                 undefined_cmp = cmp;
                 defined_side = cmp.right;
             }
-            if (is_undefined(cmp.right)) {
+            if (is_undefined(cmp.right, compressor)) {
                 found++;
                 undefined_cmp = cmp;
                 defined_side = cmp.left;
@@ -7163,27 +7185,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;
                         })
                     }),
@@ -7321,7 +7356,7 @@ def_optimize(AST_Sub, function(self, compressor) {
         ev = make_node_from_constant(ev, self).optimize(compressor);
         return best_of(compressor, ev, self);
     }
-    if (self.optional && is_nullish(self.expression)) {
+    if (self.optional && is_nullish(self.expression, compressor)) {
         return make_node(AST_Undefined, self);
     }
     return self;
@@ -7395,7 +7430,7 @@ def_optimize(AST_Dot, function(self, compressor) {
         ev = make_node_from_constant(ev, self).optimize(compressor);
         return best_of(compressor, ev, self);
     }
-    if (self.optional && is_nullish(self.expression)) {
+    if (self.optional && is_nullish(self.expression, compressor)) {
         return make_node(AST_Undefined, self);
     }
     return self;
@@ -7439,7 +7474,7 @@ def_optimize(AST_Array, function(self, compressor) {
     return self;
 });
 
-function inline_object_prop_spread(props) {
+function inline_object_prop_spread(props, compressor) {
     for (var i = 0; i < props.length; i++) {
         var prop = props[i];
         if (prop instanceof AST_Expansion) {
@@ -7457,6 +7492,9 @@ function inline_object_prop_spread(props) {
                 // non-iterable value silently does nothing; it is thus safe
                 // to remove. AST_String is the only iterable AST_Constant.
                 props.splice(i, 1);
+            } else if (is_nullish(expr, compressor)) {
+                // Likewise, null and undefined can be silently removed.
+                props.splice(i, 1);
             }
         }
     }
@@ -7467,7 +7505,7 @@ def_optimize(AST_Object, function(self, compressor) {
     if (optimized !== self) {
         return optimized;
     }
-    inline_object_prop_spread(self.properties);
+    inline_object_prop_spread(self.properties, compressor);
     return self;
 });
 
@@ -7560,7 +7598,7 @@ def_optimize(AST_TemplateString, function(self, compressor) {
         && (
             segments[1].is_string(compressor)
             || segments[1].is_number(compressor)
-            || is_nullish(segments[1])
+            || is_nullish(segments[1], compressor)
             || compressor.option("unsafe")
         )
     ) {

package/lib/equivalent-to.js

@@ -18,6 +18,7 @@ import {
     AST_Directive,
     AST_Do,
     AST_Dot,
+    AST_DotHash,
     AST_EmptyStatement,
     AST_Expansion,
     AST_Export,
@@ -233,6 +234,10 @@ AST_Dot.prototype.shallow_cmp = mkshallow({
     property: "eq"
 });
 
+AST_DotHash.prototype.shallow_cmp = mkshallow({
+    property: "eq"
+});
+
 AST_Unary.prototype.shallow_cmp = mkshallow({
     operator: "eq"
 });

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();

package/lib/output.js

@@ -349,11 +349,15 @@ function OutputStream(options) {
     var do_add_mapping = mappings ? function() {
         mappings.forEach(function(mapping) {
             try {
+                let name = !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name;
+                if (name instanceof AST_Symbol) {
+                    name = name.name;
+                }
                 options.source_map.add(
                     mapping.token.file,
                     mapping.line, mapping.col,
                     mapping.token.line, mapping.token.col,
-                    !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name
+                    is_basic_identifier_string(name) ? name : undefined
                 );
             } catch(ex) {
                 // Ignore bad mapping
@@ -933,6 +937,7 @@ function OutputStream(options) {
         var p = output.parent();
         return p instanceof AST_PropAccess && p.expression === this
             || p instanceof AST_Call && p.expression === this
+            || p instanceof AST_Binary && p.operator === "**" && p.left === this
             || output.option("safari10") && p instanceof AST_UnaryPrefix;
     });
 
@@ -2150,7 +2155,9 @@ function OutputStream(options) {
         source = regexp_source_fix(source);
         flags = flags ? sort_regexp_flags(flags) : "";
         source = source.replace(r_slash_script, slash_script_replace);
+
         output.print(output.to_utf8(`/${source}/${flags}`));
+
         const parent = output.parent();
         if (
             parent instanceof AST_Binary