Commit ded4ce5

/**

* terser's `top_retain`, read into what answers whether it keeps a name: a

* list of names, one string of them split by commas, a pattern, or a test.

* @param {CompressOptions["top_retain"] | undefined} setting the option

* @returns {((definition: NamedDefinition) => boolean) | null} the test, null where it keeps none

*/

const topRetainOf = (setting) => {

if (!setting) return null;

if (typeof setting === "function") return setting;

if (setting instanceof RegExp) {

return (definition) => {

setting.lastIndex = 0;

return setting.test(definition.name);

};

}

const names = new Set(

typeof setting === "string"

? setting.split(/,/).map((name) => name.trim())

: setting

);

return (definition) => names.has(definition.name);

};

/**

* terser's `global_defs`, the globals it replaces with a value, kept where the

* value is a primitive one a literal prints; a node or code, terser's `@`

* form, is not read.

* @param {CompressOptions["global_defs"] | undefined} setting the option

* @returns {Map<string, string | number | boolean | null> | null} the values by name, null where none

*/

const globalDefsOf = (setting) => {

if (!setting) return null;

/** @type {Map<string, string | number | boolean | null>} */

const values = new Map();

for (const name of Object.keys(setting)) {

const value = setting[name];

if (

name[0] !== "@" &&

(value === null ||

typeof value === "string" ||

typeof value === "number" ||

typeof value === "boolean")

) {

values.set(name, value);

}

}

return values.size === 0 ? null : values;

};

// Whether a `debugger` statement goes, and a global `Infinity` prints as written.

let dropsDebugger = false;

let keepsInfinity = false;

// The calls `pure_funcs` names, by how their callee is written.

/** @type {Set<string> | null} */

let pureFunctions = null;

// The `console` methods whose calls go, true for every one.

/** @type {Set<string> | true | null} */

let droppedConsole = null;

// The globals `global_defs` replaces, by name, each with a primitive value.

/** @type {Map<string, string | number | boolean | null> | null} */

let globalDefs = null;

// What answers whether `top_retain` keeps a top-level name.

/** @type {((definition: MinifierVariable) => boolean) | null} */

let retainsTop = null;

(!definition.global ||

(dropsToplevel && (retainsTop === null || !retainsTop(definition)))) &&

/**

* @param {number} node a name

* @returns {string | number | boolean | null | undefined} the value `global_defs` gives it, where it reads a global nothing assigns

*/

const globalDefOf = (node) => {

const name = tree.name(node);

const value = /** @type {Map<string, string | number | boolean | null>} */ (

globalDefs

).get(name);

return value !== undefined && isGlobalUndefined(node, name)

? value

: undefined;

};

/**

* A callee as `pure_funcs` names it: a name or a chain of names read off

* it with dots, as written.

* @param {number} node the callee, past parentheses

* @returns {string} its text, empty for any other callee

*/

const writtenCallee = (node) => {

const type = typeOf(node);

if (type === NodeType.Identifier) return tree.name(node);

if (

type !== NodeType.MemberExpression ||

tree.flag(Flag.computed, node) ||

tree.flag(Flag.optional, node)

) {

return "";

}

const object = writtenCallee(childOf(Field.object, node));

const property = childOf(Field.property, node);

return object === "" || typeOf(property) !== NodeType.Identifier

? ""

: `${object}.${tree.name(property)}`;

};

/**

* @param {number} node an expression, past parentheses

* @returns {boolean} whether it is a call of a `console` method `drop_console` drops, on the global `console`

*/

const callsDroppedConsole = (node) => {

if (droppedConsole === null || typeOf(node) !== NodeType.CallExpression) {

return false;

}

const callee = childOf(Field.callee, node);

if (

typeOf(callee) !== NodeType.MemberExpression ||

tree.flag(Flag.computed, callee)

) {

return false;

}

const object = childOf(Field.object, callee);

const property = childOf(Field.property, callee);

return (

typeOf(object) === NodeType.Identifier &&

isGlobalUndefined(object, "console") &&

typeOf(property) === NodeType.Identifier &&

(droppedConsole === true || droppedConsole.has(tree.name(property)))

);

};

if (

pureFunctions !== null &&

pureFunctions.has(writtenCallee(childOf(Field.callee, node)))

) {

return true;

}

if (globalDefs !== null) {

const value = globalDefOf(node);

if (value !== undefined) return value;

}

} else if (

(statementType === NodeType.DebuggerStatement && dropsDebugger) ||

(statementType === NodeType.ExpressionStatement &&

callsDroppedConsole(childOf(Field.expression, statement)))

) {

// terser's `drop_debugger` and `drop_console`: the call goes whole,

// what its arguments read and run with it.

dropped[statement] = 1;

findNode(statement, discountRead);

if (

keepsGlobalNames ||

keepsInfinity ||

!isGlobalUndefined(node, "Infinity")

) {

// One `drop_debugger` drops where no list holds it prints as `;`.

if (!dropsDebugger) output.print("debugger");

if (compresses && !deleted && globalDefs !== null) {

const value = globalDefOf(node);

if (value !== undefined && readsAsValue(node, parentAt(0))) {

printValue(value, takesUnary(node));

return;

}

}

dropsDebugger = Boolean(compress && compress.drop_debugger !== false);

keepsInfinity = Boolean(compress && compress.keep_infinity);

pureFunctions =

compress &&

Array.isArray(compress.pure_funcs) &&

compress.pure_funcs.length > 0

? new Set(compress.pure_funcs)

: null;

droppedConsole =

!compress || !compress.drop_console

? null

: compress.drop_console === true || new Set(compress.drop_console);

retainsTop = compress ? topRetainOf(compress.top_retain) : null;

globalDefs = compress ? globalDefsOf(compress.global_defs) : null;

"terser compress: drop-unused/drop_toplevel_all_retain",