terser 5.7.2 → 5.8.0

package/lib/propmangle.js

@@ -59,6 +59,8 @@ import {
     AST_ObjectKeyVal,
     AST_ObjectProperty,
     AST_PrivateMethod,
+    AST_PrivateGetter,
+    AST_PrivateSetter,
     AST_Sequence,
     AST_String,
     AST_Sub,
@@ -140,28 +142,59 @@ function addStrings(node, add) {
     }));
 }
 
+function mangle_private_properties(ast, options) {
+    var cprivate = -1;
+    var private_cache = new Map();
+    var nth_identifier = options.nth_identifier || base54;
+
+    ast =  ast.transform(new TreeTransformer(function(node) {
+        if (
+            node instanceof AST_ClassPrivateProperty
+            || node instanceof AST_PrivateMethod
+            || node instanceof AST_PrivateGetter
+            || node instanceof AST_PrivateSetter
+        ) {
+            node.key.name = mangle_private(node.key.name);
+        } else if (node instanceof AST_DotHash) {
+            node.property = mangle_private(node.property);
+        }
+    }));
+    return ast;
+
+    function mangle_private(name) {
+        let mangled = private_cache.get(name);
+        if (!mangled) {
+            mangled = nth_identifier.get(++cprivate);
+            private_cache.set(name, mangled);
+        }
+
+        return mangled;
+    }
+}
+
 function mangle_properties(ast, options) {
     options = defaults(options, {
         builtins: false,
         cache: null,
         debug: false,
         keep_quoted: false,
+        nth_identifier: base54,
         only_cache: false,
         regex: null,
         reserved: null,
         undeclared: false,
     }, true);
 
+    var nth_identifier = options.nth_identifier;
+
     var reserved_option = options.reserved;
     if (!Array.isArray(reserved_option)) reserved_option = [reserved_option];
     var reserved = new Set(reserved_option);
     if (!options.builtins) find_builtins(reserved);
 
     var cname = -1;
-    var cprivate = -1;
 
     var cache;
-    var private_cache = new Map();
     if (options.cache) {
         cache = options.cache.props;
         cache.forEach(function(mangled_name) {
@@ -184,27 +217,26 @@ function mangle_properties(ast, options) {
 
     var names_to_mangle = new Set();
     var unmangleable = new Set();
-    var private_properties = new Set();
 
-    var keep_quoted_strict = options.keep_quoted === "strict";
+    var keep_quoted = !!options.keep_quoted;
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node) {
         if (
             node instanceof AST_ClassPrivateProperty
             || node instanceof AST_PrivateMethod
+            || node instanceof AST_PrivateGetter
+            || node instanceof AST_PrivateSetter
+            || node instanceof AST_DotHash
         ) {
-            private_properties.add(node.key.name);
-        } else if (node instanceof AST_DotHash) {
-            private_properties.add(node.property);
+            // handled by mangle_private_properties
         } else if (node instanceof AST_ObjectKeyVal) {
-            if (typeof node.key == "string" &&
-                (!keep_quoted_strict || !node.quote)) {
+            if (typeof node.key == "string" && (!keep_quoted || !node.quote)) {
                 add(node.key);
             }
         } else if (node instanceof AST_ObjectProperty) {
             // setter or getter, since KeyVal is handled above
-            if (!keep_quoted_strict || !node.key.end.quote) {
+            if (!keep_quoted || !node.quote) {
                 add(node.key.name);
             }
         } else if (node instanceof AST_Dot) {
@@ -217,11 +249,11 @@ function mangle_properties(ast, options) {
                 declared = !(root.thedef && root.thedef.undeclared);
             }
             if (declared &&
-                (!keep_quoted_strict || !node.quote)) {
+                (!keep_quoted || !node.quote)) {
                 add(node.property);
             }
         } else if (node instanceof AST_Sub) {
-            if (!keep_quoted_strict) {
+            if (!keep_quoted) {
                 addStrings(node.property, add);
             }
         } else if (node instanceof AST_Call
@@ -237,25 +269,25 @@ function mangle_properties(ast, options) {
         if (
             node instanceof AST_ClassPrivateProperty
             || node instanceof AST_PrivateMethod
+            || node instanceof AST_PrivateGetter
+            || node instanceof AST_PrivateSetter
+            || node instanceof AST_DotHash
         ) {
-            node.key.name = mangle_private(node.key.name);
-        } else if (node instanceof AST_DotHash) {
-            node.property = mangle_private(node.property);
+            // handled by mangle_private_properties
         } else if (node instanceof AST_ObjectKeyVal) {
-            if (typeof node.key == "string" &&
-                (!keep_quoted_strict || !node.quote)) {
+            if (typeof node.key == "string" && (!keep_quoted || !node.quote)) {
                 node.key = mangle(node.key);
             }
         } else if (node instanceof AST_ObjectProperty) {
             // setter, getter, method or class field
-            if (!keep_quoted_strict || !node.key.end.quote) {
+            if (!keep_quoted || !node.quote) {
                 node.key.name = mangle(node.key.name);
             }
         } else if (node instanceof AST_Dot) {
-            if (!keep_quoted_strict || !node.quote) {
+            if (!keep_quoted || !node.quote) {
                 node.property = mangle(node.property);
             }
-        } else if (!options.keep_quoted && node instanceof AST_Sub) {
+        } else if (!keep_quoted && node instanceof AST_Sub) {
             node.property = mangleStrings(node.property);
         } else if (node instanceof AST_Call
             && node.expression.print_to_string() == "Object.defineProperty") {
@@ -312,7 +344,7 @@ function mangle_properties(ast, options) {
             // either debug mode is off, or it is on and we could not use the mangled name
             if (!mangled) {
                 do {
-                    mangled = base54(++cname);
+                    mangled = nth_identifier.get(++cname);
                 } while (!can_mangle(mangled));
             }
 
@@ -321,16 +353,6 @@ function mangle_properties(ast, options) {
         return mangled;
     }
 
-    function mangle_private(name) {
-        let mangled = private_cache.get(name);
-        if (!mangled) {
-            mangled = base54(++cprivate);
-            private_cache.set(name, mangled);
-        }
-
-        return mangled;
-    }
-
     function mangleStrings(node) {
         return node.transform(new TreeTransformer(function(node) {
             if (node instanceof AST_Sequence) {
@@ -350,4 +372,5 @@ function mangle_properties(ast, options) {
 export {
     reserve_quoted_keys,
     mangle_properties,
+    mangle_private_properties,
 };

package/lib/scope.js

@@ -667,8 +667,9 @@ AST_Scope.DEFMETHOD("def_variable", function(symbol, init) {
 
 function next_mangled(scope, options) {
     var ext = scope.enclosed;
+    var nth_identifier = options.nth_identifier;
     out: while (true) {
-        var m = base54(++scope.cname);
+        var m = nth_identifier.get(++scope.cname);
         if (ALL_RESERVED_WORDS.has(m)) continue; // skip over "do"
 
         // https://github.com/mishoo/UglifyJS2/issues/242 -- do not
@@ -744,6 +745,7 @@ AST_Symbol.DEFMETHOD("global", function() {
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
     options = defaults(options, {
         eval        : false,
+        nth_identifier : base54,
         ie8         : false,
         keep_classnames: false,
         keep_fnames : false,
@@ -765,6 +767,7 @@ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
 
 AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     options = this._default_mangler_options(options);
+    var nth_identifier = options.nth_identifier;
 
     // We only need to mangle declaration nodes.  Special logic wired
     // into the code generator will display the mangled name if it's
@@ -816,7 +819,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
         if (node instanceof AST_Label) {
             let name;
             do {
-                name = base54(++lname);
+                name = nth_identifier.get(++lname);
             } while (ALL_RESERVED_WORDS.has(name));
             node.mangled_name = name;
             return true;
@@ -878,9 +881,12 @@ AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) {
 });
 
 AST_Toplevel.DEFMETHOD("expand_names", function(options) {
-    base54.reset();
-    base54.sort();
     options = this._default_mangler_options(options);
+    var nth_identifier = options.nth_identifier;
+    if (nth_identifier.reset && nth_identifier.sort) {
+        nth_identifier.reset();
+        nth_identifier.sort();
+    }
     var avoid = this.find_colliding_names(options);
     var cname = 0;
     this.globals.forEach(rename);
@@ -892,7 +898,7 @@ AST_Toplevel.DEFMETHOD("expand_names", function(options) {
     function next_name() {
         var name;
         do {
-            name = base54(cname++);
+            name = nth_identifier.get(cname++);
         } while (avoid.has(name) || ALL_RESERVED_WORDS.has(name));
         return name;
     }
@@ -919,30 +925,37 @@ AST_Sequence.DEFMETHOD("tail_node", function() {
 
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) {
     options = this._default_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.
+        return;
+    }
+    nth_identifier.reset();
+
     try {
         AST_Node.prototype.print = function(stream, force_parens) {
             this._print(stream, force_parens);
             if (this instanceof AST_Symbol && !this.unmangleable(options)) {
-                base54.consider(this.name, -1);
+                nth_identifier.consider(this.name, -1);
             } else if (options.properties) {
                 if (this instanceof AST_DotHash) {
-                    base54.consider("#" + this.property, -1);
+                    nth_identifier.consider("#" + this.property, -1);
                 } else if (this instanceof AST_Dot) {
-                    base54.consider(this.property, -1);
+                    nth_identifier.consider(this.property, -1);
                 } else if (this instanceof AST_Sub) {
                     skip_string(this.property);
                 }
             }
         };
-        base54.consider(this.print_to_string(), 1);
+        nth_identifier.consider(this.print_to_string(), 1);
     } finally {
         AST_Node.prototype.print = AST_Node.prototype._print;
     }
-    base54.sort();
+    nth_identifier.sort();
 
     function skip_string(node) {
         if (node instanceof AST_String) {
-            base54.consider(node.value, -1);
+            nth_identifier.consider(node.value, -1);
         } else if (node instanceof AST_Conditional) {
             skip_string(node.consequent);
             skip_string(node.alternative);
@@ -966,19 +979,20 @@ const base54 = (() => {
             frequency.set(ch, 0);
         });
     }
-    base54.consider = function(str, delta) {
+    function consider(str, delta) {
         for (var i = str.length; --i >= 0;) {
             frequency.set(str[i], frequency.get(str[i]) + delta);
         }
-    };
+    }
     function compare(a, b) {
         return frequency.get(b) - frequency.get(a);
     }
-    base54.sort = function() {
+    function sort() {
         chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));
-    };
-    base54.reset = reset;
+    }
+    // Ensure this is in a usable initial state.
     reset();
+    sort();
     function base54(num) {
         var ret = "", base = 54;
         num++;
@@ -990,7 +1004,13 @@ const base54 = (() => {
         } while (num > 0);
         return ret;
     }
-    return base54;
+
+    return {
+        get: base54,
+        consider,
+        reset,
+        sort
+    };
 })();
 
 export {

package/lib/transform.js

@@ -57,7 +57,6 @@ import {
     AST_Definitions,
     AST_Destructuring,
     AST_Do,
-    AST_Dot,
     AST_Exit,
     AST_Expansion,
     AST_Export,
@@ -74,6 +73,7 @@ import {
     AST_Object,
     AST_ObjectProperty,
     AST_PrefixedTemplateString,
+    AST_PropAccess,
     AST_Sequence,
     AST_SimpleStatement,
     AST_Sub,
@@ -228,7 +228,7 @@ def_transform(AST_Sequence, function(self, tw) {
         : [new AST_Number({ value: 0 })];
 });
 
-def_transform(AST_Dot, function(self, tw) {
+def_transform(AST_PropAccess, function(self, tw) {
     self.expression = self.expression.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.7.2",
+  "version": "5.8.0",
   "engines": {
     "node": ">=10"
   },
@@ -45,19 +45,19 @@
   "dependencies": {
     "commander": "^2.20.0",
     "source-map": "~0.7.2",
-    "source-map-support": "~0.5.19"
+    "source-map-support": "~0.5.20"
   },
   "devDependencies": {
-    "@ls-lint/ls-lint": "^1.9.2",
-    "acorn": "^8.0.5",
-    "astring": "^1.6.2",
-    "eslint": "^7.19.0",
-    "eslump": "^2.0.0",
+    "@ls-lint/ls-lint": "^1.10.0",
+    "acorn": "^8.5.0",
+    "astring": "^1.7.5",
+    "eslint": "^7.32.0",
+    "eslump": "^3.0.0",
     "esm": "^3.2.25",
-    "mocha": "^8.2.1",
+    "mocha": "^9.1.1",
     "pre-commit": "^1.2.2",
     "rimraf": "^3.0.2",
-    "rollup": "2.38.4",
+    "rollup": "2.56.3",
     "semver": "^7.3.4"
   },
   "scripts": {

package/tools/terser.d.ts

@@ -80,16 +80,52 @@ export interface MangleOptions {
     keep_classnames?: boolean | RegExp;
     keep_fnames?: boolean | RegExp;
     module?: boolean;
+    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler;
     properties?: boolean | ManglePropertiesOptions;
     reserved?: string[];
     safari10?: boolean;
     toplevel?: boolean;
 }
 
+/**
+ * An identifier mangler for which the output is invariant with respect to the source code.
+ */
+export interface SimpleIdentifierMangler {
+    /**
+     * Obtains the nth most favored (usually shortest) identifier to rename a variable to.
+     * The mangler will increment n and retry until the return value is not in use in scope, and is not a reserved word.
+     * This function is expected to be stable; Evaluating get(n) === get(n) should always return true.
+     * @param n The ordinal of the identifier.
+     */
+    get(n: number): string;
+}
+
+/**
+ * An identifier mangler that leverages character frequency analysis to determine identifier precedence.
+ */
+export interface WeightedIdentifierMangler extends SimpleIdentifierMangler {
+    /**
+     * Modifies the internal weighting of the input characters by the specified delta.
+     * Will be invoked on the entire printed AST, and then deduct mangleable identifiers.
+     * @param chars The characters to modify the weighting of.
+     * @param delta The numeric weight to add to the characters.
+     */
+    consider(chars: string, delta: number): number;
+    /**
+     * Resets character weights.
+     */
+    reset(): void;
+    /**
+     * Sorts identifiers by character frequency, in preparation for calls to get(n).
+     */
+    sort(): void;
+}
+
 export interface ManglePropertiesOptions {
     builtins?: boolean;
     debug?: boolean;
     keep_quoted?: boolean | 'strict';
+    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler;
     regex?: RegExp | string;
     reserved?: string[];
 }