terser 5.16.1 → 5.16.3

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) {
@@ -2788,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()
             });
@@ -2803,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);
@@ -2828,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,
@@ -2870,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)];
         }
@@ -3037,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;

package/lib/scope.js

@@ -69,6 +69,7 @@ import {
     AST_Export,
     AST_For,
     AST_ForIn,
+    AST_ForOf,
     AST_Function,
     AST_Import,
     AST_IterationStatement,
@@ -230,8 +231,9 @@ AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = null,
             scope.init_scope_vars(parent_scope);
             scope.uses_with = save_scope.uses_with;
             scope.uses_eval = save_scope.uses_eval;
+
             if (options.safari10) {
-                if (node instanceof AST_For || node instanceof AST_ForIn) {
+                if (node instanceof AST_For || node instanceof AST_ForIn || node instanceof AST_ForOf) {
                     for_scopes.push(scope);
                 }
             }

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

package/tools/terser.d.ts

@@ -204,6 +204,7 @@ export interface SourceMapOptions {
     includeSources?: boolean;
     filename?: string;
     root?: string;
+    asObject?: boolean;
     url?: string | 'inline';
 }
 

package/bin/terser.mjs

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-
-"use strict";
-
-import "../tools/exit.cjs";
-
-import fs from "fs"
-import path from "path"
-import program from "commander"
-
-import { run_cli } from "../lib/cli.js"
-
-const packageJson = {
-    name: "terser",
-    version: "experimental module CLI"
-}
-
-run_cli({ program, packageJson, fs, path }).catch((error) => {
-    console.error(error);
-    process.exitCode = 1;
-});