PrivateCoffee/wishthis
4
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Switch FUi to stable channel

Browse source
This commit is contained in:
grandeljay 2022-10-10 10:26:02 +02:00
parent 44318823f3
commit f839fb1077
1170 changed files with 8538 additions and 42067 deletions
Download patch file Download diff file Expand all files Collapse all files

2
node_modules/uglify-js/lib/ast.js generated vendored
View file

@ -332,7 +332,7 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
var AST_BlockScope = DEFNODE("BlockScope", "_var_names enclosed functions make_def parent_scope variables", {
$documentation: "Base class for all statements introducing a lexical scope",
$propdoc: {
enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any inner scopes",
functions: "[Dictionary/S] like `variables`, but only lists function declarations",
parent_scope: "[AST_Scope?/S] link to the parent scope",
variables: "[Dictionary/S] a map of name ---> SymbolDef for all variables/functions defined in this scope",

187
node_modules/uglify-js/lib/compress.js generated vendored
View file

@ -368,7 +368,6 @@ Compressor.prototype.compress = function(node) {
args: [],
});
}
return self;
});
AST_Node.DEFMETHOD("wrap_expression", function() {
var self = this;
@ -497,6 +496,7 @@ Compressor.prototype.compress = function(node) {
function has_escaped(d, scope, node, parent) {
if (parent instanceof AST_Assign) return parent.operator == "=" && parent.right === node;
if (parent instanceof AST_Call) return parent.expression !== node || parent instanceof AST_New;
if (parent instanceof AST_ClassField) return parent.value === node && !parent.static;
if (parent instanceof AST_Exit) return parent.value === node && scope.resolve() !== d.scope.resolve();
if (parent instanceof AST_VarDef) return parent.value === node;
}
@ -1164,7 +1164,11 @@ Compressor.prototype.compress = function(node) {
if (node.extends) node.extends.walk(tw);
var props = node.properties.filter(function(prop) {
reset_flags(prop);
if (prop.key instanceof AST_Node) prop.key.walk(tw);
if (prop.key instanceof AST_Node) {
tw.push(prop);
prop.key.walk(tw);
tw.pop();
}
return prop.value;
});
if (node.name) {
@ -1184,6 +1188,7 @@ Compressor.prototype.compress = function(node) {
}
}
props.forEach(function(prop) {
tw.push(prop);
if (!prop.static || is_static_field_or_init(prop) && prop.value.contains_this()) {
push(tw);
prop.value.walk(tw);
@ -1191,6 +1196,7 @@ Compressor.prototype.compress = function(node) {
} else {
prop.value.walk(tw);
}
tw.pop();
});
return true;
});
@ -1741,6 +1747,7 @@ Compressor.prototype.compress = function(node) {
var identifier_atom = makePredicate("Infinity NaN undefined");
function is_lhs_read_only(lhs, compressor) {
if (lhs instanceof AST_Atom) return true;
if (lhs instanceof AST_ObjectIdentity) return true;
if (lhs instanceof AST_PropAccess) {
if (lhs.property === "__proto__") return true;
@ -3529,6 +3536,7 @@ Compressor.prototype.compress = function(node) {
var declare_only, jump, merge_jump;
var in_iife = in_lambda && parent && parent.TYPE == "Call" && parent.expression === self;
var chain_if_returns = in_lambda && compressor.option("conditionals") && compressor.option("sequences");
var drop_return_void = !(in_try && in_try.bfinally && in_async_generator(in_lambda));
var multiple_if_returns = has_multiple_if_returns(statements);
for (var i = statements.length; --i >= 0;) {
var stat = statements[i];
@ -3536,8 +3544,7 @@ Compressor.prototype.compress = function(node) {
var next = statements[j];
if (in_lambda && declare_only && !next && stat instanceof AST_Return
&& !(self instanceof AST_SwitchBranch)
&& !(in_try && in_try.bfinally && in_async_generator(in_lambda))) {
&& drop_return_void && !(self instanceof AST_SwitchBranch)) {
var body = stat.value;
if (!body) {
changed = true;
@ -3632,7 +3639,8 @@ Compressor.prototype.compress = function(node) {
var value = stat.body.value;
var in_bool = stat.body.in_bool || next instanceof AST_Return && next.in_bool;
// if (foo()) return x; return y; ---> return foo() ? x : y;
if (!stat.alternative && next instanceof AST_Return) {
if (!stat.alternative && next instanceof AST_Return
&& (drop_return_void || !value == !next.value)) {
changed = true;
stat = stat.clone();
stat.alternative = make_node(AST_BlockStatement, next, {
@ -3737,14 +3745,17 @@ Compressor.prototype.compress = function(node) {
return true;
}
if (!(ab instanceof AST_LoopControl)) return false;
if (jump && self instanceof AST_SwitchBranch) {
if (self instanceof AST_SwitchBranch) {
if (jump instanceof AST_Exit) {
if (!in_lambda) return false;
if (jump.value) return false;
} else if (compressor.loopcontrol_target(jump) !== parent) {
merge_jump = true;
} else if (jump) {
if (compressor.loopcontrol_target(jump) !== parent) return false;
merge_jump = true;
} else if (jump === false) {
return false;
}
merge_jump = true;
}
var lct = compressor.loopcontrol_target(ab);
if (ab instanceof AST_Continue) return match_target(loop_body(lct));
@ -3781,7 +3792,7 @@ Compressor.prototype.compress = function(node) {
end = statements.lastIndexOf(stop);
} else {
stop = statements[end];
if (stop !== jump) jump = null;
if (stop !== jump) jump = false;
}
var tail = statements.splice(start, end - start).filter(function(stat) {
if (stat instanceof AST_LambdaDefinition) {
@ -5071,7 +5082,7 @@ Compressor.prototype.compress = function(node) {
return static_fn && (static_fn[node.property] || expr.name == "Math" && node.property == "random");
}
// Accomodate when compress option evaluate=false
// Accommodate when compress option evaluate=false
// as well as the common constant expressions !0 and -1
(function(def) {
def(AST_Node, return_false);
@ -9335,7 +9346,7 @@ Compressor.prototype.compress = function(node) {
return !same_scope(def) || may_overlap(compressor, def);
}
}, true)) {
self.init = to_var(self.init);
self.init = to_var(self.init, self.resolve());
}
}
return self;
@ -9677,16 +9688,25 @@ Compressor.prototype.compress = function(node) {
alternative: null,
});
if (self.alternative instanceof AST_Exit && self.body.TYPE == self.alternative.TYPE) {
var exit = make_node(self.body.CTOR, self, {
value: make_node(AST_Conditional, self, {
condition: self.condition,
consequent: self.body.value || make_node(AST_Undefined, self.body).transform(compressor),
alternative: self.alternative.value
|| make_node(AST_Undefined, self.alternative).transform(compressor),
}),
});
if (exit instanceof AST_Return) exit.in_bool = self.body.in_bool || self.alternative.in_bool;
return exit;
var cons_value = self.body.value;
var alt_value = self.alternative.value;
if (!cons_value && !alt_value) return make_node(AST_BlockStatement, self, {
body: [
make_node(AST_SimpleStatement, self, { body: self.condition }),
self.body,
],
}).optimize(compressor);
if (cons_value && alt_value || !keep_return_void()) {
var exit = make_node(self.body.CTOR, self, {
value: make_node(AST_Conditional, self, {
condition: self.condition,
consequent: cons_value || make_node(AST_Undefined, self.body).transform(compressor),
alternative: alt_value || make_node(AST_Undefined, self.alternative).transform(compressor),
}),
});
if (exit instanceof AST_Return) exit.in_bool = self.body.in_bool || self.alternative.in_bool;
return exit;
}
}
if (self.body instanceof AST_If && !self.body.alternative && !self.alternative) {
self = make_node(AST_If, self, {
@ -9752,6 +9772,22 @@ Compressor.prototype.compress = function(node) {
return node instanceof AST_BlockStatement ? node.body : [ node ];
}
function keep_return_void() {
var has_finally = false, level = 0, node = compressor.self();
do {
if (node instanceof AST_Catch) {
if (compressor.parent(level).bfinally) has_finally = true;
level++;
} else if (node instanceof AST_Finally) {
level++;
} else if (node instanceof AST_Scope) {
return has_finally && in_async_generator(node);
} else if (node instanceof AST_Try) {
if (node.bfinally) has_finally = true;
}
} while (node = compressor.parent(level++));
}
function last_index(stats) {
for (var index = stats.length; --index >= 0;) {
if (!is_declaration(stats[index], true)) break;
@ -10124,14 +10160,13 @@ Compressor.prototype.compress = function(node) {
}
}
function to_var(stat) {
function to_var(stat, scope) {
return make_node(AST_Var, stat, {
definitions: stat.definitions.map(function(defn) {
return make_node(AST_VarDef, defn, {
name: defn.name.convert_symbol(AST_SymbolVar, function(name, node) {
var def = name.definition();
def.orig[def.orig.indexOf(node)] = name;
var scope = def.scope.resolve();
if (def.scope === scope) return;
def.scope = scope;
scope.variables.set(def.name, def);
@ -10157,7 +10192,7 @@ Compressor.prototype.compress = function(node) {
return !defn.name.match_symbol(function(node) {
if (node instanceof AST_SymbolDeclaration) return !can_varify(compressor, node);
}, true);
}) ? to_var(self) : self;
}) ? to_var(self, compressor.find_parent(AST_Scope)) : self;
}
OPT(AST_Const, varify);
@ -11553,6 +11588,15 @@ Compressor.prototype.compress = function(node) {
if (node instanceof AST_Unary) return true;
}
function extract_lhs(node, compressor) {
if (node instanceof AST_Assign) return is_lhs_read_only(node.left, compressor) ? node : node.left;
if (node instanceof AST_Sequence) return extract_lhs(node.tail_node(), compressor);
if (node instanceof AST_UnaryPrefix && UNARY_POSTFIX[node.operator]) {
return is_lhs_read_only(node.expression, compressor) ? node : node.expression;
}
return node;
}
function repeatable(compressor, node) {
if (node instanceof AST_Dot) return repeatable(compressor, node.expression);
if (node instanceof AST_Sub) {
@ -11595,31 +11639,32 @@ Compressor.prototype.compress = function(node) {
if (seq !== self) return seq.optimize(compressor);
}
if (compressor.option("assignments") && lazy_op[self.operator]) {
var lhs = extract_lhs(self.left, compressor);
var right = self.right;
// a || (a = x) ---> a = a || x
// a && (a = x) ---> a = a && x
if (self.left instanceof AST_SymbolRef
// (a = x) && (a = y) ---> a = (a = x) && y
if (lhs instanceof AST_SymbolRef
&& right instanceof AST_Assign
&& right.operator == "="
&& self.left.equals(right.left)) {
var left = right.left.clone();
&& lhs.equals(right.left)) {
lhs = lhs.clone();
var assign = make_node(AST_Assign, self, {
operator: "=",
left: left,
left: lhs,
right: make_node(AST_Binary, self, {
operator: self.operator,
left: self.left,
right: right.right,
}),
});
if (left.fixed) {
left.fixed = function() {
if (lhs.fixed) {
lhs.fixed = function() {
return assign.right;
};
left.fixed.assigns = [ assign ];
lhs.fixed.assigns = [ assign ];
}
var def = left.definition();
def.references.push(left);
var def = lhs.definition();
def.references.push(lhs);
def.replaced++;
return assign.optimize(compressor);
}
@ -11674,31 +11719,32 @@ Compressor.prototype.compress = function(node) {
case "||":
// void 0 !== x && null !== x ---> null != x
// void 0 === x || null === x ---> null == x
var lhs = self.left;
if (lhs.operator == self.operator) lhs = lhs.right;
var expr = lhs.right;
if (expr instanceof AST_Assign && expr.operator == "=") expr = expr.left;
if (lhs instanceof AST_Binary
&& lhs.operator == (self.operator == "&&" ? "!==" : "===")
&& self.right instanceof AST_Binary
&& lhs.operator == self.right.operator
&& (is_undefined(lhs.left, compressor) && self.right.left instanceof AST_Null
|| lhs.left instanceof AST_Null && is_undefined(self.right.left, compressor))
&& !expr.has_side_effects(compressor)
&& expr.equals(self.right.right)) {
lhs.operator = lhs.operator.slice(0, -1);
lhs.left = make_node(AST_Null, self);
return self.left;
var left = self.left;
if (!(left instanceof AST_Binary)) break;
if (left.operator != (self.operator == "&&" ? "!==" : "===")) break;
if (!(self.right instanceof AST_Binary)) break;
if (left.operator != self.right.operator) break;
if (is_undefined(left.left, compressor) && self.right.left instanceof AST_Null
|| left.left instanceof AST_Null && is_undefined(self.right.left, compressor)) {
var expr = left.right;
if (expr instanceof AST_Assign && expr.operator == "=") expr = expr.left;
if (expr.has_side_effects(compressor)) break;
if (!expr.equals(self.right.right)) break;
left.operator = left.operator.slice(0, -1);
left.left = make_node(AST_Null, self);
return left;
}
break;
}
var in_bool = false;
var parent = compressor.parent();
if (compressor.option("booleans")) {
var lhs = self.left;
var lhs = extract_lhs(self.left, compressor);
if (lazy_op[self.operator] && !lhs.has_side_effects(compressor)) {
// a || a ---> a
// (a = x) && a --> a = x
if (lhs.equals(self.right)) {
return maintain_this_binding(parent, compressor.self(), lhs).optimize(compressor);
return maintain_this_binding(parent, compressor.self(), self.left).optimize(compressor);
}
mark_duplicate_condition(compressor, lhs);
}
@ -11746,13 +11792,22 @@ Compressor.prototype.compress = function(node) {
case ">=": reverse("<="); break;
}
}
// x && (y && z) ---> x && y && z
// x || (y || z) ---> x || y || z
if (compressor.option("conditionals")
&& lazy_op[self.operator]
&& self.right instanceof AST_Binary
&& self.operator == self.right.operator) {
swap_chain(self, compressor);
if (compressor.option("conditionals") && lazy_op[self.operator]) {
if (self.left instanceof AST_Binary && self.operator == self.left.operator) {
var before = make_node(AST_Binary, self, {
operator: self.operator,
left: self.left.right,
right: self.right,
});
var after = before.optimize(compressor);
if (before !== after) {
self.left = self.left.left;
self.right = after;
}
}
// x && (y && z) ---> x && y && z
// x || (y || z) ---> x || y || z
if (self.right instanceof AST_Binary && self.operator == self.right.operator) swap_chain(self, compressor);
}
if (compressor.option("strings") && self.operator == "+") {
// "foo" + 42 + "" ---> "foo" + 42
@ -11826,7 +11881,7 @@ Compressor.prototype.compress = function(node) {
if (nullish ? ll == null : !ll) {
AST_Node.warn("Condition left of {operator} always {value} [{start}]", {
operator: self.operator,
value: nullish ? "nulish" : "false",
value: nullish ? "nullish" : "false",
start: self.start,
});
return make_sequence(self, [ self.left, self.right ]).optimize(compressor);
@ -12270,7 +12325,7 @@ Compressor.prototype.compress = function(node) {
var single_use = def.single_use && !(parent instanceof AST_Call && parent.is_expr_pure(compressor));
if (single_use) {
if (is_lambda(fixed)) {
if ((def.scope !== self.scope.resolve() || def.in_loop)
if ((def.scope !== self.scope.resolve(true) || def.in_loop)
&& (!compressor.option("reduce_funcs") || def.escaped.depth == 1 || fixed.inlined)) {
single_use = false;
} else if (def.redefined()) {
@ -12845,15 +12900,16 @@ Compressor.prototype.compress = function(node) {
}
var consequent = self.consequent;
var alternative = self.alternative;
if (repeatable(compressor, condition)) {
var cond_lhs = extract_lhs(condition, compressor);
if (repeatable(compressor, cond_lhs)) {
// x ? x : y ---> x || y
if (condition.equals(consequent)) return make_node(AST_Binary, self, {
if (cond_lhs.equals(consequent)) return make_node(AST_Binary, self, {
operator: "||",
left: condition,
right: alternative,
}).optimize(compressor);
// x ? y : x ---> x && y
if (condition.equals(alternative)) return make_node(AST_Binary, self, {
if (cond_lhs.equals(alternative)) return make_node(AST_Binary, self, {
operator: "&&",
left: condition,
right: consequent,
@ -13834,7 +13890,10 @@ Compressor.prototype.compress = function(node) {
var abort = false;
stat.walk(new TreeWalker(function(node) {
if (abort) return true;
if (async && node instanceof AST_Await || node instanceof AST_Return) return abort = true;
if (async && (node instanceof AST_Await || node instanceof AST_ForAwaitOf)
|| node instanceof AST_Return) {
return abort = true;
}
if (node instanceof AST_Scope) return true;
}));
return !abort;

20
node_modules/uglify-js/lib/output.js generated vendored
View file

@ -76,7 +76,7 @@ function OutputStream(options) {
wrap_iife : false,
}, true);
// Convert comment option to RegExp if neccessary and set up comments filter
// Convert comment option to RegExp if necessary and set up comments filter
var comment_filter = return_false; // Default case, throw all comments away
if (options.comments) {
var comments = options.comments;
@ -997,7 +997,7 @@ function OutputStream(options) {
if (self.init instanceof AST_Definitions) {
self.init.print(output);
} else {
parenthesize_for_noin(self.init, output, true);
parenthesize_for_no_in(self.init, output, true);
}
output.print(";");
output.space();
@ -1413,7 +1413,7 @@ function OutputStream(options) {
print_braced(this, output);
});
function print_definitinos(type) {
function print_definitions(type) {
return function(output) {
var self = this;
output.print(type);
@ -1426,15 +1426,15 @@ function OutputStream(options) {
if (!(p instanceof AST_IterationStatement && p.init === self)) output.semicolon();
};
}
DEFPRINT(AST_Const, print_definitinos("const"));
DEFPRINT(AST_Let, print_definitinos("let"));
DEFPRINT(AST_Var, print_definitinos("var"));
DEFPRINT(AST_Const, print_definitions("const"));
DEFPRINT(AST_Let, print_definitions("let"));
DEFPRINT(AST_Var, print_definitions("var"));
function parenthesize_for_noin(node, output, noin) {
function parenthesize_for_no_in(node, output, no_in) {
var parens = false;
// need to take some precautions here:
// https://github.com/mishoo/UglifyJS/issues/60
if (noin) node.walk(new TreeWalker(function(node) {
if (no_in) node.walk(new TreeWalker(function(node) {
if (parens) return true;
if (node instanceof AST_Binary && node.operator == "in") return parens = true;
if (node instanceof AST_Scope && !(is_arrow(node) && node.value)) return true;
@ -1450,8 +1450,8 @@ function OutputStream(options) {
output.print("=");
output.space();
var p = output.parent(1);
var noin = p instanceof AST_For || p instanceof AST_ForEnumeration;
parenthesize_for_noin(self.value, output, noin);
var no_in = p instanceof AST_For || p instanceof AST_ForEnumeration;
parenthesize_for_no_in(self.value, output, no_in);
}
});

48
node_modules/uglify-js/lib/parse.js generated vendored
View file

@ -782,7 +782,7 @@ function parse($TEXT, options) {
else if (!optional && !can_insert_semicolon()) expect(";");
}
function parenthesised() {
function parenthesized() {
expect("(");
var exp = expression();
expect(")");
@ -920,18 +920,18 @@ function parse($TEXT, options) {
next();
var body = in_loop(statement);
expect_token("keyword", "while");
var condition = parenthesised();
var condition = parenthesized();
semicolon(true);
return new AST_Do({
body : body,
condition : condition
condition : condition,
});
case "while":
next();
return new AST_While({
condition : parenthesised(),
body : in_loop(statement)
condition : parenthesized(),
body : in_loop(statement),
});
case "for":
@ -959,15 +959,13 @@ function parse($TEXT, options) {
value = expression();
semicolon();
}
return new AST_Return({
value: value
});
return new AST_Return({ value: value });
case "switch":
next();
return new AST_Switch({
expression : parenthesised(),
body : in_loop(switch_body_)
expression : parenthesized(),
body : in_loop(switch_body_),
});
case "throw":
@ -976,9 +974,7 @@ function parse($TEXT, options) {
croak("Illegal newline after 'throw'");
var value = expression();
semicolon();
return new AST_Throw({
value: value
});
return new AST_Throw({ value: value });
case "try":
next();
@ -996,8 +992,8 @@ function parse($TEXT, options) {
}
next();
return new AST_With({
expression : parenthesised(),
body : statement()
expression : parenthesized(),
body : statement(),
});
}
}
@ -1421,15 +1417,15 @@ function parse($TEXT, options) {
};
function if_() {
var cond = parenthesised(), body = statement(), belse = null;
var cond = parenthesized(), body = statement(), alt = null;
if (is("keyword", "else")) {
next();
belse = statement();
alt = statement();
}
return new AST_If({
condition : cond,
body : body,
alternative : belse
alternative : alt,
});
}
@ -2171,9 +2167,9 @@ function parse($TEXT, options) {
token_error(sym.start, "Unexpected " + sym.name + " in strict mode");
}
function as_symbol(type, noerror) {
function as_symbol(type, no_error) {
if (!is("name")) {
if (!noerror) croak("Name expected");
if (!no_error) croak("Name expected");
return null;
}
var sym = _make_symbol(type, S.token);
@ -2409,20 +2405,20 @@ function parse($TEXT, options) {
return new ctor({ operator: op, expression: expr });
}
var expr_op = function(left, min_prec, no_in) {
var expr_op = function(left, min_precision, no_in) {
var op = is("operator") ? S.token.value : null;
if (op == "in" && no_in) op = null;
var prec = op != null ? PRECEDENCE[op] : null;
if (prec != null && prec > min_prec) {
var precision = op != null ? PRECEDENCE[op] : null;
if (precision != null && precision > min_precision) {
next();
var right = expr_op(maybe_unary(no_in), op == "**" ? prec - 1 : prec, no_in);
var right = expr_op(maybe_unary(no_in), op == "**" ? precision - 1 : precision, no_in);
return expr_op(new AST_Binary({
start : left.start,
left : left,
operator : op,
right : right,
end : right.end
}), min_prec, no_in);
end : right.end,
}), min_precision, no_in);
}
return left;
};

52
node_modules/uglify-js/lib/propmangle.js generated vendored
View file

@ -124,12 +124,16 @@ function get_builtins() {
function reserve_quoted_keys(ast, reserved) {
ast.walk(new TreeWalker(function(node) {
if (node instanceof AST_ClassProperty) {
if (node.start && node.start.quote) add(node.key);
if (node instanceof AST_ClassProperty
|| node instanceof AST_DestructuredKeyVal
|| node instanceof AST_ObjectProperty) {
if (node.key instanceof AST_Node) {
addStrings(node.key, add);
} else if (node.start && node.start.quote) {
add(node.key);
}
} else if (node instanceof AST_Dot) {
if (node.quoted) add(node.property);
} else if (node instanceof AST_ObjectProperty) {
if (node.start && node.start.quote) add(node.key);
} else if (node instanceof AST_Sub) {
addStrings(node.property, add);
}
@ -156,12 +160,16 @@ function mangle_properties(ast, options) {
builtins: false,
cache: null,
debug: false,
domprops: false,
keep_quoted: false,
regex: null,
reserved: null,
}, true);
var reserved = options.builtins ? new Dictionary() : get_builtins();
if (!options.domprops && typeof domprops !== "undefined") domprops.forEach(function(name) {
reserved.set(name, true);
});
if (Array.isArray(options.reserved)) options.reserved.forEach(function(name) {
reserved.set(name, true);
});
@ -180,7 +188,7 @@ function mangle_properties(ast, options) {
var regex = options.regex;
// note debug is either false (disabled), or a string of the debug suffix to use (enabled).
// note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
// note debug may be enabled as an empty string, which is falsy. Also treat passing 'true'
// the same as passing an empty string.
var debug = options.debug !== false;
var debug_suffix;
@ -191,9 +199,7 @@ function mangle_properties(ast, options) {
// step 1: find candidates to mangle
ast.walk(new TreeWalker(function(node) {
if (node instanceof AST_Binary) {
if (node.operator == "in") addStrings(node.left, add);
} else if (node.TYPE == "Call") {
if (node.TYPE == "Call") {
var exp = node.expression;
if (exp instanceof AST_Dot) switch (exp.property) {
case "defineProperty":
@ -210,14 +216,18 @@ function mangle_properties(ast, options) {
addStrings(node.args[0], add);
break;
}
} else if (node instanceof AST_ClassProperty) {
if (typeof node.key == "string") add(node.key);
} else if (node instanceof AST_ClassProperty
|| node instanceof AST_DestructuredKeyVal
|| node instanceof AST_ObjectProperty) {
if (node.key instanceof AST_Node) {
addStrings(node.key, add);
} else {
add(node.key);
}
} else if (node instanceof AST_Dot) {
add(node.property);
} else if (node instanceof AST_ObjectProperty) {
if (typeof node.key == "string") add(node.key);
if (is_lhs(node, this.parent())) add(node.property);
} else if (node instanceof AST_Sub) {
addStrings(node.property, add);
if (is_lhs(node, this.parent())) addStrings(node.property, add);
}
}));
@ -242,12 +252,16 @@ function mangle_properties(ast, options) {
mangleStrings(node.args[0]);
break;
}
} else if (node instanceof AST_ClassProperty) {
if (typeof node.key == "string") node.key = mangle(node.key);
} else if (node instanceof AST_ClassProperty
|| node instanceof AST_DestructuredKeyVal
|| node instanceof AST_ObjectProperty) {
if (node.key instanceof AST_Node) {
mangleStrings(node.key);
} else {
node.key = mangle(node.key);
}
} else if (node instanceof AST_Dot) {
node.property = mangle(node.property);
} else if (node instanceof AST_ObjectProperty) {
if (typeof node.key == "string") node.key = mangle(node.key);
} else if (node instanceof AST_Sub) {
if (!options.keep_quoted) mangleStrings(node.property);
}
@ -303,7 +317,7 @@ function mangle_properties(ast, options) {
function mangleStrings(node) {
if (node instanceof AST_Sequence) {
mangleStrings(node.expressions.tail_node());
mangleStrings(node.tail_node());
} else if (node instanceof AST_String) {
node.value = mangle(node.value);
} else if (node instanceof AST_Conditional) {