terser 5.7.0 → 5.9.0

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

@@ -15,6 +15,7 @@ import { base54 } from "./scope.js";
 import { SourceMap } from "./sourcemap.js";
 import {
     mangle_properties,
+    mangle_private_properties,
     reserve_quoted_keys,
 } from "./propmangle.js";
 
@@ -113,6 +114,7 @@ async function minify(files, options) {
             keep_classnames: false,
             keep_fnames: false,
             module: false,
+            nth_identifier: base54,
             properties: false,
             reserved: [],
             safari10: false,
@@ -203,9 +205,9 @@ async function minify(files, options) {
     if (options.mangle) toplevel.figure_out_scope(options.mangle);
     if (timings) timings.mangle = Date.now();
     if (options.mangle) {
-        base54.reset();
         toplevel.compute_char_frequency(options.mangle);
         toplevel.mangle_names(options.mangle);
+        toplevel = mangle_private_properties(toplevel, options.mangle);
     }
     if (timings) timings.properties = Date.now();
     if (options.mangle && options.mangle.properties) {

package/lib/output.js

@@ -159,7 +159,7 @@ import {
     is_basic_identifier_string,
     is_identifier_string,
     PRECEDENCE,
-    RESERVED_WORDS,
+    ALL_RESERVED_WORDS,
 } from "./parse.js";
 
 const EXPECT_DIRECTIVE = /^$|[;{][\s\n]*$/;
@@ -349,11 +349,17 @@ function OutputStream(options) {
     var do_add_mapping = mappings ? function() {
         mappings.forEach(function(mapping) {
             try {
+                let { name, token } = mapping;
+                if (token.type == "name" || token.type === "privatename") {
+                    name = token.value;
+                } else if (name instanceof AST_Symbol) {
+                    name = token.type === "string" ? token.value : 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
@@ -1713,7 +1719,11 @@ function OutputStream(options) {
         //    https://github.com/mishoo/UglifyJS2/issues/60
         if (noin) {
             parens = walk(node, node => {
-                if (node instanceof AST_Scope) return true;
+                // Don't go into scopes -- except arrow functions:
+                // https://github.com/terser/terser/issues/1019#issuecomment-877642607
+                if (node instanceof AST_Scope && !(node instanceof AST_Arrow)) {
+                    return true;
+                }
                 if (node instanceof AST_Binary && node.operator == "in") {
                     return walk_abort;  // makes walk() return true
                 }
@@ -1783,7 +1793,7 @@ function OutputStream(options) {
         var expr = self.expression;
         expr.print(output);
         var prop = self.property;
-        var print_computed = RESERVED_WORDS.has(prop)
+        var print_computed = ALL_RESERVED_WORDS.has(prop)
             ? output.option("ie8")
             : !is_identifier_string(
                 prop,
@@ -1816,6 +1826,7 @@ function OutputStream(options) {
 
         if (self.optional) output.print("?");
         output.print(".#");
+        output.add_mapping(self.end);
         output.print_name(prop);
     });
     DEFPRINT(AST_Sub, function(self, output) {
@@ -1964,7 +1975,7 @@ function OutputStream(options) {
             }
             return output.print(make_num(key));
         }
-        var print_string = RESERVED_WORDS.has(key)
+        var print_string = ALL_RESERVED_WORDS.has(key)
             ? output.option("ie8")
             : (
                 output.option("ecma") < 2015 || output.option("safari10")
@@ -1991,7 +2002,7 @@ function OutputStream(options) {
                 output.option("ecma") >= 2015 || output.option("safari10")
             ) &&
             get_name(self.value) === self.key &&
-            !RESERVED_WORDS.has(self.key)
+            !ALL_RESERVED_WORDS.has(self.key)
         ) {
             print_property_name(self.key, self.quote, output);
 
@@ -2269,8 +2280,10 @@ function OutputStream(options) {
     DEFMAP([
         AST_ObjectGetter,
         AST_ObjectSetter,
+        AST_PrivateGetter,
+        AST_PrivateSetter,
     ], function(output) {
-        output.add_mapping(this.start, this.key.name);
+        output.add_mapping(this.key.end, this.key.name);
     });
 
     DEFMAP([ AST_ObjectProperty ], function(output) {

package/lib/parse.js

@@ -166,13 +166,15 @@ var LATEST_TEMPLATE_END = true;
 
 var KEYWORDS = "break case catch class const continue debugger default delete do else export extends finally for function if in instanceof let new return switch throw try typeof var void while with";
 var KEYWORDS_ATOM = "false null true";
-var RESERVED_WORDS = "enum implements import interface package private protected public static super this " + KEYWORDS_ATOM + " " + KEYWORDS;
+var RESERVED_WORDS = "enum import super this " + KEYWORDS_ATOM + " " + KEYWORDS;
+var ALL_RESERVED_WORDS = "implements interface package private protected public static " + RESERVED_WORDS;
 var KEYWORDS_BEFORE_EXPRESSION = "return new delete throw else case yield await";
 
 KEYWORDS = makePredicate(KEYWORDS);
 RESERVED_WORDS = makePredicate(RESERVED_WORDS);
 KEYWORDS_BEFORE_EXPRESSION = makePredicate(KEYWORDS_BEFORE_EXPRESSION);
 KEYWORDS_ATOM = makePredicate(KEYWORDS_ATOM);
+ALL_RESERVED_WORDS = makePredicate(ALL_RESERVED_WORDS);
 
 var OPERATOR_CHARS = makePredicate(characters("+-*&%=<>!?|~^"));
 
@@ -3339,6 +3341,6 @@ export {
     JS_Parse_Error,
     parse,
     PRECEDENCE,
-    RESERVED_WORDS,
+    ALL_RESERVED_WORDS,
     tokenizer,
 };

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,33 +142,61 @@ 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) {
-            reserved.add(mangled_name);
-        });
     } else {
         cache = new Map();
     }
@@ -184,27 +214,29 @@ function mangle_properties(ast, options) {
 
     var names_to_mangle = new Set();
     var unmangleable = new Set();
-    var private_properties = new Set();
+    // Track each already-mangled name to prevent nth_identifier from generating
+    // the same name.
+    cache.forEach((mangled_name) => unmangleable.add(mangled_name));
 
-    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

@@ -107,7 +107,7 @@ import {
     walk
 } from "./ast.js";
 import {
-    RESERVED_WORDS,
+    ALL_RESERVED_WORDS,
     js_error,
 } from "./parse.js";
 
@@ -299,7 +299,14 @@ AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = null,
             // scope when we encounter the AST_Defun node (which is
             // instanceof AST_Scope) but we get to the symbol a bit
             // later.
-            mark_export((node.scope = defun.parent_scope.get_defun_scope()).def_function(node, defun), 1);
+            const closest_scope = defun.parent_scope;
+
+            // In strict mode, function definitions are block-scoped
+            node.scope = tw.directives["use strict"]
+                ? closest_scope
+                : closest_scope.get_defun_scope();
+
+            mark_export(node.scope.def_function(node, defun), 1);
         } else if (node instanceof AST_SymbolClass) {
             mark_export(defun.def_variable(node, defun), 1);
         } else if (node instanceof AST_SymbolImport) {
@@ -478,7 +485,6 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
 
 AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope) {
     this.variables = new Map();         // map name to AST_SymbolVar (variables defined in this scope; includes functions)
-    this.functions = new Map();         // map name to AST_SymbolDefun (functions defined in this scope)
     this.uses_with = false;             // will be set to true if this or some nested scope uses the `with` statement
     this.uses_eval = false;             // will be set to true if this or nested scope uses the global `eval`
     this.parent_scope = parent_scope;   // the parent scope
@@ -641,7 +647,6 @@ AST_Scope.DEFMETHOD("find_variable", function(name) {
 AST_Scope.DEFMETHOD("def_function", function(symbol, init) {
     var def = this.def_variable(symbol, init);
     if (!def.init || def.init instanceof AST_Defun) def.init = init;
-    this.functions.set(symbol.name, def);
     return def;
 });
 
@@ -662,9 +667,10 @@ 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);
-        if (RESERVED_WORDS.has(m)) continue; // skip over "do"
+        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
         // shadow a name reserved from mangling.
@@ -739,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,
@@ -760,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
@@ -811,8 +819,8 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
         if (node instanceof AST_Label) {
             let name;
             do {
-                name = base54(++lname);
-            } while (RESERVED_WORDS.has(name));
+                name = nth_identifier.get(++lname);
+            } while (ALL_RESERVED_WORDS.has(name));
             node.mangled_name = name;
             return true;
         }
@@ -873,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);
@@ -887,8 +898,8 @@ AST_Toplevel.DEFMETHOD("expand_names", function(options) {
     function next_name() {
         var name;
         do {
-            name = base54(cname++);
-        } while (avoid.has(name) || RESERVED_WORDS.has(name));
+            name = nth_identifier.get(cname++);
+        } while (avoid.has(name) || ALL_RESERVED_WORDS.has(name));
         return name;
     }
 
@@ -914,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);
@@ -961,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++;
@@ -985,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/lib/utils/index.js

@@ -64,10 +64,8 @@ class DefaultsError extends Error {
 function defaults(args, defs, croak) {
     if (args === true) {
         args = {};
-    }
-
-    if (args != null && typeof args === "object") {
-        args = Object.assign({}, args);
+    } else if (args != null && typeof args === "object") {
+        args = {...args};
     }
 
     const ret = args || {};

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.0",
+  "version": "5.9.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": {
@@ -93,7 +93,7 @@
   "eslintConfig": {
     "parserOptions": {
       "sourceType": "module",
-      "ecmaVersion": "2020"
+      "ecmaVersion": 2020
     },
     "env": {
       "node": true,

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[];
 }
@@ -138,6 +174,7 @@ export enum OutputQuoteStyle {
 export interface MinifyOptions {
     compress?: boolean | CompressOptions;
     ecma?: ECMA;
+    enclose?: boolean | string;
     ie8?: boolean;
     keep_classnames?: boolean | RegExp;
     keep_fnames?: boolean | RegExp;