terser 5.17.7 → 5.18.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v7.18.1
+ - Fix major performance issue caused by hoisted defuns' scopes bugfix.
+
+## v7.18.0
+ - Add new `/*@__MANGLE_PROP__*/` annotation, to mark properties that should be mangled.
+
 ## v5.17.7
  - Update some dependencies
  - Add consistent sorting for `v` RegExp flag

package/README.md

@@ -52,7 +52,9 @@ From NPM for programmatic use:
 
 <!-- CLI_USAGE:START -->
 
-    terser [input files] [options]
+```
+terser [input files] [options]
+```
 
 Terser can take multiple input files.  It's recommended that you pass the
 input files first, then pass the options.  Terser will parse input files
@@ -106,6 +108,7 @@ a double dash to prevent input files being used as option arguments:
                                                `strict` disables quoted properties
                                                being automatically reserved.
                                 `regex`  Only mangle matched property names.
+                                `only_annotated` Only mangle properties defined with /*@__MANGLE_PROP__*/.
                                 `reserved`  List of names that should not be mangled.
     -f, --format [options]      Specify format options.
                                 `preamble`  Preamble to prepend to the output. You
@@ -673,6 +676,10 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 If you happen to need the source map as a raw object, set `sourceMap.asObject` to `true`.
 
+<!-- API_REFERENCE:END -->
+
+<!-- OPTIONS:START -->
+
 ## Parse options
 
 - `bare_returns` (default `false`) -- support top level `return` statements
