$

node_modules/terser/lib/compress/common.js

@@ -0,0 +1,344 @@
+/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+
+import {
+    AST_Array,
+    AST_Arrow,
+    AST_BlockStatement,
+    AST_Call,
+    AST_Class,
+    AST_Const,
+    AST_Constant,
+    AST_DefClass,
+    AST_Defun,
+    AST_EmptyStatement,
+    AST_Export,
+    AST_False,
+    AST_Function,
+    AST_Import,
+    AST_Infinity,
+    AST_LabeledStatement,
+    AST_Lambda,
+    AST_Let,
+    AST_LoopControl,
+    AST_NaN,
+    AST_Node,
+    AST_Null,
+    AST_Number,
+    AST_Object,
+    AST_ObjectKeyVal,
+    AST_PropAccess,
+    AST_RegExp,
+    AST_Scope,
+    AST_Sequence,
+    AST_SimpleStatement,
+    AST_Statement,
+    AST_String,
+    AST_SymbolRef,
+    AST_True,
+    AST_UnaryPrefix,
+    AST_Undefined,
+
+    TreeWalker,
+    walk,
+    walk_abort,
+    walk_parent,
+} from "../ast.js";
+import { make_node, regexp_source_fix, string_template, makePredicate } from "../utils/index.js";
+import { first_in_statement } from "../utils/first_in_statement.js";
+import { has_flag, TOP } from "./compressor-flags.js";
+
+export function merge_sequence(array, node) {
+    if (node instanceof AST_Sequence) {
+        array.push(...node.expressions);
+    } else {
+        array.push(node);
+    }
+    return array;
+}
+
+export function make_sequence(orig, expressions) {
+    if (expressions.length == 1) return expressions[0];
+    if (expressions.length == 0) throw new Error("trying to create a sequence with length zero!");
+    return make_node(AST_Sequence, orig, {
+        expressions: expressions.reduce(merge_sequence, [])
+    });
+}
+
+export function make_node_from_constant(val, orig) {
+    switch (typeof val) {
+      case "string":
+        return make_node(AST_String, orig, {
+            value: val
+        });
+      case "number":
+        if (isNaN(val)) return make_node(AST_NaN, orig);
+        if (isFinite(val)) {
+            return 1 / val < 0 ? make_node(AST_UnaryPrefix, orig, {
+                operator: "-",
+                expression: make_node(AST_Number, orig, { value: -val })
+            }) : make_node(AST_Number, orig, { value: val });
+        }
+        return val < 0 ? make_node(AST_UnaryPrefix, orig, {
+            operator: "-",
+            expression: make_node(AST_Infinity, orig)
+        }) : make_node(AST_Infinity, orig);
+      case "boolean":
+        return make_node(val ? AST_True : AST_False, orig);
+      case "undefined":
+        return make_node(AST_Undefined, orig);
+      default:
+        if (val === null) {
+            return make_node(AST_Null, orig, { value: null });
+        }
+        if (val instanceof RegExp) {
+            return make_node(AST_RegExp, orig, {
+                value: {
+                    source: regexp_source_fix(val.source),
+                    flags: val.flags
+                }
+            });
+        }
+        throw new Error(string_template("Can't handle constant of type: {type}", {
+            type: typeof val
+        }));
+    }
+}
+
+export function best_of_expression(ast1, ast2) {
+    return ast1.size() > ast2.size() ? ast2 : ast1;
+}
+
+export function best_of_statement(ast1, ast2) {
+    return best_of_expression(
+        make_node(AST_SimpleStatement, ast1, {
+            body: ast1
+        }),
+        make_node(AST_SimpleStatement, ast2, {
+            body: ast2
+        })
+    ).body;
+}
+
+/** Find which node is smaller, and return that */
+export function best_of(compressor, ast1, ast2) {
+    if (first_in_statement(compressor)) {
+        return best_of_statement(ast1, ast2);
+    } else {
+        return best_of_expression(ast1, ast2);
+    }
+}
+
+/** Simplify an object property's key, if possible */
+export function get_simple_key(key) {
+    if (key instanceof AST_Constant) {
+        return key.getValue();
+    }
+    if (key instanceof AST_UnaryPrefix
+        && key.operator == "void"
+        && key.expression instanceof AST_Constant) {
+        return;
+    }
+    return key;
+}
+
+export function read_property(obj, key) {
+    key = get_simple_key(key);
+    if (key instanceof AST_Node) return;
+
+    var value;
+    if (obj instanceof AST_Array) {
+        var elements = obj.elements;
+        if (key == "length") return make_node_from_constant(elements.length, obj);
+        if (typeof key == "number" && key in elements) value = elements[key];
+    } else if (obj instanceof AST_Object) {
+        key = "" + key;
+        var props = obj.properties;
+        for (var i = props.length; --i >= 0;) {
+            var prop = props[i];
+            if (!(prop instanceof AST_ObjectKeyVal)) return;
+            if (!value && props[i].key === key) value = props[i].value;
+        }
+    }
+
+    return value instanceof AST_SymbolRef && value.fixed_value() || value;
+}
+
+export function has_break_or_continue(loop, parent) {
+    var found = false;
+    var tw = new TreeWalker(function(node) {
+        if (found || node instanceof AST_Scope) return true;
+        if (node instanceof AST_LoopControl && tw.loopcontrol_target(node) === loop) {
+            return found = true;
+        }
+    });
+    if (parent instanceof AST_LabeledStatement) tw.push(parent);
+    tw.push(loop);
+    loop.body.walk(tw);
+    return found;
+}
+
+// we shouldn't compress (1,func)(something) to
+// func(something) because that changes the meaning of
+// the func (becomes lexical instead of global).
+export function maintain_this_binding(parent, orig, val) {
+    if (
+        parent instanceof AST_UnaryPrefix && parent.operator == "delete"
+        || parent instanceof AST_Call && parent.expression === orig
+            && (
+                val instanceof AST_PropAccess
+                || val instanceof AST_SymbolRef && val.name == "eval"
+            )
+    ) {
+        const zero = make_node(AST_Number, orig, { value: 0 });
+        return make_sequence(orig, [ zero, val ]);
+    } else {
+        return val;
+    }
+}
+
+export function is_func_expr(node) {
+    return node instanceof AST_Arrow || node instanceof AST_Function;
+}
+
+export function is_iife_call(node) {
+    // Used to determine whether the node can benefit from negation.
+    // Not the case with arrow functions (you need an extra set of parens).
+    if (node.TYPE != "Call") return false;
+    return node.expression instanceof AST_Function || is_iife_call(node.expression);
+}
+
+export function is_empty(thing) {
+    if (thing === null) return true;
+    if (thing instanceof AST_EmptyStatement) return true;
+    if (thing instanceof AST_BlockStatement) return thing.body.length == 0;
+    return false;
+}
+
+export const identifier_atom = makePredicate("Infinity NaN undefined");
+export function is_identifier_atom(node) {
+    return node instanceof AST_Infinity
+        || node instanceof AST_NaN
+        || node instanceof AST_Undefined;
+}
+
+/** Check if this is a SymbolRef node which has one def of a certain AST type */
+export function is_ref_of(ref, type) {
+    if (!(ref instanceof AST_SymbolRef)) return false;
+    var orig = ref.definition().orig;
+    for (var i = orig.length; --i >= 0;) {
+        if (orig[i] instanceof type) return true;
+    }
+}
+
+// Can we turn { block contents... } into just the block contents ?
+// Not if one of these is inside.
+export function can_be_evicted_from_block(node) {
+    return !(
+        node instanceof AST_DefClass ||
+        node instanceof AST_Defun ||
+        node instanceof AST_Let ||
+        node instanceof AST_Const ||
+        node instanceof AST_Export ||
+        node instanceof AST_Import
+    );
+}
+
+export function as_statement_array(thing) {
+    if (thing === null) return [];
+    if (thing instanceof AST_BlockStatement) return thing.body;
+    if (thing instanceof AST_EmptyStatement) return [];
+    if (thing instanceof AST_Statement) return [ thing ];
+    throw new Error("Can't convert thing to statement array");
+}
+
+export function is_reachable(scope_node, defs) {
+    const find_ref = node => {
+        if (node instanceof AST_SymbolRef && defs.includes(node.definition())) {
+            return walk_abort;
+        }
+    };
+
+    return walk_parent(scope_node, (node, info) => {
+        if (node instanceof AST_Scope && node !== scope_node) {
+            var parent = info.parent();
+
+            if (
+                parent instanceof AST_Call
+                && parent.expression === node
+                // Async/Generators aren't guaranteed to sync evaluate all of
+                // their body steps, so it's possible they close over the variable.
+                && !(node.async || node.is_generator)
+            ) {
+                return;
+            }
+
+            if (walk(node, find_ref)) return walk_abort;
+
+            return true;
+        }
+    });
+}
+
+/** Check if a ref refers to the name of a function/class it's defined within */
+export function is_recursive_ref(compressor, def) {
+    var node;
+    for (var i = 0; node = compressor.parent(i); i++) {
+        if (node instanceof AST_Lambda || node instanceof AST_Class) {
+            var name = node.name;
+            if (name && name.definition() === def) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+// TODO this only works with AST_Defun, shouldn't it work for other ways of defining functions?
+export function retain_top_func(fn, compressor) {
+    return compressor.top_retain
+        && fn instanceof AST_Defun
+        && has_flag(fn, TOP)
+        && fn.name
+        && compressor.top_retain(fn.name);
+}

node_modules/terser/lib/compress/compressor-flags.js

@@ -0,0 +1,63 @@
+/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+
+// bitfield flags to be stored in node.flags.
+// These are set and unset during compression, and store information in the node without requiring multiple fields.
+export const UNUSED = 0b00000001;
+export const TRUTHY = 0b00000010;
+export const FALSY = 0b00000100;
+export const UNDEFINED = 0b00001000;
+export const INLINED = 0b00010000;
+
+// Nodes to which values are ever written. Used when keep_assign is part of the unused option string.
+export const WRITE_ONLY = 0b00100000;
+
+// information specific to a single compression pass
+export const SQUEEZED = 0b0000000100000000;
+export const OPTIMIZED = 0b0000001000000000;
+export const TOP = 0b0000010000000000;
+export const CLEAR_BETWEEN_PASSES = SQUEEZED | OPTIMIZED | TOP;
+
+export const has_flag = (node, flag) => node.flags & flag;
+export const set_flag = (node, flag) => { node.flags |= flag; };
+export const clear_flag = (node, flag) => { node.flags &= ~flag; };

node_modules/terser/lib/compress/drop-side-effect-free.js

@@ -0,0 +1,350 @@
+/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+
+import {
+    AST_Accessor,
+    AST_Array,
+    AST_Arrow,
+    AST_Assign,
+    AST_Binary,
+    AST_Call,
+    AST_Chain,
+    AST_Class,
+    AST_ClassProperty,
+    AST_ConciseMethod,
+    AST_Conditional,
+    AST_Constant,
+    AST_Dot,
+    AST_Expansion,
+    AST_Function,
+    AST_Node,
+    AST_Number,
+    AST_Object,
+    AST_ObjectGetter,
+    AST_ObjectKeyVal,
+    AST_ObjectProperty,
+    AST_ObjectSetter,
+    AST_PropAccess,
+    AST_Scope,
+    AST_Sequence,
+    AST_Sub,
+    AST_SymbolRef,
+    AST_TemplateSegment,
+    AST_TemplateString,
+    AST_This,
+    AST_Unary,
+} from "../ast.js";
+import { make_node, return_null, return_this } from "../utils/index.js";
+import { first_in_statement } from "../utils/first_in_statement.js";
+
+import { pure_prop_access_globals } from "./native-objects.js";
+import { lazy_op, unary_side_effects, is_nullish_shortcircuited } from "./inference.js";
+import { WRITE_ONLY, set_flag, clear_flag } from "./compressor-flags.js";
+import { make_sequence, is_func_expr, is_iife_call } from "./common.js";
+
+// AST_Node#drop_side_effect_free() gets called when we don't care about the value,
+// only about side effects. We'll be defining this method for each node type in this module
+//
+// Examples:
+// foo++ -> foo++
+// 1 + func() -> func()
+// 10 -> (nothing)
+// knownPureFunc(foo++) -> foo++
+
+function def_drop_side_effect_free(node, func) {
+    node.DEFMETHOD("drop_side_effect_free", func);
+}
+
+// Drop side-effect-free elements from an array of expressions.
+// Returns an array of expressions with side-effects or null
+// if all elements were dropped. Note: original array may be
+// returned if nothing changed.
+function trim(nodes, compressor, first_in_statement) {
+    var len = nodes.length;
+    if (!len)  return null;
+
+    var ret = [], changed = false;
+    for (var i = 0; i < len; i++) {
+        var node = nodes[i].drop_side_effect_free(compressor, first_in_statement);
+        changed |= node !== nodes[i];
+        if (node) {
+            ret.push(node);
+            first_in_statement = false;
+        }
+    }
+    return changed ? ret.length ? ret : null : nodes;
+}
+
+def_drop_side_effect_free(AST_Node, return_this);
+def_drop_side_effect_free(AST_Constant, return_null);
+def_drop_side_effect_free(AST_This, return_null);
+
+def_drop_side_effect_free(AST_Call, function (compressor, first_in_statement) {
+    if (is_nullish_shortcircuited(this, compressor)) {
+        return this.expression.drop_side_effect_free(compressor, first_in_statement);
+    }
+
+    if (!this.is_callee_pure(compressor)) {
+        if (this.expression.is_call_pure(compressor)) {
+            var exprs = this.args.slice();
+            exprs.unshift(this.expression.expression);
+            exprs = trim(exprs, compressor, first_in_statement);
+            return exprs && make_sequence(this, exprs);
+        }
+        if (is_func_expr(this.expression)
+            && (!this.expression.name || !this.expression.name.definition().references.length)) {
+            var node = this.clone();
+            node.expression.process_expression(false, compressor);
+            return node;
+        }
+        return this;
+    }
+
+    var args = trim(this.args, compressor, first_in_statement);
+    return args && make_sequence(this, args);
+});
+
+def_drop_side_effect_free(AST_Accessor, return_null);
+
+def_drop_side_effect_free(AST_Function, return_null);
+
+def_drop_side_effect_free(AST_Arrow, return_null);
+
+def_drop_side_effect_free(AST_Class, function (compressor) {
+    const with_effects = [];
+    const trimmed_extends = this.extends && this.extends.drop_side_effect_free(compressor);
+    if (trimmed_extends)
+        with_effects.push(trimmed_extends);
+    for (const prop of this.properties) {
+        const trimmed_prop = prop.drop_side_effect_free(compressor);
+        if (trimmed_prop)
+            with_effects.push(trimmed_prop);
+    }
+    if (!with_effects.length)
+        return null;
+    return make_sequence(this, with_effects);
+});
+
+def_drop_side_effect_free(AST_Binary, function (compressor, first_in_statement) {
+    var right = this.right.drop_side_effect_free(compressor);
+    if (!right)
+        return this.left.drop_side_effect_free(compressor, first_in_statement);
+    if (lazy_op.has(this.operator)) {
+        if (right === this.right)
+            return this;
+        var node = this.clone();
+        node.right = right;
+        return node;
+    } else {
+        var left = this.left.drop_side_effect_free(compressor, first_in_statement);
+        if (!left)
+            return this.right.drop_side_effect_free(compressor, first_in_statement);
+        return make_sequence(this, [left, right]);
+    }
+});
+
+def_drop_side_effect_free(AST_Assign, function (compressor) {
+    if (this.logical)
+        return this;
+
+    var left = this.left;
+    if (left.has_side_effects(compressor)
+        || compressor.has_directive("use strict")
+        && left instanceof AST_PropAccess
+        && left.expression.is_constant()) {
+        return this;
+    }
+    set_flag(this, WRITE_ONLY);
+    while (left instanceof AST_PropAccess) {
+        left = left.expression;
+    }
+    if (left.is_constant_expression(compressor.find_parent(AST_Scope))) {
+        return this.right.drop_side_effect_free(compressor);
+    }
+    return this;
+});
+
+def_drop_side_effect_free(AST_Conditional, function (compressor) {
+    var consequent = this.consequent.drop_side_effect_free(compressor);
+    var alternative = this.alternative.drop_side_effect_free(compressor);
+    if (consequent === this.consequent && alternative === this.alternative)
+        return this;
+    if (!consequent)
+        return alternative ? make_node(AST_Binary, this, {
+            operator: "||",
+            left: this.condition,
+            right: alternative
+        }) : this.condition.drop_side_effect_free(compressor);
+    if (!alternative)
+        return make_node(AST_Binary, this, {
+            operator: "&&",
+            left: this.condition,
+            right: consequent
+        });
+    var node = this.clone();
+    node.consequent = consequent;
+    node.alternative = alternative;
+    return node;
+});
+
+def_drop_side_effect_free(AST_Unary, function (compressor, first_in_statement) {
+    if (unary_side_effects.has(this.operator)) {
+        if (!this.expression.has_side_effects(compressor)) {
+            set_flag(this, WRITE_ONLY);
+        } else {
+            clear_flag(this, WRITE_ONLY);
+        }
+        return this;
+    }
+    if (this.operator == "typeof" && this.expression instanceof AST_SymbolRef)
+        return null;
+    var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
+    if (first_in_statement && expression && is_iife_call(expression)) {
+        if (expression === this.expression && this.operator == "!")
+            return this;
+        return expression.negate(compressor, first_in_statement);
+    }
+    return expression;
+});
+
+def_drop_side_effect_free(AST_SymbolRef, function (compressor) {
+    const safe_access = this.is_declared(compressor)
+        || pure_prop_access_globals.has(this.name);
+    return safe_access ? null : this;
+});
+
+def_drop_side_effect_free(AST_Object, function (compressor, first_in_statement) {
+    var values = trim(this.properties, compressor, first_in_statement);
+    return values && make_sequence(this, values);
+});
+
+def_drop_side_effect_free(AST_ObjectProperty, function (compressor, first_in_statement) {
+    const computed_key = this instanceof AST_ObjectKeyVal && this.key instanceof AST_Node;
+    const key = computed_key && this.key.drop_side_effect_free(compressor, first_in_statement);
+    const value = this.value && this.value.drop_side_effect_free(compressor, first_in_statement);
+    if (key && value) {
+        return make_sequence(this, [key, value]);
+    }
+    return key || value;
+});
+
+def_drop_side_effect_free(AST_ClassProperty, function (compressor) {
+    const key = this.computed_key() && this.key.drop_side_effect_free(compressor);
+
+    const value = this.static && this.value
+        && this.value.drop_side_effect_free(compressor);
+
+    if (key && value)
+        return make_sequence(this, [key, value]);
+    return key || value || null;
+});
+
+def_drop_side_effect_free(AST_ConciseMethod, function () {
+    return this.computed_key() ? this.key : null;
+});
+
+def_drop_side_effect_free(AST_ObjectGetter, function () {
+    return this.computed_key() ? this.key : null;
+});
+
+def_drop_side_effect_free(AST_ObjectSetter, function () {
+    return this.computed_key() ? this.key : null;
+});
+
+def_drop_side_effect_free(AST_Array, function (compressor, first_in_statement) {
+    var values = trim(this.elements, compressor, first_in_statement);
+    return values && make_sequence(this, values);
+});
+
+def_drop_side_effect_free(AST_Dot, function (compressor, first_in_statement) {
+    if (is_nullish_shortcircuited(this, compressor)) {
+        return this.expression.drop_side_effect_free(compressor, first_in_statement);
+    }
+    if (this.expression.may_throw_on_access(compressor)) return this;
+
+    return this.expression.drop_side_effect_free(compressor, first_in_statement);
+});
+
+def_drop_side_effect_free(AST_Sub, function (compressor, first_in_statement) {
+    if (is_nullish_shortcircuited(this, compressor)) {
+        return this.expression.drop_side_effect_free(compressor, first_in_statement);
+    }
+    if (this.expression.may_throw_on_access(compressor)) return this;
+
+    var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
+    if (!expression)
+        return this.property.drop_side_effect_free(compressor, first_in_statement);
+    var property = this.property.drop_side_effect_free(compressor);
+    if (!property)
+        return expression;
+    return make_sequence(this, [expression, property]);
+});
+
+def_drop_side_effect_free(AST_Chain, function (compressor, first_in_statement) {
+    return this.expression.drop_side_effect_free(compressor, first_in_statement);
+});
+
+def_drop_side_effect_free(AST_Sequence, function (compressor) {
+    var last = this.tail_node();
+    var expr = last.drop_side_effect_free(compressor);
+    if (expr === last)
+        return this;
+    var expressions = this.expressions.slice(0, -1);
+    if (expr)
+        expressions.push(expr);
+    if (!expressions.length) {
+        return make_node(AST_Number, this, { value: 0 });
+    }
+    return make_sequence(this, expressions);
+});
+
+def_drop_side_effect_free(AST_Expansion, function (compressor, first_in_statement) {
+    return this.expression.drop_side_effect_free(compressor, first_in_statement);
+});
+
+def_drop_side_effect_free(AST_TemplateSegment, return_null);
+
+def_drop_side_effect_free(AST_TemplateString, function (compressor) {
+    var values = trim(this.segments, compressor, first_in_statement);
+    return values && make_sequence(this, values);
+});

node_modules/terser/lib/compress/evaluate.js

@@ -0,0 +1,462 @@
+/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+
+import {
+    HOP,
+    makePredicate,
+    return_this,
+    string_template,
+    regexp_source_fix,
+    regexp_is_safe,
+} from "../utils/index.js";
+import {
+    AST_Array,
+    AST_BigInt,
+    AST_Binary,
+    AST_Call,
+    AST_Chain,
+    AST_Class,
+    AST_Conditional,
+    AST_Constant,
+    AST_Dot,
+    AST_Expansion,
+    AST_Function,
+    AST_Lambda,
+    AST_New,
+    AST_Node,
+    AST_Object,
+    AST_PropAccess,
+    AST_RegExp,
+    AST_Statement,
+    AST_Symbol,
+    AST_SymbolRef,
+    AST_TemplateString,
+    AST_UnaryPrefix,
+    AST_With,
+} from "../ast.js";
+import { is_undeclared_ref} from "./inference.js";
+import { is_pure_native_value, is_pure_native_fn, is_pure_native_method } from "./native-objects.js";
+
+// methods to evaluate a constant expression
+
+function def_eval(node, func) {
+    node.DEFMETHOD("_eval", func);
+}
+
+// Used to propagate a nullish short-circuit signal upwards through the chain.
+export const nullish = Symbol("This AST_Chain is nullish");
+
+// If the node has been successfully reduced to a constant,
+// then its value is returned; otherwise the element itself
+// is returned.
+// They can be distinguished as constant value is never a
+// descendant of AST_Node.
+AST_Node.DEFMETHOD("evaluate", function (compressor) {
+    if (!compressor.option("evaluate"))
+        return this;
+    var val = this._eval(compressor, 1);
+    if (!val || val instanceof RegExp)
+        return val;
+    if (typeof val == "function" || typeof val == "object" || val == nullish)
+        return this;
+    return val;
+});
+
+var unaryPrefix = makePredicate("! ~ - + void");
+AST_Node.DEFMETHOD("is_constant", function () {
+    // Accomodate when compress option evaluate=false
+    // as well as the common constant expressions !0 and -1
+    if (this instanceof AST_Constant) {
+        return !(this instanceof AST_RegExp);
+    } else {
+        return this instanceof AST_UnaryPrefix
+            && this.expression instanceof AST_Constant
+            && unaryPrefix.has(this.operator);
+    }
+});
+
+def_eval(AST_Statement, function () {
+    throw new Error(string_template("Cannot evaluate a statement [{file}:{line},{col}]", this.start));
+});
+
+def_eval(AST_Lambda, return_this);
+def_eval(AST_Class, return_this);
+def_eval(AST_Node, return_this);
+def_eval(AST_Constant, function () {
+    return this.getValue();
+});
+
+def_eval(AST_BigInt, return_this);
+
+def_eval(AST_RegExp, function (compressor) {
+    let evaluated = compressor.evaluated_regexps.get(this.value);
+    if (evaluated === undefined && regexp_is_safe(this.value.source)) {
+        try {
+            const { source, flags } = this.value;
+            evaluated = new RegExp(source, flags);
+        } catch (e) {
+            evaluated = null;
+        }
+        compressor.evaluated_regexps.set(this.value, evaluated);
+    }
+    return evaluated || this;
+});
+
+def_eval(AST_TemplateString, function () {
+    if (this.segments.length !== 1) return this;
+    return this.segments[0].value;
+});
+
+def_eval(AST_Function, function (compressor) {
+    if (compressor.option("unsafe")) {
+        var fn = function () { };
+        fn.node = this;
+        fn.toString = () => this.print_to_string();
+        return fn;
+    }
+    return this;
+});
+
+def_eval(AST_Array, function (compressor, depth) {
+    if (compressor.option("unsafe")) {
+        var elements = [];
+        for (var i = 0, len = this.elements.length; i < len; i++) {
+            var element = this.elements[i];
+            var value = element._eval(compressor, depth);
+            if (element === value)
+                return this;
+            elements.push(value);
+        }
+        return elements;
+    }
+    return this;
+});
+
+def_eval(AST_Object, function (compressor, depth) {
+    if (compressor.option("unsafe")) {
+        var val = {};
+        for (var i = 0, len = this.properties.length; i < len; i++) {
+            var prop = this.properties[i];
+            if (prop instanceof AST_Expansion)
+                return this;
+            var key = prop.key;
+            if (key instanceof AST_Symbol) {
+                key = key.name;
+            } else if (key instanceof AST_Node) {
+                key = key._eval(compressor, depth);
+                if (key === prop.key)
+                    return this;
+            }
+            if (typeof Object.prototype[key] === "function") {
+                return this;
+            }
+            if (prop.value instanceof AST_Function)
+                continue;
+            val[key] = prop.value._eval(compressor, depth);
+            if (val[key] === prop.value)
+                return this;
+        }
+        return val;
+    }
+    return this;
+});
+
+var non_converting_unary = makePredicate("! typeof void");
+def_eval(AST_UnaryPrefix, function (compressor, depth) {
+    var e = this.expression;
+    // Function would be evaluated to an array and so typeof would
+    // incorrectly return 'object'. Hence making is a special case.
+    if (compressor.option("typeofs")
+        && this.operator == "typeof"
+        && (e instanceof AST_Lambda
+            || e instanceof AST_SymbolRef
+            && e.fixed_value() instanceof AST_Lambda)) {
+        return typeof function () { };
+    }
+    if (!non_converting_unary.has(this.operator))
+        depth++;
+    e = e._eval(compressor, depth);
+    if (e === this.expression)
+        return this;
+    switch (this.operator) {
+        case "!": return !e;
+        case "typeof":
+            // typeof <RegExp> returns "object" or "function" on different platforms
+            // so cannot evaluate reliably
+            if (e instanceof RegExp)
+                return this;
+            return typeof e;
+        case "void": return void e;
+        case "~": return ~e;
+        case "-": return -e;
+        case "+": return +e;
+    }
+    return this;
+});
+
+var non_converting_binary = makePredicate("&& || ?? === !==");
+const identity_comparison = makePredicate("== != === !==");
+const has_identity = value => typeof value === "object"
+    || typeof value === "function"
+    || typeof value === "symbol";
+
+def_eval(AST_Binary, function (compressor, depth) {
+    if (!non_converting_binary.has(this.operator))
+        depth++;
+
+    var left = this.left._eval(compressor, depth);
+    if (left === this.left)
+        return this;
+    var right = this.right._eval(compressor, depth);
+    if (right === this.right)
+        return this;
+    var result;
+
+    if (left != null
+        && right != null
+        && identity_comparison.has(this.operator)
+        && has_identity(left)
+        && has_identity(right)
+        && typeof left === typeof right) {
+        // Do not compare by reference
+        return this;
+    }
+
+    switch (this.operator) {
+        case "&&": result = left && right; break;
+        case "||": result = left || right; break;
+        case "??": result = left != null ? left : right; break;
+        case "|": result = left | right; break;
+        case "&": result = left & right; break;
+        case "^": result = left ^ right; break;
+        case "+": result = left + right; break;
+        case "*": result = left * right; break;
+        case "**": result = Math.pow(left, right); break;
+        case "/": result = left / right; break;
+        case "%": result = left % right; break;
+        case "-": result = left - right; break;
+        case "<<": result = left << right; break;
+        case ">>": result = left >> right; break;
+        case ">>>": result = left >>> right; break;
+        case "==": result = left == right; break;
+        case "===": result = left === right; break;
+        case "!=": result = left != right; break;
+        case "!==": result = left !== right; break;
+        case "<": result = left < right; break;
+        case "<=": result = left <= right; break;
+        case ">": result = left > right; break;
+        case ">=": result = left >= right; break;
+        default:
+            return this;
+    }
+    if (isNaN(result) && compressor.find_parent(AST_With)) {
+        // leave original expression as is
+        return this;
+    }
+    return result;
+});
+
+def_eval(AST_Conditional, function (compressor, depth) {
+    var condition = this.condition._eval(compressor, depth);
+    if (condition === this.condition)
+        return this;
+    var node = condition ? this.consequent : this.alternative;
+    var value = node._eval(compressor, depth);
+    return value === node ? this : value;
+});
+
+// Set of AST_SymbolRef which are currently being evaluated.
+// Avoids infinite recursion of ._eval()
+const reentrant_ref_eval = new Set();
+def_eval(AST_SymbolRef, function (compressor, depth) {
+    if (reentrant_ref_eval.has(this))
+        return this;
+
+    var fixed = this.fixed_value();
+    if (!fixed)
+        return this;
+
+    reentrant_ref_eval.add(this);
+    const value = fixed._eval(compressor, depth);
+    reentrant_ref_eval.delete(this);
+
+    if (value === fixed)
+        return this;
+
+    if (value && typeof value == "object") {
+        var escaped = this.definition().escaped;
+        if (escaped && depth > escaped)
+            return this;
+    }
+    return value;
+});
+
+const global_objs = { Array, Math, Number, Object, String };
+
+const regexp_flags = new Set([
+    "dotAll",
+    "global",
+    "ignoreCase",
+    "multiline",
+    "sticky",
+    "unicode",
+]);
+
+def_eval(AST_PropAccess, function (compressor, depth) {
+    let obj = this.expression._eval(compressor, depth + 1);
+    if (obj === nullish || (this.optional && obj == null)) return nullish;
+    if (compressor.option("unsafe")) {
+        var key = this.property;
+        if (key instanceof AST_Node) {
+            key = key._eval(compressor, depth);
+            if (key === this.property)
+                return this;
+        }
+        var exp = this.expression;
+        if (is_undeclared_ref(exp)) {
+
+            var aa;
+            var first_arg = exp.name === "hasOwnProperty"
+                && key === "call"
+                && (aa = compressor.parent() && compressor.parent().args)
+                && (aa && aa[0]
+                    && aa[0].evaluate(compressor));
+
+            first_arg = first_arg instanceof AST_Dot ? first_arg.expression : first_arg;
+
+            if (first_arg == null || first_arg.thedef && first_arg.thedef.undeclared) {
+                return this.clone();
+            }
+            if (!is_pure_native_value(exp.name, key))
+                return this;
+            obj = global_objs[exp.name];
+        } else {
+            if (obj instanceof RegExp) {
+                if (key == "source") {
+                    return regexp_source_fix(obj.source);
+                } else if (key == "flags" || regexp_flags.has(key)) {
+                    return obj[key];
+                }
+            }
+            if (!obj || obj === exp || !HOP(obj, key))
+                return this;
+
+            if (typeof obj == "function")
+                switch (key) {
+                    case "name":
+                        return obj.node.name ? obj.node.name.name : "";
+                    case "length":
+                        return obj.node.length_property();
+                    default:
+                        return this;
+                }
+        }
+        return obj[key];
+    }
+    return this;
+});
+
+def_eval(AST_Chain, function (compressor, depth) {
+    const evaluated = this.expression._eval(compressor, depth);
+    return evaluated === nullish
+        ? undefined
+        : evaluated === this.expression
+          ? this
+          : evaluated;
+});
+
+def_eval(AST_Call, function (compressor, depth) {
+    var exp = this.expression;
+
+    const callee = exp._eval(compressor, depth);
+    if (callee === nullish || (this.optional && callee == null)) return nullish;
+
+    if (compressor.option("unsafe") && exp instanceof AST_PropAccess) {
+        var key = exp.property;
+        if (key instanceof AST_Node) {
+            key = key._eval(compressor, depth);
+            if (key === exp.property)
+                return this;
+        }
+        var val;
+        var e = exp.expression;
+        if (is_undeclared_ref(e)) {
+            var first_arg = e.name === "hasOwnProperty" &&
+                key === "call" &&
+                (this.args[0] && this.args[0].evaluate(compressor));
+
+            first_arg = first_arg instanceof AST_Dot ? first_arg.expression : first_arg;
+
+            if ((first_arg == null || first_arg.thedef && first_arg.thedef.undeclared)) {
+                return this.clone();
+            }
+            if (!is_pure_native_fn(e.name, key)) return this;
+            val = global_objs[e.name];
+        } else {
+            val = e._eval(compressor, depth + 1);
+            if (val === e || !val)
+                return this;
+            if (!is_pure_native_method(val.constructor.name, key))
+                return this;
+        }
+        var args = [];
+        for (var i = 0, len = this.args.length; i < len; i++) {
+            var arg = this.args[i];
+            var value = arg._eval(compressor, depth);
+            if (arg === value)
+                return this;
+            if (arg instanceof AST_Lambda)
+                return this;
+            args.push(value);
+        }
+        try {
+            return val[key].apply(val, args);
+        } catch (ex) {
+            // We don't really care
+        }
+    }
+    return this;
+});
+
+// Also a subclass of AST_Call
+def_eval(AST_New, return_this);

node_modules/terser/lib/compress/native-objects.js

@@ -0,0 +1,184 @@
+/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+
+import { makePredicate } from "../utils/index.js";
+
+// Lists of native methods, useful for `unsafe` option which assumes they exist.
+// Note: Lots of methods and functions are missing here, in case they aren't pure
+// or not available in all JS environments.
+
+function make_nested_lookup(obj) {
+    const out = new Map();
+    for (var key of Object.keys(obj)) {
+        out.set(key, makePredicate(obj[key]));
+    }
+
+    const does_have = (global_name, fname) => {
+        const inner_map = out.get(global_name);
+        return inner_map != null && inner_map.has(fname);
+    };
+    return does_have;
+}
+
+// Objects which are safe to access without throwing or causing a side effect.
+// Usually we'd check the `unsafe` option first but these are way too common for that
+export const pure_prop_access_globals = new Set([
+    "Number",
+    "String",
+    "Array",
+    "Object",
+    "Function",
+    "Promise",
+]);
+
+const object_methods = [
+    "constructor",
+    "toString",
+    "valueOf",
+];
+
+export const is_pure_native_method = make_nested_lookup({
+    Array: [
+        "indexOf",
+        "join",
+        "lastIndexOf",
+        "slice",
+        ...object_methods,
+    ],
+    Boolean: object_methods,
+    Function: object_methods,
+    Number: [
+        "toExponential",
+        "toFixed",
+        "toPrecision",
+        ...object_methods,
+    ],
+    Object: object_methods,
+    RegExp: [
+        "test",
+        ...object_methods,
+    ],
+    String: [
+        "charAt",
+        "charCodeAt",
+        "concat",
+        "indexOf",
+        "italics",
+        "lastIndexOf",
+        "match",
+        "replace",
+        "search",
+        "slice",
+        "split",
+        "substr",
+        "substring",
+        "toLowerCase",
+        "toUpperCase",
+        "trim",
+        ...object_methods,
+    ],
+});
+
+export const is_pure_native_fn = make_nested_lookup({
+    Array: [
+        "isArray",
+    ],
+    Math: [
+        "abs",
+        "acos",
+        "asin",
+        "atan",
+        "ceil",
+        "cos",
+        "exp",
+        "floor",
+        "log",
+        "round",
+        "sin",
+        "sqrt",
+        "tan",
+        "atan2",
+        "pow",
+        "max",
+        "min",
+    ],
+    Number: [
+        "isFinite",
+        "isNaN",
+    ],
+    Object: [
+        "create",
+        "getOwnPropertyDescriptor",
+        "getOwnPropertyNames",
+        "getPrototypeOf",
+        "isExtensible",
+        "isFrozen",
+        "isSealed",
+        "hasOwn",
+        "keys",
+    ],
+    String: [
+        "fromCharCode",
+    ],
+});
+
+// Known numeric values which come with JS environments
+export const is_pure_native_value = make_nested_lookup({
+    Math: [
+        "E",
+        "LN10",
+        "LN2",
+        "LOG2E",
+        "LOG10E",
+        "PI",
+        "SQRT1_2",
+        "SQRT2",
+    ],
+    Number: [
+        "MAX_VALUE",
+        "MIN_VALUE",
+        "NaN",
+        "NEGATIVE_INFINITY",
+        "POSITIVE_INFINITY",
+    ],
+});