terser 5.7.2 → 5.11.0

package/lib/compress/tighten-body.js

@@ -321,7 +321,9 @@ export function tighten_body(statements, compressor) {
             // Replace variable with assignment when found
             if (can_replace
                 && !(node instanceof AST_SymbolDeclaration)
-                && lhs.equivalent_to(node)) {
+                && lhs.equivalent_to(node)
+                && !shadows(node.scope, lvalues)
+            ) {
                 if (stop_if_hit) {
                     abort = true;
                     return node;
@@ -369,7 +371,7 @@ export function tighten_body(statements, compressor) {
                 || node instanceof AST_PropAccess
                 && (side_effects || node.expression.may_throw_on_access(compressor))
                 || node instanceof AST_SymbolRef
-                && (lvalues.get(node.name) || side_effects && may_modify(node))
+                && ((lvalues.has(node.name) && lvalues.get(node.name).modified) || side_effects && may_modify(node))
                 || node instanceof AST_VarDef && node.value
                 && (lvalues.has(node.name.name) || side_effects && may_modify(node.name))
                 || (sym = is_lhs(node.left, node))
@@ -442,8 +444,9 @@ export function tighten_body(statements, compressor) {
                 // Locate symbols which may execute code outside of scanning range
                 var lvalues = get_lvalues(candidate);
                 var lhs_local = is_lhs_local(lhs);
-                if (lhs instanceof AST_SymbolRef)
-                    lvalues.set(lhs.name, false);
+                if (lhs instanceof AST_SymbolRef) {
+                    lvalues.set(lhs.name, { def: lhs.definition(), modified: false });
+                }
                 var side_effects = value_has_side_effects(candidate);
                 var replace_all = replace_all_symbols();
                 var may_throw = candidate.may_throw(compressor);
@@ -509,8 +512,9 @@ export function tighten_body(statements, compressor) {
                 return false;
             let cur_scope = def.scope;
             while (cur_scope && cur_scope !== scope) {
-                if (cur_scope.variables.has(def.name))
+                if (cur_scope.variables.has(def.name)) {
                     return true;
+                }
                 cur_scope = cur_scope.parent_scope;
             }
             return false;
@@ -791,8 +795,14 @@ export function tighten_body(statements, compressor) {
                 var sym = node;
                 while (sym instanceof AST_PropAccess)
                     sym = sym.expression;
-                if (sym instanceof AST_SymbolRef || sym instanceof AST_This) {
-                    lvalues.set(sym.name, lvalues.get(sym.name) || is_modified(compressor, tw, node, node, 0));
+                if (sym instanceof AST_SymbolRef) {
+                    const prev = lvalues.get(sym.name);
+                    if (!prev || !prev.modified) {
+                        lvalues.set(sym.name, {
+                            def: sym.definition(),
+                            modified: is_modified(compressor, tw, node, node, 0)
+                        });
+                    }
                 }
             });
             get_rvalue(expr).walk(tw);
@@ -904,6 +914,18 @@ export function tighten_body(statements, compressor) {
             }
             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;
+                }
+            }
+            return false;
+        }
     }
 
     function eliminate_spurious_blocks(statements) {

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/mozilla-ast.js

@@ -158,6 +158,7 @@ import {
     AST_With,
     AST_Yield,
 } from "./ast.js";
+import { is_basic_identifier_string } from "./parse.js";
 
 (function() {
 
@@ -179,6 +180,24 @@ import {
         return body;
     };
 
+    const assert_clause_from_moz = (assertions) => {
+        if (assertions && assertions.length > 0) {
+            return new AST_Object({
+                start: my_start_token(assertions),
+                end: my_end_token(assertions),
+                properties: assertions.map((assertion_kv) =>
+                    new AST_ObjectKeyVal({
+                        start: my_start_token(assertion_kv),
+                        end: my_end_token(assertion_kv),
+                        key: assertion_kv.key.name || assertion_kv.key.value,
+                        value: from_moz(assertion_kv.value)
+                    })
+                )
+            });
+        }
+        return null;
+    };
+
     var MOZ_TO_ME = {
         Program: function(M) {
             return new AST_Toplevel({
@@ -499,7 +518,8 @@ import {
                 end         : my_end_token(M),
                 imported_name: imported_name,
                 imported_names : imported_names,
-                module_name : from_moz(M.source)
+                module_name : from_moz(M.source),
+                assert_clause: assert_clause_from_moz(M.assertions)
             });
         },
         ExportAllDeclaration: function(M) {
@@ -512,7 +532,8 @@ import {
                         foreign_name: new AST_SymbolExportForeign({ name: "*" })
                     })
                 ],
-                module_name: from_moz(M.source)
+                module_name: from_moz(M.source),
+                assert_clause: assert_clause_from_moz(M.assertions)
             });
         },
         ExportNamedDeclaration: function(M) {
@@ -526,7 +547,8 @@ import {
                         name: from_moz(specifier.local)
                     });
                 }) : null,
-                module_name: from_moz(M.source)
+                module_name: from_moz(M.source),
+                assert_clause: assert_clause_from_moz(M.assertions)
             });
         },
         ExportDefaultDeclaration: function(M) {
@@ -818,12 +840,30 @@ import {
         };
     });
 
