terser 5.15.1 → 5.16.1

package/lib/compress/tighten-body.js

@@ -205,9 +205,10 @@ export function trim_unreachable_code(compressor, stat, target) {
 
 /** Tighten a bunch of statements together, and perform statement-level optimization. */
 export function tighten_body(statements, compressor) {
-    var in_loop, in_try;
-    var scope = compressor.find_parent(AST_Scope).get_defun_scope();
-    find_loop_scope_try();
+    const nearest_scope = compressor.find_scope();
+    const defun_scope = nearest_scope.get_defun_scope();
+    const { in_loop, in_try } = find_loop_scope_try();
+
     var CHANGED, max_iter = 10;
     do {
         CHANGED = false;
@@ -231,19 +232,20 @@ export function tighten_body(statements, compressor) {
     } while (CHANGED && max_iter-- > 0);
 
     function find_loop_scope_try() {
-        var node = compressor.self(), level = 0;
+        var node = compressor.self(), level = 0, in_loop = false, in_try = false;
         do {
             if (node instanceof AST_Catch || node instanceof AST_Finally) {
                 level++;
             } else if (node instanceof AST_IterationStatement) {
                 in_loop = true;
             } else if (node instanceof AST_Scope) {
-                scope = node;
                 break;
             } else if (node instanceof AST_Try) {
                 in_try = true;
             }
         } while (node = compressor.parent(level++));
+
+        return { in_loop, in_try };
     }
 
     // Search from right to left for assignment-like expressions:
@@ -255,7 +257,7 @@ export function tighten_body(statements, compressor) {
     // Will not attempt to collapse assignments into or past code blocks
     // which are not sequentially executed, e.g. loops and conditionals.
     function collapse(statements, compressor) {
-        if (scope.pinned())
+        if (nearest_scope.pinned() || defun_scope.pinned())
             return statements;
         var args;
         var candidates = [];
@@ -319,10 +321,11 @@ export function tighten_body(statements, compressor) {
                 stop_if_hit = parent;
             }
             // Replace variable with assignment when found
-            if (can_replace
+            if (
+                can_replace
                 && !(node instanceof AST_SymbolDeclaration)
                 && lhs.equivalent_to(node)
-                && !shadows(node.scope, lvalues)
+                && !shadows(scanner.find_scope() || nearest_scope, lvalues)
             ) {
                 if (stop_if_hit) {
                     abort = true;
@@ -527,9 +530,9 @@ export function tighten_body(statements, compressor) {
                     return true;
                 if (node instanceof AST_SymbolRef && (fn.variables.has(node.name) || redefined_within_scope(node.definition(), fn))) {
                     var s = node.definition().scope;
-                    if (s !== scope)
+                    if (s !== defun_scope)
                         while (s = s.parent_scope) {
-                            if (s === scope)
+                            if (s === defun_scope)
                                 return true;
                         }
                     return found = true;
@@ -851,7 +854,7 @@ export function tighten_body(statements, compressor) {
             while (lhs instanceof AST_PropAccess)
                 lhs = lhs.expression;
             return lhs instanceof AST_SymbolRef
-                && lhs.definition().scope === scope
+                && lhs.definition().scope.get_defun_scope() === defun_scope
                 && !(in_loop
                     && (lvalues.has(lhs.name)
                         || candidate instanceof AST_Unary
@@ -886,15 +889,11 @@ export function tighten_body(statements, compressor) {
             var def = sym.definition();
             if (def.orig.length == 1 && def.orig[0] instanceof AST_SymbolDefun)
                 return false;
-            if (def.scope.get_defun_scope() !== scope)
+            if (def.scope.get_defun_scope() !== defun_scope)
                 return true;
-            return !def.references.every((ref) => {
-                var s = ref.scope.get_defun_scope();
-                // "block" scope within AST_Catch
-                if (s.TYPE == "Scope")
-                    s = s.parent_scope;
-                return s === scope;
-            });
+            return def.references.some((ref) =>
+                ref.scope.get_defun_scope() !== defun_scope
+            );
         }
 
         function side_effects_external(node, lhs) {
@@ -910,18 +909,20 @@ export function tighten_body(statements, compressor) {
                 if (node instanceof AST_Sub)
                     return side_effects_external(node.expression, true);
                 if (node instanceof AST_SymbolRef)
-                    return node.definition().scope !== scope;
+                    return node.definition().scope.get_defun_scope() !== defun_scope;
             }
             return false;
         }
 
-        function shadows(newScope, lvalues) {
-            for (const {def} of lvalues.values()) {
-                let current = newScope;
-                while (current && current !== def.scope) {
-                    let nested_def = current.variables.get(def.name);
-                    if (nested_def && nested_def !== def) return true;
-                    current = current.parent_scope;
+        /**
+         * Will any of the pulled-in lvalues shadow a variable in newScope or parents?
+         * similar to scope_encloses_variables_in_this_scope */
+        function shadows(my_scope, lvalues) {
+            for (const { def } of lvalues.values()) {
+                const looked_up = my_scope.find_variable(def.name);
+                if (looked_up) {
+                    if (looked_up === def) continue;
+                    return true;
                 }
             }
             return false;
@@ -1343,7 +1344,7 @@ export function tighten_body(statements, compressor) {
                 break;
             if (def.name.name != sym.name)
                 break;
-            if (!node.right.is_constant_expression(scope))
+            if (!node.right.is_constant_expression(nearest_scope))
                 break;
             var prop = node.left.property;
             if (prop instanceof AST_Node) {

package/lib/mozilla-ast.js

@@ -113,6 +113,7 @@ import {
     AST_PrivateGetter,
     AST_PrivateMethod,
     AST_PrivateSetter,
+    AST_PrivateIn,
     AST_PropAccess,
     AST_RegExp,
     AST_Return,
@@ -128,6 +129,7 @@ import {
     AST_SymbolCatch,
     AST_SymbolClass,
     AST_SymbolClassProperty,
+    AST_SymbolPrivateProperty,
     AST_SymbolConst,
     AST_SymbolDefClass,
     AST_SymbolDefun,
@@ -432,7 +434,9 @@ import { is_basic_identifier_string } from "./parse.js";
             if (M.computed) {
                 key = from_moz(M.key);
             } else {
-                if (M.key.type !== "Identifier") throw new Error("Non-Identifier key in PropertyDefinition");
+                if (M.key.type !== "Identifier" && M.key.type !== "PrivateIdentifier") {
+                    throw new Error("Non-Identifier key in PropertyDefinition");
+                }
                 key = from_moz(M.key);
             }
 
@@ -867,6 +871,18 @@ import { is_basic_identifier_string } from "./parse.js";
         },
 
         BinaryExpression: function(M) {
+            if (M.left.type === "PrivateIdentifier") {
+                return new AST_PrivateIn({
+                    start: my_start_token(M),
+                    end: my_end_token(M),
+                    key: new AST_SymbolPrivateProperty({
+                        start: my_start_token(M.left),
+                        end: my_end_token(M.left),
+                        name: M.left.name
+                    }),
+                    value: from_moz(M.right),
+                });
+            }
             return new AST_Binary({
                 start: my_start_token(M),
                 end: my_end_token(M),
@@ -1451,6 +1467,15 @@ import { is_basic_identifier_string } from "./parse.js";
         };
     });
 
+    def_to_moz(AST_PrivateIn, function To_Moz_BinaryExpression_PrivateIn(M) {
+        return {
+            type: "BinaryExpression",
+            left: { type: "PrivateIdentifier", name: M.key.name },
+            operator: "in",
+            right: to_moz(M.value),
+        };
+    });
+
     def_to_moz(AST_Array, function To_Moz_ArrayExpression(M) {
         return {
             type: "ArrayExpression",

package/lib/output.js

@@ -74,7 +74,9 @@ import {
     AST_ConciseMethod,
     AST_PrivateGetter,
     AST_PrivateMethod,
+    AST_SymbolPrivateProperty,
     AST_PrivateSetter,
+    AST_PrivateIn,
     AST_Conditional,
     AST_Const,
     AST_Constant,
@@ -1795,7 +1797,10 @@ function OutputStream(options) {
                 if (node instanceof AST_Scope && !(node instanceof AST_Arrow)) {
                     return true;
                 }
-                if (node instanceof AST_Binary && node.operator == "in") {
+                if (
+                    node instanceof AST_Binary && node.operator == "in"
+                    || node instanceof AST_PrivateIn
+                ) {
                     return walk_abort;  // makes walk() return true
                 }
             });
@@ -2184,6 +2189,16 @@ function OutputStream(options) {
         }
         self._print_getter_setter(type, true, output);
     });
+    DEFPRINT(AST_PrivateIn, function(self, output) {
+        self.key.print(output);
+        output.space();
+        output.print("in");
+        output.space();
+        self.value.print(output);
+    });
+    DEFPRINT(AST_SymbolPrivateProperty, function(self, output) {
+        output.print("#" + self.name);
+    });
     DEFPRINT(AST_ConciseMethod, function(self, output) {
         var type;
         if (self.is_generator && self.async) {

package/lib/parse.js

@@ -69,6 +69,7 @@ import {
     AST_ClassProperty,
     AST_ClassStaticBlock,
     AST_ConciseMethod,
+    AST_PrivateIn,
     AST_PrivateGetter,
     AST_PrivateMethod,
     AST_PrivateSetter,
@@ -145,6 +146,7 @@ import {
     AST_TemplateSegment,
     AST_TemplateString,
     AST_This,
+    AST_SymbolPrivateProperty,
     AST_Throw,
     AST_Token,
     AST_Toplevel,
@@ -1041,7 +1043,7 @@ var PRECEDENCE = (function(a, ret) {
     {}
 );
 
-var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "big_int", "string", "regexp", "name" ]);
+var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "big_int", "string", "regexp", "name"]);
 
 /* -----[ Parser ]----- */
 
@@ -1213,6 +1215,10 @@ function parse($TEXT, options) {
             return simple_statement();
 
           case "name":
+          case "privatename":
+            if(is("privatename") && !S.in_class)
+                croak("Private field must be used in an enclosing class");
+
             if (S.token.value == "async" && is_token(peek(), "keyword", "function")) {
                 next();
                 next();
@@ -2357,6 +2363,29 @@ function parse($TEXT, options) {
         if (is("template_head")) {
             return subscripts(template_string(), allow_calls);
         }
+        if (is("privatename")) {
+            if(!S.in_class) {
+                croak("Private field must be used in an enclosing class");
+            }
+
+            const start = S.token;
+            const key = new AST_SymbolPrivateProperty({
+                start,
+                name: start.value,
+                end: start
+            });
+            next();
+            expect_token("operator", "in");
+
+            const private_in = new AST_PrivateIn({
+                start,
+                key,
+                value: subscripts(as_atom_node(), allow_calls),
+                end: prev()
+            });
+
+            return subscripts(private_in, allow_calls);
+        }
         if (ATOMIC_START_TOKEN.has(S.token.type)) {
             return subscripts(as_atom_node(), allow_calls);
         }
@@ -2442,7 +2471,9 @@ function parse($TEXT, options) {
                 }));
                 continue;
             }
-
+            if(is("privatename")) {
+                croak("private fields are not allowed in an object");
+            }
             var name = as_property_name();
             var value;
 
@@ -2516,7 +2547,9 @@ function parse($TEXT, options) {
         }
 
         expect("{");
-
+        // mark in class feild,
+        const save_in_class = S.in_class;
+        S.in_class = true;
         while (is("punc", ";")) { next(); }  // Leading semicolons are okay in class bodies.
         while (!is("punc", "}")) {
             start = S.token;
@@ -2525,6 +2558,8 @@ function parse($TEXT, options) {
             a.push(method);
             while (is("punc", ";")) { next(); }
         }
+        // mark in class feild,
+        S.in_class = save_in_class;
 
         S.input.pop_directives_stack();
 
@@ -3031,6 +3066,8 @@ function parse($TEXT, options) {
         var start = expr.start;
         if (is("punc", ".")) {
             next();
+            if(is("privatename") && !S.in_class) 
+                croak("Private field must be used in an enclosing class");
             const AST_DotVariant = is("privatename") ? AST_DotHash : AST_Dot;
             return subscripts(new AST_DotVariant({
                 start      : start,
@@ -3084,6 +3121,8 @@ function parse($TEXT, options) {
 
                 chain_contents = subscripts(call, true, true);
             } else if (is("name") || is("privatename")) {
+                if(is("privatename") && !S.in_class) 
+                    croak("Private field must be used in an enclosing class");
                 const AST_DotVariant = is("privatename") ? AST_DotHash : AST_Dot;
                 chain_contents = subscripts(new AST_DotVariant({
                     start,
@@ -3129,7 +3168,6 @@ function parse($TEXT, options) {
                 end: prev()
             }), allow_calls);
         }
-
         return expr;
     };
 

package/lib/propmangle.js

@@ -61,6 +61,7 @@ import {
     AST_PrivateMethod,
     AST_PrivateGetter,
     AST_PrivateSetter,
+    AST_PrivateIn,
     AST_Sequence,
     AST_String,
     AST_Sub,
@@ -153,6 +154,7 @@ function mangle_private_properties(ast, options) {
             || node instanceof AST_PrivateMethod
             || node instanceof AST_PrivateGetter
             || node instanceof AST_PrivateSetter
+            || node instanceof AST_PrivateIn
         ) {
             node.key.name = mangle_private(node.key.name);
         } else if (node instanceof AST_DotHash) {

package/lib/scope.js

@@ -104,7 +104,8 @@ import {
     AST_VarDef,
     AST_With,
     TreeWalker,
-    walk
+    walk,
+    walk_abort
 } from "./ast.js";
 import {
     ALL_RESERVED_WORDS,
@@ -418,7 +419,7 @@ AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = null,
                 sym = toplevel.def_global(node);
                 if (node instanceof AST_SymbolExport) sym.export = MASK_EXPORT_DONT_MANGLE;
             } else if (sym.scope instanceof AST_Lambda && name == "arguments") {
-                sym.scope.uses_arguments = true;
+                sym.scope.get_defun_scope().uses_arguments = true;
             }
             node.thedef = sym;
             node.reference();
@@ -520,7 +521,25 @@ AST_Scope.DEFMETHOD("add_child_scope", function (scope) {
 
     scope.parent_scope = this;
 
-    // TODO uses_with, uses_eval, etc
+    // Propagate to this.uses_arguments from arrow functions
+    if ((scope instanceof AST_Arrow) && !this.uses_arguments) {
+        this.uses_arguments = walk(scope, node => {
+            if (
+                node instanceof AST_SymbolRef
+                && node.scope instanceof AST_Lambda
+                && node.name === "arguments"
+            ) {
+                return walk_abort;
+            }
+
+            if (node instanceof AST_Lambda && !(node instanceof AST_Arrow)) {
+                return true;
+            }
+        });
+    }
+
+    this.uses_with = this.uses_with || scope.uses_with;
+    this.uses_eval = this.uses_eval || scope.uses_eval;
 
     const scope_ancestry = (() => {
         const ancestry = [];
@@ -756,7 +775,10 @@ AST_Symbol.DEFMETHOD("global", function() {
     return this.thedef.global;
 });
 
-AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
+/**
+ * Format the mangler options (if any) into their appropriate types
+ */
+export function format_mangler_options(options) {
     options = defaults(options, {
         eval        : false,
         nth_identifier : base54,
@@ -777,10 +799,10 @@ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
     // Never mangle arguments
     options.reserved.add("arguments");
     return options;
-});
+}
 
 AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
-    options = this._default_mangler_options(options);
+    options = format_mangler_options(options);
     var nth_identifier = options.nth_identifier;
 
     // We only need to mangle declaration nodes.  Special logic wired
@@ -904,7 +926,7 @@ AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) {
 });
 
 AST_Toplevel.DEFMETHOD("expand_names", function(options) {
-    options = this._default_mangler_options(options);
+    options = format_mangler_options(options);
     var nth_identifier = options.nth_identifier;
     if (nth_identifier.reset && nth_identifier.sort) {
         nth_identifier.reset();
@@ -947,7 +969,7 @@ AST_Sequence.DEFMETHOD("tail_node", function() {
 });
 
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) {
-    options = this._default_mangler_options(options);
+    options = format_mangler_options(options);
     var nth_identifier = options.nth_identifier;
     if (!nth_identifier.reset || !nth_identifier.consider || !nth_identifier.sort) {
         // If the identifier mangler is invariant, skip computing character frequency.

package/lib/size.js

@@ -53,6 +53,7 @@ import {
     AST_PrivateGetter,
     AST_PrivateMethod,
     AST_PrivateSetter,
+    AST_PrivateIn,
     AST_RegExp,
     AST_Return,
     AST_Sequence,
@@ -395,6 +396,10 @@ AST_PrivateGetter.prototype._size = AST_PrivateSetter.prototype._size = function
     return AST_ConciseMethod.prototype._size.call(this) + 4;
 };
 
+AST_PrivateIn.prototype._size = function () {
+    return 5; // "#", and " in "
+};
+
 AST_Class.prototype._size = function () {
     return (
         (this.name ? 8 : 7)
@@ -420,9 +425,11 @@ AST_ClassPrivateProperty.prototype._size = function () {
 };
 
 AST_Symbol.prototype._size = function () {
-    return !mangle_options || this.definition().unmangleable(mangle_options)
-        ? this.name.length
-        : 1;
+    if (!(mangle_options && this.thedef && !this.thedef.unmangleable(mangle_options))) {
+        return this.name.length;
+    } else {
+        return 1;
+    }
 };
 
 // TODO take propmangle into account
@@ -431,11 +438,7 @@ AST_SymbolClassProperty.prototype._size = function () {
 };
 
 AST_SymbolRef.prototype._size = AST_SymbolDeclaration.prototype._size = function () {
-    const { name, thedef } = this;
-
-    if (thedef && thedef.global) return name.length;
-
-    if (name === "arguments") return 9;
+    if (this.name === "arguments") return 9;
 
     return AST_Symbol.prototype._size.call(this);
 };

package/lib/transform.js

@@ -47,6 +47,7 @@ import {
     AST_Array,
     AST_Await,
     AST_Binary,
+    AST_PrivateIn,
     AST_Block,
     AST_Call,
     AST_Case,
@@ -259,6 +260,11 @@ def_transform(AST_Binary, function(self, tw) {
     self.right = self.right.transform(tw);
 });
 
+def_transform(AST_PrivateIn, function(self, tw) {
+    self.key = self.key.transform(tw);
+    self.value = self.value.transform(tw);
+});
+
 def_transform(AST_Conditional, function(self, tw) {
     self.condition = self.condition.transform(tw);
     self.consequent = self.consequent.transform(tw);

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.15.1",
+  "version": "5.16.1",
   "engines": {
     "node": ">=10"
   },