terser 5.9.0 → 5.14.2

package/lib/output.js

@@ -172,10 +172,52 @@ function is_some_comments(comment) {
     // multiline comment
     return (
         (comment.type === "comment2" || comment.type === "comment1")
-        && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value)
+        && /@preserve|@copyright|@lic|@cc_on|^\**!/i.test(comment.value)
     );
 }
 
+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;
@@ -205,6 +247,8 @@ function OutputStream(options) {
         width                : 80,
         wrap_iife            : false,
         wrap_func_args       : true,
+
+        _destroy_ast         : false
     }, true);
 
     if (options.shorthand === undefined)
@@ -240,11 +284,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 + "}";
@@ -371,19 +415,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) {
@@ -417,13 +460,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;
@@ -447,7 +490,7 @@ function OutputStream(options) {
                 || (ch == "/" && ch == prev)
                 || ((ch == "+" || ch == "-") && ch == last)
             ) {
-                OUTPUT += " ";
+                OUTPUT.append(" ");
                 current_col++;
                 current_pos++;
             }
@@ -465,7 +508,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;
@@ -505,15 +548,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() {
@@ -579,13 +622,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;
             }
@@ -722,7 +766,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);
@@ -751,9 +795,21 @@ function OutputStream(options) {
                 need_space = true;
             }
         });
-        if (OUTPUT.length > insert) newline_insert = insert;
+        if (OUTPUT.length() > insert) newline_insert = insert;
     }
 
+    /**
+     * When output.option("_destroy_ast") is enabled, destroy the function.
+     * Call this after printing it.
+     */
+    const gc_scope =
+      options["_destroy_ast"]
+        ? function gc_scope(scope) {
+            scope.body.length = 0;
+            scope.argnames.length = 0;
+        }
+        : noop;
+
     var stack = [];
     return {
         get             : get,
@@ -781,7 +837,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();
@@ -800,6 +856,7 @@ function OutputStream(options) {
         with_square     : with_square,
         add_mapping     : add_mapping,
         option          : function(opt) { return options[opt]; },
+        gc_scope,
         printed_comments: printed_comments,
         prepend_comments: readonly ? noop : prepend_comments,
         append_comments : readonly || comment_filter === return_false ? noop : append_comments,
@@ -1056,7 +1113,8 @@ function OutputStream(options) {
         var p = output.parent();
         if (this.args.length === 0
             && (p instanceof AST_PropAccess // (new Date).getTime(), (new Date)["getTime"]()
-                || p instanceof AST_Call && p.expression === this)) // (new foo)(bar)
+                || p instanceof AST_Call && p.expression === this
+                || p instanceof AST_PrefixedTemplateString && p.prefix === this)) // (new foo)(bar)
             return true;
     });
 
@@ -1189,12 +1247,14 @@ function OutputStream(options) {
         output.with_indent(output.next_indent(), function() {
             output.append_comments(self, true);
         });
+        output.add_mapping(self.end);
         output.print("}");
     }
     function print_braced(self, output, allow_directives) {
         if (self.body.length > 0) {
             output.with_block(function() {
                 display_body(self.body, false, output, allow_directives);
+                output.add_mapping(self.end);
             });
         } else print_braced_empty(self, output);
     }
@@ -1315,6 +1375,7 @@ function OutputStream(options) {
     });
     DEFPRINT(AST_Lambda, function(self, output) {
         self._do_print(output);
+        output.gc_scope(self);
     });
 
     DEFPRINT(AST_PrefixedTemplateString, function(self, output) {
@@ -1394,6 +1455,7 @@ function OutputStream(options) {
             print_braced(self, output);
         }
         if (needs_parens) { output.print(")"); }
+        output.gc_scope(self);
     });
 
     /* -----[ exits ]----- */
@@ -1637,6 +1699,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) {
@@ -1702,6 +1768,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 ||
@@ -2163,7 +2233,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 (

package/lib/parse.js

@@ -162,7 +162,7 @@ import {
 } from "./ast.js";
 
 var LATEST_RAW = "";  // Only used for numbers and template strings
-var LATEST_TEMPLATE_END = true;
+var TEMPLATE_RAWS = new Map();  // Raw template strings
 
 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";
@@ -693,8 +693,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
                 next(true, true);
                 S.brace_counter++;
                 tok = token(begin ? "template_head" : "template_substitution", content);
-                LATEST_RAW = raw;
-                LATEST_TEMPLATE_END = false;
+                TEMPLATE_RAWS.set(tok, raw);
+                tok.template_end = false;
                 return tok;
             }
 
@@ -710,8 +710,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         }
         S.template_braces.pop();
         tok = token(begin ? "template_head" : "template_substitution", content);
-        LATEST_RAW = raw;
-        LATEST_TEMPLATE_END = true;
+        TEMPLATE_RAWS.set(tok, raw);
+        tok.template_end = true;
         return tok;
     });
 
@@ -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;
                 }