+    const assert_clause_to_moz = assert_clause => {
+        const assertions = [];
+        if (assert_clause) {
+            for (const { key, value } of assert_clause.properties) {
+                const key_moz = is_basic_identifier_string(key)
+                    ? { type: "Identifier", name: key }
+                    : { type: "Literal", value: key, raw: JSON.stringify(key) };
+                assertions.push({
+                    type: "ImportAttribute",
+                    key: key_moz,
+                    value: to_moz(value)
+                });
+            }
+        }
+        return assertions;
+    };
+
     def_to_moz(AST_Export, function To_Moz_ExportDeclaration(M) {
         if (M.exported_names) {
             if (M.exported_names[0].name.name === "*") {
                 return {
                     type: "ExportAllDeclaration",
-                    source: to_moz(M.module_name)
+                    source: to_moz(M.module_name),
+                    assertions: assert_clause_to_moz(M.assert_clause)
                 };
             }
             return {
@@ -836,7 +876,8 @@ import {
                     };
                 }),
                 declaration: to_moz(M.exported_definition),
-                source: to_moz(M.module_name)
+                source: to_moz(M.module_name),
+                assertions: assert_clause_to_moz(M.assert_clause)
             };
         }
         return {
@@ -870,7 +911,8 @@ import {
         return {
             type: "ImportDeclaration",
             specifiers: specifiers,
-            source: to_moz(M.module_name)
+            source: to_moz(M.module_name),
+            assertions: assert_clause_to_moz(M.assert_clause)
         };
     });
 

package/lib/output.js

@@ -176,6 +176,48 @@ function is_some_comments(comment) {
     );
 }
 
