terser 5.16.0 → 5.16.2

package/lib/compress/tighten-body.js

@@ -205,9 +205,10 @@ export function trim_unreachable_code(compressor, stat, target) {
 
 /** Tighten a bunch of statements together, and perform statement-level optimization. */
 export function tighten_body(statements, compressor) {
-    var in_loop, in_try;
-    var scope = compressor.find_parent(AST_Scope).get_defun_scope();
-    find_loop_scope_try();
+    const nearest_scope = compressor.find_scope();
+    const defun_scope = nearest_scope.get_defun_scope();
+    const { in_loop, in_try } = find_loop_scope_try();
+
     var CHANGED, max_iter = 10;
     do {
         CHANGED = false;
@@ -231,19 +232,20 @@ export function tighten_body(statements, compressor) {
     } while (CHANGED && max_iter-- > 0);
 
     function find_loop_scope_try() {
-        var node = compressor.self(), level = 0;
+        var node = compressor.self(), level = 0, in_loop = false, in_try = false;
         do {
             if (node instanceof AST_Catch || node instanceof AST_Finally) {
                 level++;
             } else if (node instanceof AST_IterationStatement) {
                 in_loop = true;
             } else if (node instanceof AST_Scope) {
-                scope = node;
                 break;
             } else if (node instanceof AST_Try) {
                 in_try = true;
             }
         } while (node = compressor.parent(level++));
+
+        return { in_loop, in_try };
     }
 
     // Search from right to left for assignment-like expressions:
@@ -255,7 +257,7 @@ export function tighten_body(statements, compressor) {
     // Will not attempt to collapse assignments into or past code blocks
     // which are not sequentially executed, e.g. loops and conditionals.
     function collapse(statements, compressor) {
-        if (scope.pinned())
+        if (nearest_scope.pinned() || defun_scope.pinned())
             return statements;
         var args;
         var candidates = [];
@@ -319,10 +321,11 @@ export function tighten_body(statements, compressor) {
                 stop_if_hit = parent;
             }
             // Replace variable with assignment when found
-            if (can_replace
+            if (
+                can_replace
                 && !(node instanceof AST_SymbolDeclaration)
                 && lhs.equivalent_to(node)
-                && !shadows(node.scope, lvalues)
+                && !shadows(scanner.find_scope() || nearest_scope, lvalues)
             ) {
                 if (stop_if_hit) {
                     abort = true;
@@ -527,9 +530,9 @@ export function tighten_body(statements, compressor) {
                     return true;
                 if (node instanceof AST_SymbolRef && (fn.variables.has(node.name) || redefined_within_scope(node.definition(), fn))) {
                     var s = node.definition().scope;
-                    if (s !== scope)
+                    if (s !== defun_scope)
                         while (s = s.parent_scope) {
-                            if (s === scope)
+                            if (s === defun_scope)
                                 return true;
                         }
                     return found = true;
@@ -851,7 +854,7 @@ export function tighten_body(statements, compressor) {
             while (lhs instanceof AST_PropAccess)
                 lhs = lhs.expression;
             return lhs instanceof AST_SymbolRef
-                && lhs.definition().scope === scope
+                && lhs.definition().scope.get_defun_scope() === defun_scope
                 && !(in_loop
                     && (lvalues.has(lhs.name)
                         || candidate instanceof AST_Unary
@@ -886,15 +889,11 @@ export function tighten_body(statements, compressor) {
             var def = sym.definition();
             if (def.orig.length == 1 && def.orig[0] instanceof AST_SymbolDefun)
                 return false;
-            if (def.scope.get_defun_scope() !== scope)
+            if (def.scope.get_defun_scope() !== defun_scope)
                 return true;
-            return !def.references.every((ref) => {
-                var s = ref.scope.get_defun_scope();
-                // "block" scope within AST_Catch
-                if (s.TYPE == "Scope")
-                    s = s.parent_scope;
-                return s === scope;
-            });
+            return def.references.some((ref) =>
+                ref.scope.get_defun_scope() !== defun_scope
+            );
         }
 
         function side_effects_external(node, lhs) {
@@ -910,18 +909,20 @@ export function tighten_body(statements, compressor) {
                 if (node instanceof AST_Sub)
                     return side_effects_external(node.expression, true);
                 if (node instanceof AST_SymbolRef)
-                    return node.definition().scope !== scope;
+                    return node.definition().scope.get_defun_scope() !== defun_scope;
             }
             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;
+        /**
+         * Will any of the pulled-in lvalues shadow a variable in newScope or parents?
+         * similar to scope_encloses_variables_in_this_scope */
+        function shadows(my_scope, lvalues) {
+            for (const { def } of lvalues.values()) {
+                const looked_up = my_scope.find_variable(def.name);
+                if (looked_up) {
+                    if (looked_up === def) continue;
+                    return true;
                 }
             }
             return false;
@@ -1343,7 +1344,7 @@ export function tighten_body(statements, compressor) {
                 break;
             if (def.name.name != sym.name)
                 break;
-            if (!node.right.is_constant_expression(scope))
+            if (!node.right.is_constant_expression(nearest_scope))
                 break;
             var prop = node.left.property;
             if (prop instanceof AST_Node) {
@@ -1403,14 +1404,21 @@ export function tighten_body(statements, compressor) {
                     CHANGED = true;
                     stat.init = exprs.length ? make_sequence(stat.init, exprs) : null;
                     statements[++j] = stat;
-                } else if (prev instanceof AST_Var && (!stat.init || stat.init.TYPE == prev.TYPE)) {
+                } else if (
+                    prev instanceof AST_Var
+                    && (!stat.init || stat.init.TYPE == prev.TYPE)
+                ) {
                     if (stat.init) {
                         prev.definitions = prev.definitions.concat(stat.init.definitions);
                     }
                     stat.init = prev;
                     statements[j] = stat;
                     CHANGED = true;
-                } else if (defs && stat.init && defs.TYPE == stat.init.TYPE && declarations_only(stat.init)) {
+                } else if (
+                    defs instanceof AST_Var
+                    && stat.init instanceof AST_Var
+                    && declarations_only(stat.init)
+                ) {
                     defs.definitions = defs.definitions.concat(stat.init.definitions);
                     stat.init = null;
                     statements[++j] = stat;

package/lib/minify.js

@@ -19,12 +19,15 @@ import {
     reserve_quoted_keys,
 } from "./propmangle.js";
 
-var to_ascii = typeof atob == "undefined" ? function(b64) {
-    return Buffer.from(b64, "base64").toString();
-} : atob;
-var to_base64 = typeof btoa == "undefined" ? function(str) {
-    return Buffer.from(str).toString("base64");
-} : btoa;
+// to/from base64 functions
+// Prefer built-in Buffer, if available, then use hack
+// https://developer.mozilla.org/en-US/docs/Glossary/Base64#The_Unicode_Problem
+var to_ascii = typeof Buffer !== "undefined"
+    ? (b64) => Buffer.from(b64, "base64").toString()
+    : (b64) => decodeURIComponent(escape(atob(b64)));
+var to_base64 = typeof Buffer !== "undefined"
+    ? (str) => Buffer.from(str).toString("base64")
+    : (str) => btoa(unescape(encodeURIComponent(str)));
 
 function read_source_map(code) {
     var match = /(?:^|[^.])\/\/# sourceMappingURL=data:application\/json(;[\w=-]*)?;base64,([+/0-9A-Za-z]*=*)\s*$/.exec(code);

package/lib/mozilla-ast.js

@@ -529,24 +529,11 @@ import { is_basic_identifier_string } from "./parse.js";
             var imported_name = null;
             var imported_names = null;
             M.specifiers.forEach(function (specifier) {
-                if (specifier.type === "ImportSpecifier") {
+                if (specifier.type === "ImportSpecifier" || specifier.type === "ImportNamespaceSpecifier") {
                     if (!imported_names) { imported_names = []; }
-                    imported_names.push(new AST_NameMapping({
-                        start: my_start_token(specifier),
-                        end: my_end_token(specifier),
-                        foreign_name: from_moz(specifier.imported),
-                        name: from_moz(specifier.local)
-                    }));
+                    imported_names.push(from_moz(specifier));
                 } else if (specifier.type === "ImportDefaultSpecifier") {
-                    imported_name = from_moz(specifier.local);
-                } else if (specifier.type === "ImportNamespaceSpecifier") {
-                    if (!imported_names) { imported_names = []; }
-                    imported_names.push(new AST_NameMapping({
-                        start: my_start_token(specifier),
-                        end: my_end_token(specifier),
-                        foreign_name: new AST_SymbolImportForeign({ name: "*" }),
-                        name: from_moz(specifier.local)
-                    }));
+                    imported_name = from_moz(specifier);
                 }
             });
             return new AST_Import({
@@ -559,14 +546,39 @@ import { is_basic_identifier_string } from "./parse.js";
             });
         },
 
+        ImportSpecifier: function(M) {
+            return new AST_NameMapping({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                foreign_name: from_moz(M.imported),
+                name: from_moz(M.local)
+            });
+        },
+
+        ImportDefaultSpecifier: function(M) {
+            return from_moz(M.local);
+        },
+
+        ImportNamespaceSpecifier: function(M) {
+            return new AST_NameMapping({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                foreign_name: new AST_SymbolImportForeign({ name: "*" }),
+                name: from_moz(M.local)
+            });
+        },
+
         ExportAllDeclaration: function(M) {
+            var foreign_name = M.exported == null ? 
+                new AST_SymbolExportForeign({ name: "*" }) :
+                from_moz(M.exported);
             return new AST_Export({
                 start: my_start_token(M),
                 end: my_end_token(M),
                 exported_names: [
                     new AST_NameMapping({
                         name: new AST_SymbolExportForeign({ name: "*" }),
-                        foreign_name: new AST_SymbolExportForeign({ name: "*" })
+                        foreign_name: foreign_name
                     })
                 ],
                 module_name: from_moz(M.source),
@@ -580,10 +592,7 @@ import { is_basic_identifier_string } from "./parse.js";
                 end: my_end_token(M),
                 exported_definition: from_moz(M.declaration),
                 exported_names: M.specifiers && M.specifiers.length ? M.specifiers.map(function (specifier) {
-                    return new AST_NameMapping({
-                        foreign_name: from_moz(specifier.exported),
-                        name: from_moz(specifier.local)
-                    });
+                    return from_moz(specifier);
                 }) : null,
                 module_name: from_moz(M.source),
                 assert_clause: assert_clause_from_moz(M.assertions)
@@ -599,6 +608,13 @@ import { is_basic_identifier_string } from "./parse.js";
             });
         },
 
+        ExportSpecifier: function(M) {
+            return new AST_NameMapping({
+                foreign_name: from_moz(M.exported),
+                name: from_moz(M.local)
+            });
+        },
+
         Literal: function(M) {
             var val = M.value, args = {
                 start  : my_start_token(M),
@@ -624,6 +640,22 @@ import { is_basic_identifier_string } from "./parse.js";
             if (val === null) return new AST_Null(args);
             switch (typeof val) {
               case "string":
+                args.quote = "\"";
+                var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
+                if (p.type == "ImportSpecifier") {
+                    args.name = val;
+                    return new AST_SymbolImportForeign(args);
+                } else if (p.type == "ExportSpecifier") {
+                    args.name = val;
+                    if (M == p.exported) {
+                        return new AST_SymbolExportForeign(args);
+                    } else {
+                        return new AST_SymbolExport(args);
+                    }
+                } else if (p.type == "ExportAllDeclaration" && M == p.exported) {
+                    args.name = val;
+                    return new AST_SymbolExportForeign(args);
+                }
                 args.value = val;
                 return new AST_String(args);
               case "number":
@@ -1328,10 +1360,17 @@ import { is_basic_identifier_string } from "./parse.js";
 
     def_to_moz(AST_Export, function To_Moz_ExportDeclaration(M) {
         if (M.exported_names) {
-            if (M.exported_names[0].name.name === "*") {
+            var first_exported = M.exported_names[0];
+            var first_exported_name = first_exported.name;
+            if (first_exported_name.name === "*" && !first_exported_name.quote) {
+                var foreign_name = first_exported.foreign_name;
+                var exported = foreign_name.name === "*" && !foreign_name.quote
+                    ? null
+                    : to_moz(foreign_name);
                 return {
                     type: "ExportAllDeclaration",
                     source: to_moz(M.module_name),
+                    exported: exported,
                     assertions: assert_clause_to_moz(M.assert_clause)
                 };
             }
@@ -1363,19 +1402,22 @@ import { is_basic_identifier_string } from "./parse.js";
                 local: to_moz(M.imported_name)
             });
         }
-        if (M.imported_names && M.imported_names[0].foreign_name.name === "*") {
-            specifiers.push({
-                type: "ImportNamespaceSpecifier",
-                local: to_moz(M.imported_names[0].name)
-            });
-        } else if (M.imported_names) {
-            M.imported_names.forEach(function(name_mapping) {
+        if (M.imported_names) {
+            var first_imported_foreign_name = M.imported_names[0].foreign_name;
+            if (first_imported_foreign_name.name === "*" && !first_imported_foreign_name.quote) {
                 specifiers.push({
-                    type: "ImportSpecifier",
-                    local: to_moz(name_mapping.name),
-                    imported: to_moz(name_mapping.foreign_name)
+                    type: "ImportNamespaceSpecifier",
+                    local: to_moz(M.imported_names[0].name)
                 });
-            });
+            } else {
+                M.imported_names.forEach(function(name_mapping) {
+                    specifiers.push({
+                        type: "ImportSpecifier",
+                        local: to_moz(name_mapping.name),
+                        imported: to_moz(name_mapping.foreign_name)
+                    });
+                });
+            }
         }
         return {
             type: "ImportDeclaration",
@@ -1639,7 +1681,14 @@ import { is_basic_identifier_string } from "./parse.js";
     });
 
     def_to_moz(AST_Symbol, function To_Moz_Identifier(M, parent) {
-        if (M instanceof AST_SymbolMethod && parent.quote) {
+        if (
+            (M instanceof AST_SymbolMethod && parent.quote) ||
+            ((
+                M instanceof AST_SymbolImportForeign ||
+                M instanceof AST_SymbolExportForeign ||
+                M instanceof AST_SymbolExport
+                ) && M.quote)
+         ) {
             return {
                 type: "Literal",
                 value: M.name

package/lib/output.js

@@ -1225,7 +1225,7 @@ function OutputStream(options) {
     }
 
     AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output) {
-        force_statement(this.body, output);
+        print_maybe_braced_body(this.body, output);
     });
 
     DEFPRINT(AST_Statement, function(self, output) {
@@ -1554,7 +1554,7 @@ function OutputStream(options) {
                 b = b.body;
             } else break;
         }
-        force_statement(self.body, output);
+        print_maybe_braced_body(self.body, output);
     }
     DEFPRINT(AST_If, function(self, output) {
         output.print("if");
@@ -1571,7 +1571,7 @@ function OutputStream(options) {
             if (self.alternative instanceof AST_If)
                 self.alternative.print(output);
             else
-                force_statement(self.alternative, output);
+                print_maybe_braced_body(self.alternative, output);
         } else {
             self._do_print_body(output);
         }
@@ -1681,7 +1681,9 @@ function OutputStream(options) {
             output.space();
         }
         if (self.imported_names) {
-            if (self.imported_names.length === 1 && self.imported_names[0].foreign_name.name === "*") {
+            if (self.imported_names.length === 1 &&
+                self.imported_names[0].foreign_name.name === "*" &&
+                !self.imported_names[0].foreign_name.quote) {
                 self.imported_names[0].print(output);
             } else {
                 output.print("{");
@@ -1715,14 +1717,31 @@ function OutputStream(options) {
     DEFPRINT(AST_NameMapping, function(self, output) {
         var is_import = output.parent() instanceof AST_Import;
         var definition = self.name.definition();
+        var foreign_name = self.foreign_name;
         var names_are_different =
             (definition && definition.mangled_name || self.name.name) !==
-            self.foreign_name.name;
+            foreign_name.name;
+        if (!names_are_different &&
+            foreign_name.name === "*" &&
+            foreign_name.quote != self.name.quote) {
+                // export * as "*"
+            names_are_different = true;
+        }
+        var foreign_name_is_name = foreign_name.quote == null;
         if (names_are_different) {
             if (is_import) {
-                output.print(self.foreign_name.name);
+                if (foreign_name_is_name) {
+                    output.print(foreign_name.name);
+                } else {
+                    output.print_string(foreign_name.name, foreign_name.quote);
+                }
             } else {
-                self.name.print(output);
+                if (self.name.quote == null) {
+                    self.name.print(output);
+                } else {
+                    output.print_string(self.name.name, self.name.quote);
+                }
+                
             }
             output.space();
             output.print("as");
@@ -1730,10 +1749,18 @@ function OutputStream(options) {
             if (is_import) {
                 self.name.print(output);
             } else {
-                output.print(self.foreign_name.name);
+                if (foreign_name_is_name) {
+                    output.print(foreign_name.name);
+                } else {
+                    output.print_string(foreign_name.name, foreign_name.quote);
+                }
             }
         } else {
-            self.name.print(output);
+            if (self.name.quote == null) {
+                self.name.print(output);
+            } else {
+                output.print_string(self.name.name, self.name.quote);
+            }
         }
     });
 
@@ -1745,8 +1772,10 @@ function OutputStream(options) {
             output.space();
         }
         if (self.exported_names) {
-            if (self.exported_names.length === 1 && self.exported_names[0].name.name === "*") {
-                self.exported_names[0].print(output);
+            if (self.exported_names.length === 1 &&
+                self.exported_names[0].name.name === "*" &&
+                !self.exported_names[0].name.quote) {
+                    self.exported_names[0].print(output);
             } else {
                 output.print("{");
                 self.exported_names.forEach(function(name_export, i) {
@@ -2266,12 +2295,15 @@ function OutputStream(options) {
         }
     });
 
-    function force_statement(stat, output) {
+    /** if, for, while, may or may not have braces surrounding its body */
+    function print_maybe_braced_body(stat, output) {
         if (output.option("braces")) {
             make_block(stat, output);
         } else {
             if (!stat || stat instanceof AST_EmptyStatement)
                 output.force_semicolon();
+            else if (stat instanceof AST_Let || stat instanceof AST_Const || stat instanceof AST_Class)
+                make_block(stat, output);
             else
                 stat.print(output);
         }

package/lib/parse.js

@@ -2089,14 +2089,20 @@ function parse($TEXT, options) {
         });
     }
 
+    /**
+     * var
+     *   vardef1 = 2,
+     *   vardef2 = 3;
+     */
     function vardefs(no_in, kind) {
-        var a = [];
+        var var_defs = [];
         var def;
         for (;;) {
             var sym_type =
                 kind === "var" ? AST_SymbolVar :
                 kind === "const" ? AST_SymbolConst :
                 kind === "let" ? AST_SymbolLet : null;
+            // var { a } = b
             if (is("punc", "{") || is("punc", "[")) {
                 def = new AST_VarDef({
                     start: S.token,
@@ -2116,12 +2122,12 @@ function parse($TEXT, options) {
                 });
                 if (def.name.name == "import") croak("Unexpected token: import");
             }
-            a.push(def);
+            var_defs.push(def);
             if (!is("punc", ","))
                 break;
             next();
         }
-        return a;
+        return var_defs;
     }
 
     var var_ = function(no_in) {
@@ -2548,6 +2554,7 @@ function parse($TEXT, options) {
 
         expect("{");
         // mark in class feild,
+        const save_in_class = S.in_class;
         S.in_class = true;
         while (is("punc", ";")) { next(); }  // Leading semicolons are okay in class bodies.
         while (!is("punc", "}")) {
@@ -2558,7 +2565,7 @@ function parse($TEXT, options) {
             while (is("punc", ";")) { next(); }
         }
         // mark in class feild,
-        S.in_class = false;
+        S.in_class = save_in_class;
 
         S.input.pop_directives_stack();
 
@@ -2787,9 +2794,10 @@ function parse($TEXT, options) {
     }
 
     function map_name(is_import) {
-        function make_symbol(type) {
+        function make_symbol(type, quote) {
             return new type({
                 name: as_property_name(),
+                quote: quote || undefined,
                 start: prev(),
                 end: prev()
             });
@@ -2802,16 +2810,16 @@ function parse($TEXT, options) {
         var name;
 
         if (is_import) {
-            foreign_name = make_symbol(foreign_type);
+            foreign_name = make_symbol(foreign_type, start.quote);
         } else {
-            name = make_symbol(type);
+            name = make_symbol(type, start.quote);
         }
         if (is("name", "as")) {
             next();  // The "as" word
             if (is_import) {
                 name = make_symbol(type);
             } else {
-                foreign_name = make_symbol(foreign_type);
+                foreign_name = make_symbol(foreign_type, S.token.quote);
             }
         } else if (is_import) {
             name = new type(foreign_name);
@@ -2827,20 +2835,26 @@ function parse($TEXT, options) {
         });
     }
 
-    function map_nameAsterisk(is_import, name) {
+    function map_nameAsterisk(is_import, import_or_export_foreign_name) {
         var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign;
         var type = is_import ? AST_SymbolImport : AST_SymbolExport;
         var start = S.token;
-        var foreign_name;
+        var name, foreign_name;
         var end = prev();
 
+        if (is_import) {
+            name = import_or_export_foreign_name;
+        } else {
+            foreign_name = import_or_export_foreign_name;
+        }
+
         name = name || new type({
             start: start,
             name: "*",
             end: end,
         });
 
-        foreign_name = new foreign_type({
+        foreign_name = foreign_name || new foreign_type({
             start: start,
             name: "*",
             end: end,
@@ -2869,9 +2883,9 @@ function parse($TEXT, options) {
         } else if (is("operator", "*")) {
             var name;
             next();
-            if (is_import && is("name", "as")) {
+            if (is("name", "as")) {
                 next();  // The "as" word
-                name = as_symbol(is_import ? AST_SymbolImport : AST_SymbolExportForeign);
+                name = is_import ? as_symbol(AST_SymbolImport) : as_symbol_or_string(AST_SymbolExportForeign);
             }
             names = [map_nameAsterisk(is_import, name)];
         }
@@ -3036,6 +3050,27 @@ function parse($TEXT, options) {
         return sym;
     }
 
+    function as_symbol_or_string(type) {
+        if (!is("name")) {
+            if (!is("string")) {
+                croak("Name or string expected");
+            }
+            var tok = S.token;
+            var ret = new type({
+                start : tok,
+                end   : tok,
+                name : tok.value,
+                quote : tok.quote
+            });
+            next();
+            return ret;
+        }
+        var sym = _make_symbol(type);
+        _verify_symbol(sym);
+        next();
+        return sym;
+    }
+
     // Annotate AST_Call, AST_Lambda or AST_New with the special comments
     function annotate(node) {
         var start = node.start;