@@ -1572,66 +1572,66 @@ function parse($TEXT, options) {
         });
     };
 
-    function track_used_binding_identifiers(is_parameter, strict) {
-        var parameters = new Set();
-        var duplicate = false;
-        var default_assignment = false;
-        var spread = false;
-        var strict_mode = !!strict;
-        var tracker = {
-            add_parameter: function(token) {
-                if (parameters.has(token.value)) {
-                    if (duplicate === false) {
-                        duplicate = token;
-                    }
-                    tracker.check_strict();
-                } else {
-                    parameters.add(token.value);
-                    if (is_parameter) {
-                        switch (token.value) {
-                          case "arguments":
-                          case "eval":
-                          case "yield":
-                            if (strict_mode) {
-                                token_error(token, "Unexpected " + token.value + " identifier as parameter inside strict mode");
-                            }
-                            break;
-                          default:
-                            if (RESERVED_WORDS.has(token.value)) {
-                                unexpected();
-                            }
+    class UsedParametersTracker {
+        constructor(is_parameter, strict, duplicates_ok = false) {
+            this.is_parameter = is_parameter;
+            this.duplicates_ok = duplicates_ok;
+            this.parameters = new Set();
+            this.duplicate = null;
+            this.default_assignment = false;
+            this.spread = false;
+            this.strict_mode = !!strict;
+        }
+        add_parameter(token) {
+            if (this.parameters.has(token.value)) {
+                if (this.duplicate === null) {
+                    this.duplicate = token;
+                }
+                this.check_strict();
+            } else {
+                this.parameters.add(token.value);
+                if (this.is_parameter) {
+                    switch (token.value) {
+                      case "arguments":
+                      case "eval":
+                      case "yield":
+                        if (this.strict_mode) {
+                            token_error(token, "Unexpected " + token.value + " identifier as parameter inside strict mode");
+                        }
+                        break;
+                      default:
+                        if (RESERVED_WORDS.has(token.value)) {
+                            unexpected();
                         }
                     }
                 }
-            },
-            mark_default_assignment: function(token) {
-                if (default_assignment === false) {
-                    default_assignment = token;
-                }
-            },
-            mark_spread: function(token) {
-                if (spread === false) {
-                    spread = token;
-                }
-            },
-            mark_strict_mode: function() {
-                strict_mode = true;
-            },
-            is_strict: function() {
-                return default_assignment !== false || spread !== false || strict_mode;
-            },
-            check_strict: function() {
-                if (tracker.is_strict() && duplicate !== false) {
-                    token_error(duplicate, "Parameter " + duplicate.value + " was used already");
-                }
             }
-        };
-
-        return tracker;
+        }
+        mark_default_assignment(token) {
+            if (this.default_assignment === false) {
+                this.default_assignment = token;
+            }
+        }
+        mark_spread(token) {
+            if (this.spread === false) {
+                this.spread = token;
+            }
+        }
+        mark_strict_mode() {
+            this.strict_mode = true;
+        }
+        is_strict() {
+            return this.default_assignment !== false || this.spread !== false || this.strict_mode;
+        }
+        check_strict() {
+            if (this.is_strict() && this.duplicate !== null && !this.duplicates_ok) {
+                token_error(this.duplicate, "Parameter " + this.duplicate.value + " was used already");
+            }
+        }
     }
 
     function parameters(params) {
-        var used_parameters = track_used_binding_identifiers(true, S.input.has_directive("use strict"));
+        var used_parameters = new UsedParametersTracker(true, S.input.has_directive("use strict"));
 
         expect("(");
 
@@ -1655,7 +1655,7 @@ function parse($TEXT, options) {
         var param;
         var expand = false;
         if (used_parameters === undefined) {
-            used_parameters = track_used_binding_identifiers(true, S.input.has_directive("use strict"));
+            used_parameters = new UsedParametersTracker(true, S.input.has_directive("use strict"));
         }
         if (is("expand", "...")) {
             expand = S.token;
@@ -1698,7 +1698,9 @@ function parse($TEXT, options) {
         var expand_token;
         var first_token = S.token;
         if (used_parameters === undefined) {
-            used_parameters = track_used_binding_identifiers(false, S.input.has_directive("use strict"));
+            const strict = S.input.has_directive("use strict");
+            const duplicates_ok = symbol_type === AST_SymbolVar;
+            used_parameters = new UsedParametersTracker(false, strict, duplicates_ok);
         }
         symbol_type = symbol_type === undefined ? AST_SymbolFunarg : symbol_type;
         if (is("punc", "[")) {
@@ -2091,7 +2093,7 @@ function parse($TEXT, options) {
             if (is("punc", "{") || is("punc", "[")) {
                 def = new AST_VarDef({
                     start: S.token,
-                    name: binding_element(undefined ,sym_type),
+                    name: binding_element(undefined, sym_type),
                     value: is("operator", "=") ? (expect_token("operator", "="), expression(false, no_in)) : null,
                     end: prev()
                 });
@@ -2365,19 +2367,19 @@ function parse($TEXT, options) {
 
         segments.push(new AST_TemplateSegment({
             start: S.token,
-            raw: LATEST_RAW,
+            raw: TEMPLATE_RAWS.get(S.token),
             value: S.token.value,
             end: S.token
         }));
 
-        while (!LATEST_TEMPLATE_END) {
+        while (!S.token.template_end) {
             next();
             handle_regexp();
             segments.push(expression(true));
 
             segments.push(new AST_TemplateSegment({
                 start: S.token,
-                raw: LATEST_RAW,
+                raw: TEMPLATE_RAWS.get(S.token),
                 value: S.token.value,
                 end: S.token
             }));
@@ -2551,7 +2553,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 +2668,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 +2699,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 +2820,7 @@ function parse($TEXT, options) {
         return names;
     }
 
-    function export_() {
+    function export_statement() {
         var start = S.token;
         var is_default;
         var exported_names;
@@ -2824,6 +2838,8 @@ function parse($TEXT, options) {
                 }
                 next();
 
+                const assert_clause = maybe_import_assertion();
+
                 return new AST_Export({
                     start: start,
                     is_default: is_default,
@@ -2835,6 +2851,7 @@ function parse($TEXT, options) {
                         end: mod_str,
                     }),
                     end: prev(),
+                    assert_clause
                 });
             } else {
                 return new AST_Export({
@@ -2880,6 +2897,7 @@ function parse($TEXT, options) {
             exported_value: exported_value,
             exported_definition: exported_definition,
             end: prev(),
+            assert_clause: null
         });
     }
 
@@ -3324,6 +3342,7 @@ function parse($TEXT, options) {
         } else {
             toplevel = new AST_Toplevel({ start: start, body: body, end: end });
         }
+        TEMPLATE_RAWS = new Map();
         return toplevel;
     })();
 

package/lib/propmangle.js

@@ -78,7 +78,7 @@ function find_builtins(reserved) {
     var global_ref = typeof global === "object" ? global : self;
 
     new_globals.forEach(function (new_global) {
-        objects[new_global] = global_ref[new_global] || new Function();
+        objects[new_global] = global_ref[new_global] || function() {};
     });
 
     [

package/lib/scope.js

@@ -116,6 +116,11 @@ const MASK_EXPORT_WANT_MANGLE = 1 << 1;
 
 let function_defs = null;
 let unmangleable_names = null;
+/**
+ * When defined, there is a function declaration somewhere that's inside of a block.
+ * See https://tc39.es/ecma262/multipage/additional-ecmascript-features-for-web-browsers.html#sec-block-level-function-declarations-web-legacy-compatibility-semantics
+*/
+let scopes_with_block_defuns = null;
 
 class SymbolDef {
     constructor(scope, orig, init) {
@@ -666,6 +671,15 @@ AST_Scope.DEFMETHOD("def_variable", function(symbol, init) {
 });
 
 function next_mangled(scope, options) {
+    let defun_scope;
+    if (
+        scopes_with_block_defuns
+        && (defun_scope = scope.get_defun_scope())
+        && scopes_with_block_defuns.has(defun_scope)
+    ) {
+        scope = defun_scope;
+    }
+
     var ext = scope.enclosed;
     var nth_identifier = options.nth_identifier;
     out: while (true) {
@@ -781,6 +795,8 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     }
 
     const mangled_names = this.mangled_names = new Set();
+    unmangleable_names = new Set();
+
     if (options.cache) {
         this.globals.forEach(collect);
         if (options.cache.props) {
@@ -798,6 +814,13 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             lname = save_nesting;
             return true;        // don't descend again in TreeWalker
         }
+        if (
+            node instanceof AST_Defun
+            && !(tw.parent() instanceof AST_Scope)
+        ) {
+            scopes_with_block_defuns = scopes_with_block_defuns || new Set();
+            scopes_with_block_defuns.add(node.parent_scope.get_defun_scope());
+        }
         if (node instanceof AST_Scope) {
             node.variables.forEach(collect);
             return;
@@ -833,7 +856,6 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     this.walk(tw);
 
     if (options.keep_fnames || options.keep_classnames) {
-        unmangleable_names = new Set();
         // Collect a set of short names which are unmangleable,
         // for use in avoiding collisions in next_mangled.
         to_mangle.forEach(def => {
@@ -847,11 +869,12 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
 
     function_defs = null;
     unmangleable_names = null;
+    scopes_with_block_defuns = null;
 
     function collect(symbol) {
-        const should_mangle = !options.reserved.has(symbol.name)
-            && !(symbol.export & MASK_EXPORT_DONT_MANGLE);
-        if (should_mangle) {
+        if (symbol.export & MASK_EXPORT_DONT_MANGLE) {
+            unmangleable_names.add(symbol.name);
+        } else if (!options.reserved.has(symbol.name)) {
             to_mangle.push(symbol);
         }
     }