@@ -1061,8 +1068,14 @@ as "output options".
   function expressions that are passed as arguments, in parenthesis. See
   [OptimizeJS](https://github.com/nolanlawson/optimize-js) for more details.
 
+
+<!-- OPTIONS:END -->
+
+
 # Miscellaneous
 
+<!-- MISCELLANEOUS:START -->
+
 ### Keeping copyright notices or other comments
 
 You can pass `--comments` to retain certain comments in the output.  By
@@ -1189,6 +1202,7 @@ Annotations in Terser are a way to tell it to treat a certain function call diff
  * `/*@__NOINLINE__*/` - Makes sure the called function is not inlined into the call site.
  * `/*@__PURE__*/` - Marks a function call as pure. That means, it can safely be dropped.
  * `/*@__KEY__*/` - Marks a string literal as a property to also mangle it when mangling properties.
+ * `/*@__MANGLE_PROP__*/` - Opts-in an object property (or class field) for mangling, when the property mangler is enabled.
 
 You can use either a `@` sign at the start, or a `#`.
 
@@ -1326,19 +1340,27 @@ $ rm -rf node_modules yarn.lock
 $ yarn
 ```
 
-<!-- API_REFERENCE:END -->
+<!-- MISCELLANEOUS:END -->
 
 # Reporting issues
 
-In the terser CLI we use [source-map-support](https://npmjs.com/source-map-support) to produce good error stacks. In your own app, you're expected to enable source-map-support (read their docs) to have nice stack traces that will help you write good issues.
+<!-- REPORTING_ISSUES:START -->
+
+## A minimal, reproducible example
+
+You're expected to provide a [minimal reproducible example] of input code that will demonstrate your issue.
+
+To get to this example, you can remove bits of your code and stop if your issue ceases to reproduce.
 
 ## Obtaining the source code given to Terser
 
-Because users often don't control the call to `await minify()` or its arguments, Terser provides a `TERSER_DEBUG_DIR` environment variable to make terser output some debug logs. If you're using a bundler or a project that includes a bundler and are not sure what went wrong with your code, pass that variable like so:
+Because users often don't control the call to `await minify()` or its arguments, Terser provides a `TERSER_DEBUG_DIR` environment variable to make terser output some debug logs.
 
-```
-$ TERSER_DEBUG_DIR=/path/to/logs command-that-uses-terser
-$ ls /path/to/logs
+These logs will contain the input code and options of each `minify()` call.
+
+```bash
+TERSER_DEBUG_DIR=/tmp/terser-log-dir command-that-uses-terser
+ls /tmp/terser-log-dir
 terser-debug-123456.log
 ```
 
@@ -1348,6 +1370,12 @@ If you're not sure how to set an environment variable on your shell (the above e
 > npx cross-env TERSER_DEBUG_DIR=/path/to/logs command-that-uses-terser
 ```
 
+## Stack traces
+
+In the terser CLI we use [source-map-support](https://npmjs.com/source-map-support) to produce good error stacks. In your own app, you're expected to enable source-map-support (read their docs) to have nice stack traces that will help you write good issues.
+
+<!-- REPORTING_ISSUES:END -->
+
 # README.md Patrons:
 
 *note*: <s>You can support this project on patreon: [link]</s> **The Terser Patreon is shutting down in favor of opencollective**. Check out [PATRONS.md](https://github.com/terser/terser/blob/master/PATRONS.md) for our first-tier patrons.

package/dist/bundle.min.js

@@ -2372,7 +2372,7 @@ function parse($TEXT, options) {
                 value : tok.value,
                 quote : tok.quote
             });
-            annotate(ret);            
+            annotate(ret);
             break;
           case "regexp":
             const [_, source, flags] = tok.value.match(/^\/(.*)\/(\w*)$/);
@@ -2684,13 +2684,14 @@ function parse($TEXT, options) {
             }
 
             // Create property
-            a.push(new AST_ObjectKeyVal({
+            const kv = new AST_ObjectKeyVal({
                 start: start,
                 quote: start.quote,
                 key: name instanceof AST_Node ? name : "" + name,
                 value: value,
                 end: prev()
-            }));
+            });
+            a.push(annotate(kv));
         }
         next();
         return new AST_Object({ properties: a });
@@ -2803,26 +2804,26 @@ function parse($TEXT, options) {
                     : AST_ObjectSetter;
 
                 name = get_symbol_ast(name);
-                return new AccessorClass({
+                return annotate(new AccessorClass({
                     start,
                     static: is_static,
                     key: name,
                     quote: name instanceof AST_SymbolMethod ? property_token.quote : undefined,
                     value: create_accessor(),
                     end: prev()
-                });
+                }));
             } else {
                 const AccessorClass = accessor_type === "get"
                     ? AST_PrivateGetter
                     : AST_PrivateSetter;
 
-                return new AccessorClass({
+                return annotate(new AccessorClass({
                     start,
                     static: is_static,
                     key: get_symbol_ast(name),
                     value: create_accessor(),
                     end: prev(),
-                });
+                }));
             }
         }
 
@@ -2842,7 +2843,7 @@ function parse($TEXT, options) {
                 value       : create_accessor(is_generator, is_async),
                 end         : prev()
             });
-            return node;
+            return annotate(node);
         }
 
         if (is_class) {
@@ -2855,14 +2856,16 @@ function parse($TEXT, options) {
                 : AST_ClassProperty;
             if (is("operator", "=")) {
                 next();
-                return new AST_ClassPropertyVariant({
-                    start,
-                    static: is_static,
-                    quote,
-                    key,
-                    value: expression(false),
-                    end: prev()
-                });
+                return annotate(
+                    new AST_ClassPropertyVariant({
+                        start,
+                        static: is_static,
+                        quote,
+                        key,
+                        value: expression(false),
+                        end: prev()
+                    })
+                );
             } else if (
                 is("name")
                 || is("privatename")
@@ -2870,13 +2873,15 @@ function parse($TEXT, options) {
                 || is("punc", ";")
                 || is("punc", "}")
             ) {
-                return new AST_ClassPropertyVariant({
-                    start,
-                    static: is_static,
-                    quote,
-                    key,
-                    end: prev()
-                });
+                return annotate(
+                    new AST_ClassPropertyVariant({
+                        start,
+                        static: is_static,
+                        quote,
+                        key,
+                        end: prev()
+                    })
+                );
             }
         }
     }
@@ -3239,10 +3244,9 @@ function parse($TEXT, options) {
     }
 
     // Annotate AST_Call, AST_Lambda or AST_New with the special comments
-    function annotate(node) {
-        var start = node.start;
-        var comments = start.comments_before;
-        const comments_outside_parens = outer_comments_before_counts.get(start);
+    function annotate(node, before_token = node.start) {
+        var comments = before_token.comments_before;
+        const comments_outside_parens = outer_comments_before_counts.get(before_token);
         var i = comments_outside_parens != null ? comments_outside_parens : comments.length;
         while (--i >= 0) {
             var comment = comments[i];
@@ -3263,8 +3267,13 @@ function parse($TEXT, options) {
                     set_annotation(node, _KEY);
                     break;
                 }
+                if (/[@#]__MANGLE_PROP__/.test(comment.value)) {
+                    set_annotation(node, _MANGLEPROP);
+                    break;
+                }
             }
         }
+        return node;
     }
 
     var subscripts = function(expr, allow_calls, is_chain) {
@@ -5623,6 +5632,7 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", function AST_Obj
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -5652,6 +5662,7 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", function AST_ObjectKeyVa
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -5713,6 +5724,7 @@ var AST_ObjectSetter = DEFNODE("ObjectSetter", "quote static", function AST_Obje
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -5735,6 +5747,7 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", function AST_Obje
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -5762,6 +5775,7 @@ var AST_ConciseMethod = DEFNODE(
             this.value = props.value;
             this.start = props.start;
             this.end = props.end;
+            this._annotations = props._annotations;
         }
 
         this.flags = 0;
@@ -5884,6 +5898,7 @@ var AST_ClassProperty = DEFNODE("ClassProperty", "static quote", function AST_Cl
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -6787,10 +6802,11 @@ class TreeTransformer extends TreeWalker {
     }
 }
 
-const _PURE     = 0b00000001;
-const _INLINE   = 0b00000010;
-const _NOINLINE = 0b00000100;
-const _KEY      = 0b00001000;
+const _PURE       = 0b00000001;
+const _INLINE     = 0b00000010;
+const _NOINLINE   = 0b00000100;
+const _KEY        = 0b00001000;
+const _MANGLEPROP = 0b00010000;
 
 /***********************************************************************
 
@@ -15918,6 +15934,10 @@ function handle_defined_after_hoist(parent) {
         ) return true;
     });
 
+    const symbols_of_interest = new Set();
+    const defuns_of_interest = new Set();
+    const potential_conflicts = [];
+
     for (const defun of defuns) {
         const fname_def = defun.name.definition();
         const found_self_ref_in_other_defuns = defuns.some(
@@ -15947,35 +15967,77 @@ function handle_defined_after_hoist(parent) {
                 continue;
             }
 
-            // Detect `call_defun(); var used_in_defun = X`
-            // Because `used_in_defun` is not certainly X when it's defined after.
-            let found_defun_ref = false;
-            let found_def_after_defun = false;
-            walk_parent(parent, (node, info) => {
-                if (node === defun) return true;
+            // for the slower checks below this loop
+            potential_conflicts.push({ defun, def, fname_def });
+            symbols_of_interest.add(def.id);
+            symbols_of_interest.add(fname_def.id);
+            defuns_of_interest.add(defun);
+        }
+    }
 
-                // Step 1: find `call_defun()` or other refs to the defun
-                if (
-                    !found_defun_ref
-                    && node.thedef === fname_def
-                    && node instanceof AST_Symbol
-                ) {
-                    found_defun_ref = true;
+    // linearize all symbols, and locate defs that are read after the defun
+    if (potential_conflicts.length) {
+        // All "symbols of interest", that is, defuns or defs, that we found.
+        // These are placed in order so we can check which is after which.
+        const found_symbols = [];
+        // Indices of `found_symbols` which are writes
+        const found_symbol_writes = new Set();
+        // Defun ranges are recorded because we don't care if a function uses the def internally
+        const defun_ranges = new Map();
+
+        let tw;
+        parent.walk((tw = new TreeWalker((node, descend) => {
+            if (node instanceof AST_Defun && defuns_of_interest.has(node)) {
+                const start = found_symbols.length;
+                descend();
+                const end = found_symbols.length;
+
+                defun_ranges.set(node, { start, end });
+                return true;
+            }
+            // if we found a defun on the list, mark IN_DEFUN=id and descend
+
+            if (node instanceof AST_Symbol && node.thedef) {
+                const id = node.definition().id;
+                if (symbols_of_interest.has(id)) {
+                    if (node instanceof AST_SymbolDeclaration || is_lhs(node, tw)) {
+                        found_symbol_writes.add(found_symbols.length);
+                    }
+                    found_symbols.push(id);
                 }
+            }
+        })));
+
+        for (const { def, defun, fname_def } of potential_conflicts) {
+            const defun_range = defun_ranges.get(defun);
+
+            // find the index in `found_symbols`, with some special rules:
+            const find = (sym_id, starting_at = 0, must_be_write = false) => {
+                const index = found_symbols.indexOf(sym_id, starting_at);
 
-                // Step 2: if Step 1 occurred, find a var the defun uses
                 if (
-                    found_defun_ref
-                    && node.thedef === def
-                    && (node instanceof AST_SymbolDeclaration
-                        || is_lhs(node, info))
+                    defun_range
+                    && index >= defun_range.start
+                    && index < defun_range.end
                 ) {
-                    found_def_after_defun = true;
-                    return walk_abort;
+                    return find(sym_id, defun_range.end, must_be_write);
+                } else if (
+                    must_be_write
+                    && index >= 0
+                    && !found_symbol_writes.has(index)
+                ) {
+                    return find(sym_id, index + 1, must_be_write);
+                } else {
+                    return index;
                 }
-            });
+            };
 
-            if (found_def_after_defun) {
+            const read_defun_at = find(fname_def.id);
+            const wrote_def_at = find(def.id, read_defun_at + 1, true);
+
+            const wrote_def_after_reading_defun = read_defun_at != -1 && wrote_def_at != -1 && wrote_def_at > read_defun_at;
+
+            if (wrote_def_after_reading_defun) {
                 def.fixed = false;
             }
         }
@@ -29819,6 +29881,7 @@ function mangle_properties(ast, options) {
         regex: null,
         reserved: null,
         undeclared: false,
+        only_annotated: false,
     }, true);
 
     var nth_identifier = options.nth_identifier;
@@ -29837,6 +29900,7 @@ function mangle_properties(ast, options) {
         cache = new Map();
     }
 
+    var only_annotated = options.only_annotated;
     var regex = options.regex && new RegExp(options.regex);
 
     // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
@@ -29848,6 +29912,7 @@ function mangle_properties(ast, options) {
         debug_name_suffix = (options.debug === true ? "" : options.debug);
     }
 
+    var annotated_names = new Set();
     var names_to_mangle = new Set();
     var unmangleable = new Set();
     // Track each already-mangled name to prevent nth_identifier from generating
@@ -29856,7 +29921,36 @@ function mangle_properties(ast, options) {
 
     var keep_quoted = !!options.keep_quoted;
 
-    // step 1: find candidates to mangle
+    // Step 1: Find all annotated /*@__MANGLEPROP__*/
+    walk(ast, node => {
+        if (
+            node instanceof AST_ClassPrivateProperty
+            || node instanceof AST_PrivateMethod
+            || node instanceof AST_PrivateGetter
+            || node instanceof AST_PrivateSetter
+            || node instanceof AST_DotHash
+        ) ; else if (node instanceof AST_ObjectKeyVal) {
+            if (
+                typeof node.key == "string"
+                && has_annotation(node, _MANGLEPROP)
+                && can_mangle(node.key)
+            ) {
+                annotated_names.add(node.key);
+                clear_annotation(node, _MANGLEPROP);
+            }
+        } else if (node instanceof AST_ObjectProperty) {
+            // setter or getter, since KeyVal is handled above
+            if (
+                has_annotation(node, _MANGLEPROP)
+                && can_mangle(node.key.name)
+            ) {
+                annotated_names.add(node.key.name);
+                clear_annotation(node, _MANGLEPROP);
+            }
+        }
+    });
+
+    // step 2: find candidates to mangle
     ast.walk(new TreeWalker(function(node) {
         if (
             node instanceof AST_ClassPrivateProperty
@@ -29948,15 +30042,19 @@ function mangle_properties(ast, options) {
     }
 
     function should_mangle(name) {
-        if (regex && !regex.test(name)) return false;
+        if (only_annotated && !annotated_names.has(name)) return false;
+        if (regex && !regex.test(name)) {
+            return annotated_names.has(name);
+        }
         if (reserved.has(name)) return false;
         return cache.has(name)
             || names_to_mangle.has(name);
     }
 
     function add(name) {
-        if (can_mangle(name))
+        if (can_mangle(name)) {
             names_to_mangle.add(name);
+        }
 
         if (!should_mangle(name)) {
             unmangleable.add(name);

package/lib/ast.js

@@ -2013,6 +2013,7 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", function AST_Obj
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -2042,6 +2043,7 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", function AST_ObjectKeyVa
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -2103,6 +2105,7 @@ var AST_ObjectSetter = DEFNODE("ObjectSetter", "quote static", function AST_Obje
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -2125,6 +2128,7 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", function AST_Obje
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -2152,6 +2156,7 @@ var AST_ConciseMethod = DEFNODE(
             this.value = props.value;
             this.start = props.start;
             this.end = props.end;
+            this._annotations = props._annotations;
         }
 
         this.flags = 0;
@@ -2274,6 +2279,7 @@ var AST_ClassProperty = DEFNODE("ClassProperty", "static quote", function AST_Cl
         this.value = props.value;
         this.start = props.start;
         this.end = props.end;
+        this._annotations = props._annotations;
     }
 
     this.flags = 0;
@@ -3177,10 +3183,11 @@ class TreeTransformer extends TreeWalker {
     }
 }
 
-const _PURE     = 0b00000001;
-const _INLINE   = 0b00000010;
-const _NOINLINE = 0b00000100;
-const _KEY      = 0b00001000;
+const _PURE       = 0b00000001;
+const _INLINE     = 0b00000010;
+const _NOINLINE   = 0b00000100;
+const _KEY        = 0b00001000;
+const _MANGLEPROP = 0b00010000;
 
 export {
     AST_Accessor,
@@ -3326,4 +3333,5 @@ export {
     _NOINLINE,
     _PURE,
     _KEY,
+    _MANGLEPROP,
 };

package/lib/compress/reduce-vars.js

@@ -93,10 +93,10 @@ import {
     AST_Yield,
 
     walk,
-    walk_parent,
-    walk_abort,
     walk_body,
 
+    TreeWalker,
+
     _INLINE,
     _NOINLINE,
     _PURE
@@ -513,6 +513,10 @@ function handle_defined_after_hoist(parent) {
         ) return true;
     });
 
+    const symbols_of_interest = new Set();
+    const defuns_of_interest = new Set();
+    const potential_conflicts = [];
+
     for (const defun of defuns) {
         const fname_def = defun.name.definition();
         const found_self_ref_in_other_defuns = defuns.some(
@@ -542,35 +546,77 @@ function handle_defined_after_hoist(parent) {
                 continue;
             }
 
-            // Detect `call_defun(); var used_in_defun = X`
-            // Because `used_in_defun` is not certainly X when it's defined after.
-            let found_defun_ref = false;
-            let found_def_after_defun = false;
-            walk_parent(parent, (node, info) => {
-                if (node === defun) return true;
+            // for the slower checks below this loop
+            potential_conflicts.push({ defun, def, fname_def });
+            symbols_of_interest.add(def.id);
+            symbols_of_interest.add(fname_def.id);
+            defuns_of_interest.add(defun);
+        }
+    }
 
-                // Step 1: find `call_defun()` or other refs to the defun
-                if (
-                    !found_defun_ref
-                    && node.thedef === fname_def
-                    && node instanceof AST_Symbol
-                ) {
-                    found_defun_ref = true;
+    // linearize all symbols, and locate defs that are read after the defun
+    if (potential_conflicts.length) {
+        // All "symbols of interest", that is, defuns or defs, that we found.
+        // These are placed in order so we can check which is after which.
+        const found_symbols = [];
+        // Indices of `found_symbols` which are writes
+        const found_symbol_writes = new Set();
+        // Defun ranges are recorded because we don't care if a function uses the def internally
+        const defun_ranges = new Map();
+
+        let tw;
+        parent.walk((tw = new TreeWalker((node, descend) => {
+            if (node instanceof AST_Defun && defuns_of_interest.has(node)) {
+                const start = found_symbols.length;
+                descend();
+                const end = found_symbols.length;
+
+                defun_ranges.set(node, { start, end });
+                return true;
+            }
+            // if we found a defun on the list, mark IN_DEFUN=id and descend
+
+            if (node instanceof AST_Symbol && node.thedef) {
+                const id = node.definition().id;
+                if (symbols_of_interest.has(id)) {
+                    if (node instanceof AST_SymbolDeclaration || is_lhs(node, tw)) {
+                        found_symbol_writes.add(found_symbols.length);
+                    }
+                    found_symbols.push(id);
                 }
+            }
+        })));
+
+        for (const { def, defun, fname_def } of potential_conflicts) {
+            const defun_range = defun_ranges.get(defun);
+
+            // find the index in `found_symbols`, with some special rules:
+            const find = (sym_id, starting_at = 0, must_be_write = false) => {
+                const index = found_symbols.indexOf(sym_id, starting_at);
 
-                // Step 2: if Step 1 occurred, find a var the defun uses
                 if (
-                    found_defun_ref
-                    && node.thedef === def
-                    && (node instanceof AST_SymbolDeclaration
-                        || is_lhs(node, info))
+                    defun_range
+                    && index >= defun_range.start
+                    && index < defun_range.end
                 ) {
-                    found_def_after_defun = true;
-                    return walk_abort;
+                    return find(sym_id, defun_range.end, must_be_write);
+                } else if (
+                    must_be_write
+                    && index >= 0
+                    && !found_symbol_writes.has(index)
+                ) {
+                    return find(sym_id, index + 1, must_be_write);
+                } else {
+                    return index;
                 }
-            });
+            };
+
+            const read_defun_at = find(fname_def.id);
+            const wrote_def_at = find(def.id, read_defun_at + 1, true);
+
+            const wrote_def_after_reading_defun = read_defun_at != -1 && wrote_def_at != -1 && wrote_def_at > read_defun_at;
 
-            if (found_def_after_defun) {
+            if (wrote_def_after_reading_defun) {
                 def.fixed = false;
             }
         }

package/lib/parse.js

@@ -163,7 +163,8 @@ import {
     _INLINE,
     _NOINLINE,
     _PURE,
-    _KEY
+    _KEY,
+    _MANGLEPROP,
 } from "./ast.js";
 
 var LATEST_RAW = "";  // Only used for numbers and template strings
@@ -2226,7 +2227,7 @@ function parse($TEXT, options) {
                 value : tok.value,
                 quote : tok.quote
             });
-            annotate(ret);            
+            annotate(ret);
             break;
           case "regexp":
             const [_, source, flags] = tok.value.match(/^\/(.*)\/(\w*)$/);
@@ -2538,13 +2539,14 @@ function parse($TEXT, options) {
             }
 
             // Create property
-            a.push(new AST_ObjectKeyVal({
+            const kv = new AST_ObjectKeyVal({
                 start: start,
                 quote: start.quote,
                 key: name instanceof AST_Node ? name : "" + name,
                 value: value,
                 end: prev()
-            }));
+            });
+            a.push(annotate(kv));
         }
         next();
         return new AST_Object({ properties: a });
@@ -2657,26 +2659,26 @@ function parse($TEXT, options) {
                     : AST_ObjectSetter;
 
                 name = get_symbol_ast(name);
-                return new AccessorClass({
+                return annotate(new AccessorClass({
                     start,
                     static: is_static,
                     key: name,
                     quote: name instanceof AST_SymbolMethod ? property_token.quote : undefined,
                     value: create_accessor(),
                     end: prev()
-                });
+                }));
             } else {
                 const AccessorClass = accessor_type === "get"
                     ? AST_PrivateGetter
                     : AST_PrivateSetter;
 
-                return new AccessorClass({
+                return annotate(new AccessorClass({
                     start,
                     static: is_static,
                     key: get_symbol_ast(name),
                     value: create_accessor(),
                     end: prev(),
-                });
+                }));
             }
         }
 
@@ -2696,7 +2698,7 @@ function parse($TEXT, options) {
                 value       : create_accessor(is_generator, is_async),
                 end         : prev()
             });
-            return node;
+            return annotate(node);
         }
 
         if (is_class) {
@@ -2709,14 +2711,16 @@ function parse($TEXT, options) {
                 : AST_ClassProperty;
             if (is("operator", "=")) {
                 next();
-                return new AST_ClassPropertyVariant({
-                    start,
-                    static: is_static,
-                    quote,
-                    key,
-                    value: expression(false),
-                    end: prev()
-                });
+                return annotate(
+                    new AST_ClassPropertyVariant({
+                        start,
+                        static: is_static,
+                        quote,
+                        key,
+                        value: expression(false),
+                        end: prev()
+                    })
+                );
             } else if (
                 is("name")
                 || is("privatename")
@@ -2724,13 +2728,15 @@ function parse($TEXT, options) {
                 || is("punc", ";")
                 || is("punc", "}")
             ) {
-                return new AST_ClassPropertyVariant({
-                    start,
-                    static: is_static,
-                    quote,
-                    key,
-                    end: prev()
-                });
+                return annotate(
+                    new AST_ClassPropertyVariant({
+                        start,
+                        static: is_static,
+                        quote,
+                        key,
+                        end: prev()
+                    })
+                );
             }
         }
     }
@@ -3093,10 +3099,9 @@ function parse($TEXT, options) {
     }
 
     // Annotate AST_Call, AST_Lambda or AST_New with the special comments
-    function annotate(node) {
-        var start = node.start;
-        var comments = start.comments_before;
-        const comments_outside_parens = outer_comments_before_counts.get(start);
+    function annotate(node, before_token = node.start) {
+        var comments = before_token.comments_before;
+        const comments_outside_parens = outer_comments_before_counts.get(before_token);
         var i = comments_outside_parens != null ? comments_outside_parens : comments.length;
         while (--i >= 0) {
             var comment = comments[i];
@@ -3117,8 +3122,13 @@ function parse($TEXT, options) {
                     set_annotation(node, _KEY);
                     break;
                 }
+                if (/[@#]__MANGLE_PROP__/.test(comment.value)) {
+                    set_annotation(node, _MANGLEPROP);
+                    break;
+                }
             }
         }
+        return node;
     }
 
     var subscripts = function(expr, allow_calls, is_chain) {

package/lib/propmangle.js

@@ -70,6 +70,9 @@ import {
     TreeTransformer,
     TreeWalker,
     _KEY,
+    _MANGLEPROP,
+
+    walk,
 } from "./ast.js";
 import { domprops } from "../tools/domprops.js";
 
@@ -188,6 +191,7 @@ function mangle_properties(ast, options) {
         regex: null,
         reserved: null,
         undeclared: false,
+        only_annotated: false,
     }, true);
 
     var nth_identifier = options.nth_identifier;
@@ -206,6 +210,7 @@ function mangle_properties(ast, options) {
         cache = new Map();
     }
 
+    var only_annotated = options.only_annotated;
     var regex = options.regex && new RegExp(options.regex);
 
     // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
@@ -217,6 +222,7 @@ function mangle_properties(ast, options) {
         debug_name_suffix = (options.debug === true ? "" : options.debug);
     }
 
+    var annotated_names = new Set();
     var names_to_mangle = new Set();
     var unmangleable = new Set();
     // Track each already-mangled name to prevent nth_identifier from generating
@@ -225,7 +231,38 @@ function mangle_properties(ast, options) {
 
     var keep_quoted = !!options.keep_quoted;
 
-    // step 1: find candidates to mangle
+    // Step 1: Find all annotated /*@__MANGLEPROP__*/
+    walk(ast, node => {
+        if (
+            node instanceof AST_ClassPrivateProperty
+            || node instanceof AST_PrivateMethod
+            || node instanceof AST_PrivateGetter
+            || node instanceof AST_PrivateSetter
+            || node instanceof AST_DotHash
+        ) {
+            // handled by mangle_private_properties
+        } else if (node instanceof AST_ObjectKeyVal) {
+            if (
+                typeof node.key == "string"
+                && has_annotation(node, _MANGLEPROP)
+                && can_mangle(node.key)
+            ) {
+                annotated_names.add(node.key);
+                clear_annotation(node, _MANGLEPROP);
+            }
+        } else if (node instanceof AST_ObjectProperty) {
+            // setter or getter, since KeyVal is handled above
+            if (
+                has_annotation(node, _MANGLEPROP)
+                && can_mangle(node.key.name)
+            ) {
+                annotated_names.add(node.key.name);
+                clear_annotation(node, _MANGLEPROP);
+            }
+        }
+    });
+
+    // step 2: find candidates to mangle
     ast.walk(new TreeWalker(function(node) {
         if (
             node instanceof AST_ClassPrivateProperty
@@ -321,15 +358,19 @@ function mangle_properties(ast, options) {
     }
 
     function should_mangle(name) {
-        if (regex && !regex.test(name)) return false;
+        if (only_annotated && !annotated_names.has(name)) return false;
+        if (regex && !regex.test(name)) {
+            return annotated_names.has(name);
+        }
         if (reserved.has(name)) return false;
         return cache.has(name)
             || names_to_mangle.has(name);
     }
 
     function add(name) {
-        if (can_mangle(name))
+        if (can_mangle(name)) {
             names_to_mangle.add(name);
+        }
 
         if (!should_mangle(name)) {
             unmangleable.add(name);

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