terser 5.12.1 → 5.14.0

package/lib/equivalent-to.js

@@ -97,24 +97,6 @@ export const equivalent_to = (tree1, tree2) => {
     return walk_1_state.length == 0 && walk_2_state.length == 0;
 };
 
-// Creates a shallow compare function
-const mkshallow = (props) => {
-    const comparisons = Object
-        .keys(props)
-        .map(key => {
-            if (props[key] === "eq") {
-                return `this.${key} === other.${key}`;
-            } else if (props[key] === "exist") {
-                return `(this.${key} == null ? other.${key} == null : this.${key} === other.${key})`;
-            } else {
-                throw new Error(`mkshallow: Unexpected instruction: ${props[key]}`);
-            }
-        })
-        .join(" && ");
-
-    return new Function("other", "return " + comparisons);
-};
-
 const pass_through = () => true;
 
 AST_Node.prototype.shallow_cmp = function () {
@@ -123,7 +105,9 @@ AST_Node.prototype.shallow_cmp = function () {
 
 AST_Debugger.prototype.shallow_cmp = pass_through;
 
-AST_Directive.prototype.shallow_cmp = mkshallow({ value: "eq" });
+AST_Directive.prototype.shallow_cmp = function(other) {
+    return this.value === other.value;
+};
 
 AST_SimpleStatement.prototype.shallow_cmp = pass_through;
 
@@ -131,17 +115,17 @@ AST_Block.prototype.shallow_cmp = pass_through;
 
 AST_EmptyStatement.prototype.shallow_cmp = pass_through;
 
-AST_LabeledStatement.prototype.shallow_cmp = mkshallow({ "label.name": "eq" });
+AST_LabeledStatement.prototype.shallow_cmp = function(other) {
+    return this.label.name === other.label.name;
+};
 
 AST_Do.prototype.shallow_cmp = pass_through;
 
 AST_While.prototype.shallow_cmp = pass_through;
 
-AST_For.prototype.shallow_cmp = mkshallow({
-    init: "exist",
-    condition: "exist",
-    step: "exist"
-});
+AST_For.prototype.shallow_cmp = function(other) {
+    return (this.init == null ? other.init == null : this.init === other.init) && (this.condition == null ? other.condition == null : this.condition === other.condition) && (this.step == null ? other.step == null : this.step === other.step);
+};
 
 AST_ForIn.prototype.shallow_cmp = pass_through;
 
@@ -153,22 +137,21 @@ AST_Toplevel.prototype.shallow_cmp = pass_through;
 
 AST_Expansion.prototype.shallow_cmp = pass_through;
 
-AST_Lambda.prototype.shallow_cmp = mkshallow({
-    is_generator: "eq",
-    async: "eq"
-});
+AST_Lambda.prototype.shallow_cmp = function(other) {
+    return this.is_generator === other.is_generator && this.async === other.async;
+};
 
-AST_Destructuring.prototype.shallow_cmp = mkshallow({
-    is_array: "eq"
-});
+AST_Destructuring.prototype.shallow_cmp = function(other) {
+    return this.is_array === other.is_array;
+};
 
 AST_PrefixedTemplateString.prototype.shallow_cmp = pass_through;
 
 AST_TemplateString.prototype.shallow_cmp = pass_through;
 
-AST_TemplateSegment.prototype.shallow_cmp = mkshallow({
-    "value": "eq"
-});
+AST_TemplateSegment.prototype.shallow_cmp = function(other) {
+    return this.value === other.value;
+};
 
 AST_Jump.prototype.shallow_cmp = pass_through;
 
@@ -176,51 +159,45 @@ AST_LoopControl.prototype.shallow_cmp = pass_through;
 
 AST_Await.prototype.shallow_cmp = pass_through;
 
-AST_Yield.prototype.shallow_cmp = mkshallow({
-    is_star: "eq"
-});
+AST_Yield.prototype.shallow_cmp = function(other) {
+    return this.is_star === other.is_star;
+};
 
-AST_If.prototype.shallow_cmp = mkshallow({
-    alternative: "exist"
-});
+AST_If.prototype.shallow_cmp = function(other) {
+    return this.alternative == null ? other.alternative == null : this.alternative === other.alternative;
+};
 
 AST_Switch.prototype.shallow_cmp = pass_through;
 
 AST_SwitchBranch.prototype.shallow_cmp = pass_through;
 
-AST_Try.prototype.shallow_cmp = mkshallow({
-    bcatch: "exist",
-    bfinally: "exist"
-});
+AST_Try.prototype.shallow_cmp = function(other) {
+    return (this.bcatch == null ? other.bcatch == null : this.bcatch === other.bcatch) && (this.bfinally == null ? other.bfinally == null : this.bfinally === other.bfinally);
+};
 
-AST_Catch.prototype.shallow_cmp = mkshallow({
-    argname: "exist"
-});
+AST_Catch.prototype.shallow_cmp = function(other) {
+    return this.argname == null ? other.argname == null : this.argname === other.argname;
+};
 
 AST_Finally.prototype.shallow_cmp = pass_through;
 
 AST_Definitions.prototype.shallow_cmp = pass_through;
 
-AST_VarDef.prototype.shallow_cmp = mkshallow({
-    value: "exist"
-});
+AST_VarDef.prototype.shallow_cmp = function(other) {
+    return this.value == null ? other.value == null : this.value === other.value;
+};
 
 AST_NameMapping.prototype.shallow_cmp = pass_through;
 
-AST_Import.prototype.shallow_cmp = mkshallow({
-    imported_name: "exist",
-    imported_names: "exist"
-});
+AST_Import.prototype.shallow_cmp = function(other) {
+    return (this.imported_name == null ? other.imported_name == null : this.imported_name === other.imported_name) && (this.imported_names == null ? other.imported_names == null : this.imported_names === other.imported_names);
+};
 
 AST_ImportMeta.prototype.shallow_cmp = pass_through;
 
-AST_Export.prototype.shallow_cmp = mkshallow({
-    exported_definition: "exist",
-    exported_value: "exist",
-    exported_names: "exist",
-    module_name: "eq",
-    is_default: "eq",
-});
+AST_Export.prototype.shallow_cmp = function(other) {
+    return (this.exported_definition == null ? other.exported_definition == null : this.exported_definition === other.exported_definition) && (this.exported_value == null ? other.exported_value == null : this.exported_value === other.exported_value) && (this.exported_names == null ? other.exported_names == null : this.exported_names === other.exported_names) && this.module_name === other.module_name && this.is_default === other.is_default;
+};
 
 AST_Call.prototype.shallow_cmp = pass_through;
 
@@ -230,21 +207,21 @@ AST_PropAccess.prototype.shallow_cmp = pass_through;
 
 AST_Chain.prototype.shallow_cmp = pass_through;
 
-AST_Dot.prototype.shallow_cmp = mkshallow({
-    property: "eq"
-});
+AST_Dot.prototype.shallow_cmp = function(other) {
+    return this.property === other.property;
+};
 
-AST_DotHash.prototype.shallow_cmp = mkshallow({
-    property: "eq"
-});
+AST_DotHash.prototype.shallow_cmp = function(other) {
+    return this.property === other.property;
+};
 
-AST_Unary.prototype.shallow_cmp = mkshallow({
-    operator: "eq"
-});
+AST_Unary.prototype.shallow_cmp = function(other) {
+    return this.operator === other.operator;
+};
 
-AST_Binary.prototype.shallow_cmp = mkshallow({
-    operator: "eq"
-});
+AST_Binary.prototype.shallow_cmp = function(other) {
+    return this.operator === other.operator;
+};
 
 AST_Conditional.prototype.shallow_cmp = pass_through;
 
@@ -254,36 +231,33 @@ AST_Object.prototype.shallow_cmp = pass_through;
 
 AST_ObjectProperty.prototype.shallow_cmp = pass_through;
 
-AST_ObjectKeyVal.prototype.shallow_cmp = mkshallow({
-    key: "eq"
-});
+AST_ObjectKeyVal.prototype.shallow_cmp = function(other) {
+    return this.key === other.key;
+};
 
-AST_ObjectSetter.prototype.shallow_cmp = mkshallow({
-    static: "eq"
-});
+AST_ObjectSetter.prototype.shallow_cmp = function(other) {
+    return this.static === other.static;
+};
 
-AST_ObjectGetter.prototype.shallow_cmp = mkshallow({
-    static: "eq"
-});
+AST_ObjectGetter.prototype.shallow_cmp = function(other) {
+    return this.static === other.static;
+};
 
-AST_ConciseMethod.prototype.shallow_cmp = mkshallow({
-    static: "eq",
-    is_generator: "eq",
-    async: "eq",
-});
+AST_ConciseMethod.prototype.shallow_cmp = function(other) {
+    return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
+};
 
-AST_Class.prototype.shallow_cmp = mkshallow({
-    name: "exist",
-    extends: "exist",
-});
+AST_Class.prototype.shallow_cmp = function(other) {
+    return (this.name == null ? other.name == null : this.name === other.name) && (this.extends == null ? other.extends == null : this.extends === other.extends);
+};
 
-AST_ClassProperty.prototype.shallow_cmp = mkshallow({
-    static: "eq"
-});
+AST_ClassProperty.prototype.shallow_cmp = function(other) {
+    return this.static === other.static;
+};
 
-AST_Symbol.prototype.shallow_cmp = mkshallow({
-    name: "eq"
-});
+AST_Symbol.prototype.shallow_cmp = function(other) {
+    return this.name === other.name;
+};
 
 AST_NewTarget.prototype.shallow_cmp = pass_through;
 
@@ -291,17 +265,17 @@ AST_This.prototype.shallow_cmp = pass_through;
 
 AST_Super.prototype.shallow_cmp = pass_through;
 
-AST_String.prototype.shallow_cmp = mkshallow({
-    value: "eq"
-});
+AST_String.prototype.shallow_cmp = function(other) {
+    return this.value === other.value;
+};
 
-AST_Number.prototype.shallow_cmp = mkshallow({
-    value: "eq"
-});
+AST_Number.prototype.shallow_cmp = function(other) {
+    return this.value === other.value;
+};
 
-AST_BigInt.prototype.shallow_cmp = mkshallow({
-    value: "eq"
-});
+AST_BigInt.prototype.shallow_cmp = function(other) {
+    return this.value === other.value;
+};
 
 AST_RegExp.prototype.shallow_cmp = function (other) {
     return (

package/lib/minify.js

@@ -7,7 +7,7 @@ import {
     map_to_object,
     HOP,
 } from "./utils/index.js";
-import { AST_Toplevel, AST_Node } from "./ast.js";
+import { AST_Toplevel, AST_Node, walk, AST_Scope } from "./ast.js";
 import { parse } from "./parse.js";
 import { OutputStream } from "./output.js";
 import { Compressor } from "./compress/index.js";
@@ -194,6 +194,8 @@ async function minify(files, options, _fs_module) {
             url: null,
         }, true);
     }
+
+    // -- Parse phase --
     if (timings) timings.parse = Date.now();
     var toplevel;
     if (files instanceof AST_Toplevel) {
@@ -243,12 +245,16 @@ async function minify(files, options, _fs_module) {
         toplevel.figure_out_scope(options.mangle);
         toplevel.expand_names(options.mangle);
     }
+
+    // -- Compress phase --
     if (timings) timings.compress = Date.now();
     if (options.compress) {
         toplevel = new Compressor(options.compress, {
             mangle_options: options.mangle
         }).compress(toplevel);
     }
+
+    // -- Mangle phase --
     if (timings) timings.scope = Date.now();
     if (options.mangle) toplevel.figure_out_scope(options.mangle);
     if (timings) timings.mangle = Date.now();
@@ -261,6 +267,8 @@ async function minify(files, options, _fs_module) {
     if (options.mangle && options.mangle.properties) {
         toplevel = mangle_properties(toplevel, options.mangle.properties);
     }
+
+    // Format phase
     if (timings) timings.format = Date.now();
     var result = {};
     if (options.format.ast) {
@@ -270,19 +278,34 @@ async function minify(files, options, _fs_module) {
         result.ast = toplevel.to_mozilla_ast();
     }
     if (!HOP(options.format, "code") || options.format.code) {
+        if (!options.format.ast) {
+            // Destroy stuff to save RAM. (unless the deprecated `ast` option is on)
+            options.format._destroy_ast = true;
+
+            walk(toplevel, node => {
+                if (node instanceof AST_Scope) {
+                    node.variables = undefined;
+                    node.enclosed = undefined;
+                    node.parent_scope = undefined;
+                }
+                if (node.block_scope) {
+                    node.block_scope.variables = undefined;
+                    node.block_scope.enclosed = undefined;
+                    node.parent_scope = undefined;
+                }
+            });
+        }
+
         if (options.sourceMap) {
+            if (options.sourceMap.includeSources && files instanceof AST_Toplevel) {
+                throw new Error("original source content unavailable");
+            }
             options.format.source_map = await SourceMap({
                 file: options.sourceMap.filename,
                 orig: options.sourceMap.content,
-                root: options.sourceMap.root
+                root: options.sourceMap.root,
+                files: options.sourceMap.includeSources ? files : null,
             });
-            if (options.sourceMap.includeSources) {
-                if (files instanceof AST_Toplevel) {
-                    throw new Error("original source content unavailable");
-                } else for (var name in files) if (HOP(files, name)) {
-                    options.format.source_map.get().setSourceContent(name, files[name]);
-                }
-            }
         }
         delete options.format.ast;
         delete options.format.code;
@@ -291,11 +314,21 @@ async function minify(files, options, _fs_module) {
         toplevel.print(stream);
         result.code = stream.get();
         if (options.sourceMap) {
-            if(options.sourceMap.asObject) {
-                result.map = options.format.source_map.get().toJSON();
-            } else {
-                result.map = options.format.source_map.toString();
-            }
+            Object.defineProperty(result, "map", {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    const map = options.format.source_map.getEncoded();
+                    return (result.map = options.sourceMap.asObject ? map : JSON.stringify(map));
+                },
+                set(value) {
+                    Object.defineProperty(result, "map", {
+                        value,
+                        writable: true,
+                    });
+                }
+            });
+            result.decoded_map = options.format.source_map.getDecoded();
             if (options.sourceMap.url == "inline") {
                 var sourceMap = typeof result.map === "object" ? JSON.stringify(result.map) : result.map;
                 result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(sourceMap);