Commit 2fff492

* @param {number} node a name

* @returns {boolean} whether it reads a built-in constructor nothing assigns, one constructing the same called without `new`

const readsBuiltInConstructor = (node) => {

if (typeOf(node) !== NodeType.Identifier || mangledNames === null) {

const definition = mangledNames[node];

constructedWhenCalled.has(tree.name(node)) &&

/**

* Whether a `new` of a built-in nothing assigns constructs as a call of it

* does, as webpack's improvements have it; a `RegExp` call hands back an

* expression it is given, so only one of a primitive or nothing does.

* @param {number} node the `new`

* @returns {boolean} true where it prints as the call

*/

const constructsWhenCalled = (node) => {

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

return (

readsBuiltInConstructor(callee) &&

(tree.name(callee) !== "RegExp" || patternIsPrimitive(node))

);

};

comparesConvert,

heritageConstructs

* Whether a class's heritage is a constructor, so defining the class does

* not throw: `null`, a built-in one, or a class made before it and never

* set since, which an arrow or a generator a name holds is not.

* @param {number} heritage the heritage, past parentheses

* @returns {boolean} true where it is known to construct

const heritageConstructs = (heritage) => {

if (

(madeReads.size !== 0 && madeReads.has(heritage)) ||

readsBuiltInConstructor(heritage)

) {

return true;

const left =

typeOf(heritage) === NodeType.LogicalExpression &&

tree.textOf(Part.operator, heritage) === "&&"

? childOf(Field.left, heritage)

: heritage;

return (

typeOf(left) === NodeType.Literal &&

tree.textOf(Part.raw, left) === "null"

);

isPureValue(candidate)

* @param {number} statement a statement of a list

* @param {TreeDefinition} definition a name's definition

* @param {number=} count how many of a declaration's first declarators to read, all where not given

* @returns {boolean} whether it makes that name a class: declares the class, or a variable a class expression sets

*/

const makesClass = (statement, definition, count = -1) => {

const names = /** @type {TreeDefinition[]} */ (mangledNames);

if (typeOf(statement) === NodeType.ExportNamedDeclaration) {

statement = tree.field(0, Field.declaration, statement);

}

const type = statement === 0 ? 0 : typeOf(statement);

if (type === NodeType.ClassDeclaration) {

return names[tree.field(0, Field.id, statement)] === definition;

}

if (type !== NodeType.VariableDeclaration) return false;

if (count === -1) count = tree.fieldCount(Field.declarations, statement);

for (let i = 0; i < count; i++) {

const declarator = tree.field(i, Field.declarations, statement);

if (names[tree.field(0, Field.id, declarator)] === definition) {

return (

typeOf(childOf(Field.init, declarator)) === NodeType.ClassExpression

);

}

}

return false;

};

/**

* Notes a class extending a class made before it in the same list, and

* never set again, whose read there is made and so cannot throw.

* @param {number} node a class declaration of a list, or a class expression one of its declarators sets

* @param {number} index the place there of the statement holding it

* @param {number=} declarator where it is a declarator's value, that declarator's place in the statement, whose declarators before it are read too

const noteExtendsDeclared = (node, list, index, declarator = 0) => {

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

for (let i = 0; i <= index; i++) {

i < index

? makesClass(statement, definition)

: declarator > 0 && makesClass(statement, definition, declarator)

if (typeOf(init) === NodeType.ClassExpression) {

noteExtendsDeclared(init, node, i, j);

}

return isPureValue(candidate) ? id : 0;

[

"(function(){var f = () => {}; var C = class extends f{}; g()})()",

"!function(){var f=()=>{};(class extends f{});g()}();"

],

// A class a variable is set to before, and never again, constructs.

[

"(function(){var B = class {}; var C = class extends B{}; g()})()",

"g();"

],

[

"(function(){var B = class {}; B = h(); var C = class extends B{}; g()})()",

"!function(){var B=class{};B=h();(class extends B{});g()}();"

],

[

"(function(){var C = class extends B{}; var B = class {}; g()})()",

"!function(){(class extends B{});var B=class{};g()}();"

],