+class Rope {
+    constructor() {
+        this.committed = "";
+        this.current = "";
+    }
+
+    append(str) {
+        this.current += str;
+    }
+
+    insertAt(char, index) {
+        const { committed, current } = this;
+        if (index < committed.length) {
+            this.committed = committed.slice(0, index) + char + committed.slice(index);
+        } else if (index === committed.length) {
+            this.committed += char;
+        } else {
+            index -= committed.length;
+            this.committed += current.slice(0, index) + char;
+            this.current = current.slice(index);
+        }
+    }
+
+    charAt(index) {
+        const { committed } = this;
+        if (index < committed.length) return committed[index];
+        return this.current[index - committed.length];
+    }
+
+    curLength() {
+        return this.current.length;
+    }
+
+    length() {
+        return this.committed.length + this.current.length;
+    }
+
+    toString() {
+        return this.committed + this.current;
+    }
+}
+
 function OutputStream(options) {
 
     var readonly = !options;
@@ -240,11 +282,11 @@ function OutputStream(options) {
     var current_col = 0;
     var current_line = 1;
     var current_pos = 0;
-    var OUTPUT = "";
+    var OUTPUT = new Rope();
     let printed_comments = new Set();
 
-    var to_utf8 = options.ascii_only ? function(str, identifier) {
-        if (options.ecma >= 2015 && !options.safari10) {
+    var to_utf8 = options.ascii_only ? function(str, identifier = false, regexp = false) {
+        if (options.ecma >= 2015 && !options.safari10 && !regexp) {
             str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) {
                 var code = get_full_char_code(ch, 0).toString(16);
                 return "\\u{" + code + "}";
@@ -349,9 +391,11 @@ function OutputStream(options) {
     var do_add_mapping = mappings ? function() {
         mappings.forEach(function(mapping) {
             try {
-                let name = !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name;
-                if (name instanceof AST_Symbol) {
-                    name = name.name;
+                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,
@@ -369,19 +413,18 @@ function OutputStream(options) {
     var ensure_line_len = options.max_line_len ? function() {
         if (current_col > options.max_line_len) {
             if (might_add_newline) {
-                var left = OUTPUT.slice(0, might_add_newline);
-                var right = OUTPUT.slice(might_add_newline);
+                OUTPUT.insertAt("\n", might_add_newline);
+                const curLength = OUTPUT.curLength();
                 if (mappings) {
-                    var delta = right.length - current_col;
+                    var delta = curLength - current_col;
                     mappings.forEach(function(mapping) {
                         mapping.line++;
                         mapping.col += delta;
                     });
                 }
-                OUTPUT = left + "\n" + right;
                 current_line++;
                 current_pos++;
-                current_col = right.length;
+                current_col = curLength;
             }
         }
         if (might_add_newline) {
@@ -415,13 +458,13 @@ function OutputStream(options) {
 
             if (prev === ":" && ch === "}" || (!ch || !";}".includes(ch)) && prev !== ";") {
                 if (options.semicolons || requireSemicolonChars.has(ch)) {
-                    OUTPUT += ";";
+                    OUTPUT.append(";");
                     current_col++;
                     current_pos++;
                 } else {
                     ensure_line_len();
                     if (current_col > 0) {
-                        OUTPUT += "\n";
+                        OUTPUT.append("\n");
                         current_pos++;
                         current_line++;
                         current_col = 0;
@@ -445,7 +488,7 @@ function OutputStream(options) {
                 || (ch == "/" && ch == prev)
                 || ((ch == "+" || ch == "-") && ch == last)
             ) {
-                OUTPUT += " ";
+                OUTPUT.append(" ");
                 current_col++;
                 current_pos++;
             }
@@ -463,7 +506,7 @@ function OutputStream(options) {
             if (!might_add_newline) do_add_mapping();
         }
 
-        OUTPUT += str;
+        OUTPUT.append(str);
         has_parens = str[str.length - 1] == "(";
         current_pos += str.length;
         var a = str.split(/\r?\n/), n = a.length - 1;
@@ -503,15 +546,15 @@ function OutputStream(options) {
 
     var newline = options.beautify ? function() {
         if (newline_insert < 0) return print("\n");
-        if (OUTPUT[newline_insert] != "\n") {
-            OUTPUT = OUTPUT.slice(0, newline_insert) + "\n" + OUTPUT.slice(newline_insert);
+        if (OUTPUT.charAt(newline_insert) != "\n") {
+            OUTPUT.insertAt("\n", newline_insert);
             current_pos++;
             current_line++;
         }
         newline_insert++;
     } : options.max_line_len ? function() {
         ensure_line_len();
-        might_add_newline = OUTPUT.length;
+        might_add_newline = OUTPUT.length();
     } : noop;
 
     var semicolon = options.beautify ? function() {
@@ -577,13 +620,14 @@ function OutputStream(options) {
         if (might_add_newline) {
             ensure_line_len();
         }
-        return OUTPUT;
+        return OUTPUT.toString();
     }
 
     function has_nlb() {
-        let n = OUTPUT.length - 1;
+        const output = OUTPUT.toString();
+        let n = output.length - 1;
         while (n >= 0) {
-            const code = OUTPUT.charCodeAt(n);
+            const code = output.charCodeAt(n);
             if (code === CODE_LINE_BREAK) {
                 return true;
             }
@@ -720,7 +764,7 @@ function OutputStream(options) {
             !/comment[134]/.test(c.type)
         ))) return;
         printed_comments.add(comments);
-        var insert = OUTPUT.length;
+        var insert = OUTPUT.length();
         comments.filter(comment_filter, node).forEach(function(c, i) {
             if (printed_comments.has(c)) return;
             printed_comments.add(c);
@@ -749,7 +793,7 @@ function OutputStream(options) {
                 need_space = true;
             }
         });
-        if (OUTPUT.length > insert) newline_insert = insert;
+        if (OUTPUT.length() > insert) newline_insert = insert;
     }
 
     var stack = [];
@@ -779,7 +823,7 @@ function OutputStream(options) {
             var encoded = encode_string(str, quote);
             if (escape_directive === true && !encoded.includes("\\")) {
                 // Insert semicolons to break directive prologue
-                if (!EXPECT_DIRECTIVE.test(OUTPUT)) {
+                if (!EXPECT_DIRECTIVE.test(OUTPUT.toString())) {
                     force_semicolon();
                 }
                 force_semicolon();
@@ -1635,6 +1679,10 @@ function OutputStream(options) {
             output.space();
         }
         self.module_name.print(output);
+        if (self.assert_clause) {
+            output.print("assert");
+            self.assert_clause.print(output);
+        }
         output.semicolon();
     });
     DEFPRINT(AST_ImportMeta, function(self, output) {
@@ -1700,6 +1748,10 @@ function OutputStream(options) {
             output.space();
             self.module_name.print(output);
         }
+        if (self.assert_clause) {
+            output.print("assert");
+            self.assert_clause.print(output);
+        }
         if (self.exported_value
                 && !(self.exported_value instanceof AST_Defun ||
                     self.exported_value instanceof AST_Function ||
@@ -1824,6 +1876,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) {
@@ -2160,7 +2213,7 @@ function OutputStream(options) {
         flags = flags ? sort_regexp_flags(flags) : "";
         source = source.replace(r_slash_script, slash_script_replace);
 
-        output.print(output.to_utf8(`/${source}/${flags}`));
+        output.print(output.to_utf8(`/${source}/${flags}`, false, true));
 
         const parent = output.parent();
         if (
@@ -2277,8 +2330,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

@@ -1222,7 +1222,7 @@ function parse($TEXT, options) {
             }
             if (S.token.value == "import" && !is_token(peek(), "punc", "(") && !is_token(peek(), "punc", ".")) {
                 next();
-                var node = import_();
+                var node = import_statement();
                 semicolon();
                 return node;
             }
@@ -1374,7 +1374,7 @@ function parse($TEXT, options) {
               case "export":
                 if (!is_token(peek(), "punc", "(")) {
                     next();
-                    var node = export_();
+                    var node = export_statement();
                     if (is("punc", ";")) semicolon();
                     return node;
                 }
@@ -2551,7 +2551,7 @@ function parse($TEXT, options) {
         };
 
         const is_not_method_start = () =>
-            !is("punc", "(") && !is("punc", ",") && !is("punc", "}") && !is("operator", "=");
+            !is("punc", "(") && !is("punc", ",") && !is("punc", "}") && !is("punc", ";") && !is("operator", "=");
 
         var is_async = false;
         var is_static = false;
@@ -2666,7 +2666,15 @@ function parse($TEXT, options) {
         }
     }
 
-    function import_() {
+    function maybe_import_assertion() {
+        if (is("name", "assert") && !has_newline_before(S.token)) {
+            next();
+            return object_or_destructuring_();
+        }
+        return null;
+    }
+
+    function import_statement() {
         var start = prev();
 
         var imported_name;
@@ -2689,16 +2697,20 @@ function parse($TEXT, options) {
             unexpected();
         }
         next();
+
+        const assert_clause = maybe_import_assertion();
+
         return new AST_Import({
-            start: start,
-            imported_name: imported_name,
-            imported_names: imported_names,
+            start,
+            imported_name,
+            imported_names,
             module_name: new AST_String({
                 start: mod_str,
                 value: mod_str.value,
                 quote: mod_str.quote,
                 end: mod_str,
             }),
+            assert_clause,
             end: S.token,
         });
     }
@@ -2806,7 +2818,7 @@ function parse($TEXT, options) {
         return names;
     }
 
-    function export_() {
+    function export_statement() {
         var start = S.token;
         var is_default;
         var exported_names;
@@ -2824,6 +2836,8 @@ function parse($TEXT, options) {
                 }
                 next();
 
+                const assert_clause = maybe_import_assertion();
+
                 return new AST_Export({
                     start: start,
                     is_default: is_default,
@@ -2835,6 +2849,7 @@ function parse($TEXT, options) {
                         end: mod_str,
                     }),
                     end: prev(),
+                    assert_clause
                 });
             } else {
                 return new AST_Export({
@@ -2880,6 +2895,7 @@ function parse($TEXT, options) {
             exported_value: exported_value,
             exported_definition: exported_definition,
             end: prev(),
+            assert_clause: null
         });
     }