rollup 0.55.1 → 0.55.5

package/dist/typings/src/ast/ExecutionPathOptions.d.ts

@@ -1,97 +0,0 @@
-import CallExpression from "./nodes/CallExpression";
-import CallOptions from "./CallOptions";
-import ThisVariable from "./variables/ThisVariable";
-import ParameterVariable from "./variables/ParameterVariable";
-import { ObjectPath } from "./variables/VariableReassignmentTracker";
-import { Entity, WritableEntity } from "./Entity";
-import Property from "./nodes/Property";
-import { ExpressionEntity } from "./nodes/shared/Expression";
-export declare enum OptionTypes {
-	IGNORED_LABELS = 0,
-	ACCESSED_NODES = 1,
-	ARGUMENTS_VARIABLES = 2,
-	ASSIGNED_NODES = 3,
-	IGNORE_BREAK_STATEMENTS = 4,
-	IGNORE_RETURN_AWAIT_YIELD = 5,
-	NODES_CALLED_AT_PATH_WITH_OPTIONS = 6,
-	REPLACED_VARIABLE_INITS = 7,
-	RETURN_EXPRESSIONS_ACCESSED_AT_PATH = 8,
-	RETURN_EXPRESSIONS_ASSIGNED_AT_PATH = 9,
-	RETURN_EXPRESSIONS_CALLED_AT_PATH = 10
-}
-export declare type RESULT_KEY = {};
-export declare const RESULT_KEY: RESULT_KEY;
-export declare type KeyTypes = OptionTypes | Entity | RESULT_KEY;
-export default class ExecutionPathOptions {
-	private optionValues;
-	static create(): ExecutionPathOptions;
-	private constructor();
-	private get(option);
-	private remove(option);
-	private set(option, value);
-	private setIn(optionPath, value);
-	addAccessedNodeAtPath(
-		path: ObjectPath,
-		node: ExpressionEntity
-	): ExecutionPathOptions;
-	addAccessedReturnExpressionAtPath(
-		path: ObjectPath,
-		callExpression: CallExpression | Property
-	): ExecutionPathOptions;
-	addAssignedNodeAtPath(
-		path: ObjectPath,
-		node: WritableEntity
-	): ExecutionPathOptions;
-	addAssignedReturnExpressionAtPath(
-		path: ObjectPath,
-		callExpression: CallExpression | Property
-	): ExecutionPathOptions;
-	addCalledNodeAtPathWithOptions(
-		path: ObjectPath,
-		node: ExpressionEntity,
-		callOptions: CallOptions
-	): ExecutionPathOptions;
-	addCalledReturnExpressionAtPath(
-		path: ObjectPath,
-		callExpression: CallExpression | Property
-	): ExecutionPathOptions;
-	getArgumentsVariables(): ExpressionEntity[];
-	getHasEffectsWhenCalledOptions(): ExecutionPathOptions;
-	getReplacedVariableInit(
-		variable: ThisVariable | ParameterVariable
-	): ExpressionEntity;
-	hasNodeBeenAccessedAtPath(
-		path: ObjectPath,
-		node: ExpressionEntity
-	): boolean;
-	hasNodeBeenAssignedAtPath(path: ObjectPath, node: WritableEntity): boolean;
-	hasNodeBeenCalledAtPathWithOptions(
-		path: ObjectPath,
-		node: ExpressionEntity,
-		callOptions: CallOptions
-	): boolean;
-	hasReturnExpressionBeenAccessedAtPath(
-		path: ObjectPath,
-		callExpression: CallExpression | Property
-	): boolean;
-	hasReturnExpressionBeenAssignedAtPath(
-		path: ObjectPath,
-		callExpression: CallExpression | Property
-	): boolean;
-	hasReturnExpressionBeenCalledAtPath(
-		path: ObjectPath,
-		callExpression: CallExpression | Property
-	): boolean;
-	ignoreBreakStatements(): boolean | Entity | ExpressionEntity[];
-	ignoreLabel(labelName: string): any;
-	ignoreReturnAwaitYield(): boolean | Entity | ExpressionEntity[];
-	replaceVariableInit(
-		variable: ThisVariable | ParameterVariable,
-		init: ExpressionEntity
-	): ExecutionPathOptions;
-	setArgumentsVariables(variables: ExpressionEntity[]): ExecutionPathOptions;
-	setIgnoreBreakStatements(value?: boolean): ExecutionPathOptions;
-	setIgnoreLabel(labelName: string): ExecutionPathOptions;
-	setIgnoreNoLabels(): ExecutionPathOptions;
-	setIgnoreReturnAwaitYield(value?: boolean): ExecutionPathOptions;
-}

package/dist/typings/src/ast/Node.d.ts

@@ -1,186 +0,0 @@
-/// <reference path="../../../../src/ast/Node.d.ts" />
-import { PredicateFunction, UnknownAssignment } from "./values";
-import ExecutionPathOptions from "./ExecutionPathOptions";
-import Scope from "./scopes/Scope";
-import Module from "../Module";
-import MagicString from "magic-string";
-import CallOptions from "./CallOptions";
-import Expression from "./nodes/Expression";
-import Declaration from "./nodes/Declaration";
-import { ObjectPath } from "./variables/VariableReassignmentTracker";
-export declare type ForEachReturnExpressionCallback = (
-	options: ExecutionPathOptions
-) => (node: Node | UnknownAssignment) => void;
-export default class Node {
-	type: string;
-	keys: string[];
-	included: boolean;
-	scope: Scope;
-	start: number;
-	end: number;
-	leadingCommentStart: number;
-	trailingCommentEnd: number;
-	next: number;
-	module: Module;
-	parent: Node | Module;
-	__enhanced: boolean;
-	constructor();
-	/**
-	 * Called once all nodes have been initialised and the scopes have been populated.
-	 * Usually one should not override this function but override bindNode and/or
-	 * bindChildren instead.
-	 */
-	bind(): void;
-	/**
-	 * Reassign a given path of an object.
-	 * E.g., node.reassignPath(['x', 'y']) is called when something
-	 * is assigned to node.x.y.
-	 * The default noop implementation is ok as long as hasEffectsWhenAssignedAtPath
-	 * always returns true for this node. Otherwise it should be overridden.
-	 * @param {String[]} _path
-	 * @param {ExecutionPathOptions} _options
-	 */
-	reassignPath(_path: ObjectPath, _options: ExecutionPathOptions): void;
-	/**
-	 * Override to control on which children "bind" is called.
-	 */
-	bindChildren(): void;
-	/**
-	 * Override this to bind assignments to variables and do any initialisations that
-	 * require the scopes to be populated with variables.
-	 */
-	bindNode(): void;
-	eachChild(callback: (node: Node) => void): void;
-	/**
-	 * Executes the callback on each possible return expression when calling this node.
-	 * @param {String[]} _path
-	 * @param {CallOptions} _callOptions
-	 * @param {Function} _callback
-	 * @param {ExecutionPathOptions} _options
-	 */
-	forEachReturnExpressionWhenCalledAtPath(
-		_path: ObjectPath,
-		_callOptions: CallOptions,
-		_callback: ForEachReturnExpressionCallback,
-		_options: ExecutionPathOptions
-	): void;
-	getValue(): {
-		toString: () => string;
-	};
-	/**
-	 * Determine if this Node would have an effect on the bundle.
-	 * This is usually true for already included nodes. Exceptions are e.g. break statements
-	 * which only have an effect if their surrounding loop or switch statement is included.
-	 * The options pass on information like this about the current execution path.
-	 * @param {ExecutionPathOptions} options
-	 * @return {boolean}
-	 */
-	hasEffects(options: ExecutionPathOptions): boolean;
-	/**
-	 * @param {String[]} path
-	 * @param {ExecutionPathOptions} _options
-	 * @return {boolean}
-	 */
-	hasEffectsWhenAccessedAtPath(
-		path: ObjectPath,
-		_options: ExecutionPathOptions
-	): boolean;
-	/**
-	 * @param {String[]} _path
-	 * @param {ExecutionPathOptions} _options
-	 * @return {boolean}
-	 */
-	hasEffectsWhenAssignedAtPath(
-		_path: ObjectPath,
-		_options: ExecutionPathOptions
-	): boolean;
-	/**
-	 * @param {String[]} _path
-	 * @param {CallOptions} _callOptions
-	 * @param {ExecutionPathOptions} _options
-	 * @return {boolean}
-	 */
-	hasEffectsWhenCalledAtPath(
-		_path: ObjectPath,
-		_callOptions: CallOptions,
-		_options: ExecutionPathOptions
-	): boolean;
-	/**
-	 * Returns true if this node or any of its children is included.
-	 * @return {boolean}
-	 */
-	hasIncludedChild(): boolean;
-	/**
-	 * Includes the node in the bundle. Children are usually included if they are
-	 * necessary for this node (e.g. a function body) or if they have effects.
-	 * Necessary variables need to be included as well. Should return true if any
-	 * nodes or variables have been added that were missing before.
-	 * @return {boolean}
-	 */
-	includeInBundle(): boolean;
-	/**
-	 * Alternative version of includeInBundle to override the default behaviour of
-	 * declarations to only include nodes for declarators that have an effect. Necessary
-	 * for for-loops that do not use a declared loop variable.
-	 * @return {boolean}
-	 */
-	includeWithAllDeclarations(): boolean;
-	/**
-	 * Assign a scope to this node and make sure all children have the right scopes.
-	 * Perform any additional initialisation that does not depend on the scope being
-	 * populated with variables.
-	 * Usually one should not override this function but override initialiseScope,
-	 * initialiseNode and/or initialiseChildren instead. BlockScopes have a special
-	 * alternative initialisation initialiseAndReplaceScope.
-	 * @param {Scope} parentScope
-	 */
-	initialise(parentScope: Scope): void;
-	initialiseAndDeclare(
-		_parentScope: Scope,
-		_kind: string,
-		_init: Declaration | Expression | UnknownAssignment | null
-	): void;
-	/**
-	 * Override to change how and with what scopes children are initialised
-	 * @param {Scope} _parentScope
-	 */
-	initialiseChildren(_parentScope: Scope): void;
-	/**
-	 * Override to perform special initialisation steps after the scope is initialised
-	 * @param {Scope} _parentScope
-	 */
-	initialiseNode(_parentScope: Scope): void;
-	/**
-	 * Override if this scope should receive a different scope than the parent scope.
-	 * @param {Scope} parentScope
-	 */
-	initialiseScope(parentScope: Scope): void;
-	insertSemicolon(code: MagicString): void;
-	locate(): any;
-	render(code: MagicString, es: boolean): void;
-	/**
-	 * Start a new execution path to determine if this node has an effect on the bundle and
-	 * should therefore be included. Included nodes should always be included again in subsequent
-	 * visits as the inclusion of additional variables may require the inclusion of more child
-	 * nodes in e.g. block statements.
-	 * @return {boolean}
-	 */
-	shouldBeIncluded(): boolean;
-	someChild(callback: (node: Node) => boolean): boolean;
-	/**
-	 * Returns true if some possible return expression when called at the given
-	 * path returns true. predicateFunction receives a `node` as parameter.
-	 * @param {String[]} _path
-	 * @param {CallOptions} _callOptions
-	 * @param {Function} predicateFunction
-	 * @param {ExecutionPathOptions} options
-	 * @returns {boolean}
-	 */
-	someReturnExpressionWhenCalledAtPath(
-		_path: ObjectPath,
-		_callOptions: CallOptions,
-		predicateFunction: (options: ExecutionPathOptions) => PredicateFunction,
-		options: ExecutionPathOptions
-	): boolean;
-	toString(): string;
-}

package/dist/typings/src/ast/clone.d.ts

@@ -1 +0,0 @@
-export default function clone<T>(node: T): T;

package/dist/typings/src/ast/comment.d.ts

@@ -1,4 +0,0 @@
-export default interface Comment {
-	start: number;
-	end: number;
-};

package/dist/typings/src/ast/enhance.d.ts

@@ -1,7 +0,0 @@
-import Module from "../Module";
-import Comment from "./comment";
-export default function enhance(
-	ast: any,
-	module: Module,
-	comments: Comment[]
-): void;

package/dist/typings/src/ast/keys.d.ts

@@ -1,4 +0,0 @@
-declare const keys: {
-	[name: string]: string[];
-};
-export default keys;

package/dist/typings/src/ast/nodes/ArrayExpression.d.ts

@@ -1,9 +0,0 @@
-import SpreadElement from "./SpreadElement";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import { ExpressionNode, NodeBase } from "./shared/Node";
-import { NodeType } from "./index";
-export default class ArrayExpression extends NodeBase {
-	type: NodeType.ArrayExpression;
-	elements: (ExpressionNode | SpreadElement | null)[];
-	hasEffectsWhenAccessedAtPath(path: ObjectPath): boolean;
-}

package/dist/typings/src/ast/nodes/ArrayPattern.d.ts

@@ -1,21 +0,0 @@
-import Scope from "../scopes/Scope";
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import { PatternNode } from "./shared/Pattern";
-import { ExpressionEntity } from "./shared/Expression";
-import { NodeBase } from "./shared/Node";
-import { NodeType } from "./index";
-export default class ArrayPattern extends NodeBase implements PatternNode {
-	type: NodeType.ArrayPattern;
-	elements: (PatternNode | null)[];
-	reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
-	hasEffectsWhenAssignedAtPath(
-		path: ObjectPath,
-		options: ExecutionPathOptions
-	): boolean;
-	initialiseAndDeclare(
-		parentScope: Scope,
-		kind: string,
-		_init: ExpressionEntity | null
-	): void;
-}

package/dist/typings/src/ast/nodes/ArrowFunctionExpression.d.ts

@@ -1,48 +0,0 @@
-import Scope from "../scopes/Scope";
-import ReturnValueScope from "../scopes/ReturnValueScope";
-import BlockStatement from "./BlockStatement";
-import CallOptions from "../CallOptions";
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import {
-	ForEachReturnExpressionCallback,
-	SomeReturnExpressionCallback
-} from "./shared/Expression";
-import { PatternNode } from "./shared/Pattern";
-import { NodeType } from "./index";
-import { ExpressionNode, NodeBase } from "./shared/Node";
-export default class ArrowFunctionExpression extends NodeBase {
-	type: NodeType.ArrowFunctionExpression;
-	body: BlockStatement | ExpressionNode;
-	params: PatternNode[];
-	scope: ReturnValueScope;
-	bindNode(): void;
-	forEachReturnExpressionWhenCalledAtPath(
-		path: ObjectPath,
-		callOptions: CallOptions,
-		callback: ForEachReturnExpressionCallback,
-		options: ExecutionPathOptions
-	): void;
-	hasEffects(_options: ExecutionPathOptions): boolean;
-	hasEffectsWhenAccessedAtPath(
-		path: ObjectPath,
-		_options: ExecutionPathOptions
-	): boolean;
-	hasEffectsWhenAssignedAtPath(
-		path: ObjectPath,
-		_options: ExecutionPathOptions
-	): boolean;
-	hasEffectsWhenCalledAtPath(
-		path: ObjectPath,
-		_callOptions: CallOptions,
-		options: ExecutionPathOptions
-	): boolean;
-	initialiseChildren(): void;
-	initialiseScope(parentScope: Scope): void;
-	someReturnExpressionWhenCalledAtPath(
-		path: ObjectPath,
-		callOptions: CallOptions,
-		predicateFunction: SomeReturnExpressionCallback,
-		options: ExecutionPathOptions
-	): boolean;
-}

package/dist/typings/src/ast/nodes/AssignmentExpression.d.ts

@@ -1,16 +0,0 @@
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import { PatternNode } from "./shared/Pattern";
-import { ExpressionNode, NodeBase } from "./shared/Node";
-import { NodeType } from "./index";
-export default class AssignmentExpression extends NodeBase {
-	type: NodeType.AssignmentExpression;
-	left: PatternNode | ExpressionNode;
-	right: ExpressionNode;
-	bindNode(): void;
-	hasEffects(options: ExecutionPathOptions): boolean;
-	hasEffectsWhenAccessedAtPath(
-		path: ObjectPath,
-		options: ExecutionPathOptions
-	): boolean;
-}

package/dist/typings/src/ast/nodes/AssignmentPattern.d.ts

@@ -1,23 +0,0 @@
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import Scope from "../scopes/Scope";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import { PatternNode } from "./shared/Pattern";
-import { ExpressionEntity } from "./shared/Expression";
-import { ExpressionNode, NodeBase } from "./shared/Node";
-import { NodeType } from "./index";
-export default class AssignmentPattern extends NodeBase implements PatternNode {
-	type: NodeType.AssignmentPattern;
-	left: PatternNode;
-	right: ExpressionNode;
-	bindNode(): void;
-	reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
-	hasEffectsWhenAssignedAtPath(
-		path: ObjectPath,
-		options: ExecutionPathOptions
-	): boolean;
-	initialiseAndDeclare(
-		parentScope: Scope,
-		kind: string,
-		init: ExpressionEntity | null
-	): void;
-}

package/dist/typings/src/ast/nodes/AssignmentProperty.d.ts

@@ -1,10 +0,0 @@
-import { PatternNode } from "./shared/Pattern";
-import { ExpressionNode } from "./shared/Node";
-import { NodeType } from "./index";
-export default interface AssignmentProperty extends PatternNode {
-	type: NodeType.Property;
-	value: PatternNode;
-	key: ExpressionNode;
-	kind: "init";
-	method: false;
-};

package/dist/typings/src/ast/nodes/AwaitExpression.d.ts

@@ -1,8 +0,0 @@
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import { NodeType } from "./index";
-import { ExpressionNode, NodeBase } from "./shared/Node";
-export default class AwaitExpression extends NodeBase {
-	type: NodeType.AwaitExpression;
-	argument: ExpressionNode;
-	hasEffects(options: ExecutionPathOptions): boolean;
-}

package/dist/typings/src/ast/nodes/BinaryExpression.d.ts

@@ -1,38 +0,0 @@
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import { NodeType } from "./index";
-import { ExpressionNode, NodeBase } from "./shared/Node";
-export declare type BinaryOperator =
-	| "=="
-	| "!="
-	| "==="
-	| "!=="
-	| "<"
-	| "<="
-	| ">"
-	| ">="
-	| "<<"
-	| ">>"
-	| ">>>"
-	| "+"
-	| "-"
-	| "*"
-	| "/"
-	| "%"
-	| " |"
-	| "^"
-	| "&"
-	| "**"
-	| "in"
-	| "instanceof";
-export default class BinaryExpression extends NodeBase {
-	type: NodeType.BinaryExpression;
-	left: ExpressionNode;
-	right: ExpressionNode;
-	operator: BinaryOperator;
-	getValue(): any;
-	hasEffectsWhenAccessedAtPath(
-		path: ObjectPath,
-		_options: ExecutionPathOptions
-	): boolean;
-}

package/dist/typings/src/ast/nodes/BlockStatement.d.ts

@@ -1,19 +0,0 @@
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import Scope from "../scopes/Scope";
-import MagicString from "magic-string";
-import { Node } from "./shared/Node";
-import { StatementBase, StatementNode } from "./shared/Statement";
-import { NodeType } from "./index";
-export declare function isBlockStatement(node: Node): node is BlockStatement;
-export default class BlockStatement extends StatementBase {
-	type: NodeType.BlockStatement;
-	scope: Scope;
-	body: StatementNode[];
-	bindImplicitReturnExpressionToScope(): void;
-	hasEffects(options: ExecutionPathOptions): boolean;
-	includeInBundle(): boolean;
-	initialiseAndReplaceScope(scope: Scope): void;
-	initialiseChildren(_parentScope: Scope): void;
-	initialiseScope(parentScope: Scope): void;
-	render(code: MagicString, es: boolean): void;
-}

package/dist/typings/src/ast/nodes/BreakStatement.d.ts

@@ -1,9 +0,0 @@
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import Identifier from "./Identifier";
-import { StatementBase } from "./shared/Statement";
-import { NodeType } from "./index";
-export default class BreakStatement extends StatementBase {
-	type: NodeType.BreakStatement;
-	label: Identifier | null;
-	hasEffects(options: ExecutionPathOptions): boolean;
-}

package/dist/typings/src/ast/nodes/CallExpression.d.ts

@@ -1,45 +0,0 @@
-import CallOptions from "../CallOptions";
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import SpreadElement from "./SpreadElement";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import {
-	ForEachReturnExpressionCallback,
-	SomeReturnExpressionCallback
-} from "./shared/Expression";
-import { NodeType } from "./index";
-import { ExpressionNode, NodeBase } from "./shared/Node";
-export default class CallExpression extends NodeBase {
-	type: NodeType.CallExpression;
-	callee: ExpressionNode;
-	arguments: (ExpressionNode | SpreadElement)[];
-	private _callOptions;
-	reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
-	bindNode(): void;
-	forEachReturnExpressionWhenCalledAtPath(
-		path: ObjectPath,
-		callOptions: CallOptions,
-		callback: ForEachReturnExpressionCallback,
-		options: ExecutionPathOptions
-	): void;
-	hasEffects(options: ExecutionPathOptions): boolean;
-	hasEffectsWhenAccessedAtPath(
-		path: ObjectPath,
-		options: ExecutionPathOptions
-	): boolean;
-	hasEffectsWhenAssignedAtPath(
-		path: ObjectPath,
-		options: ExecutionPathOptions
-	): boolean;
-	hasEffectsWhenCalledAtPath(
-		path: ObjectPath,
-		callOptions: CallOptions,
-		options: ExecutionPathOptions
-	): boolean;
-	initialiseNode(): void;
-	someReturnExpressionWhenCalledAtPath(
-		path: ObjectPath,
-		callOptions: CallOptions,
-		predicateFunction: SomeReturnExpressionCallback,
-		options: ExecutionPathOptions
-	): boolean;
-}

package/dist/typings/src/ast/nodes/CatchClause.d.ts

@@ -1,14 +0,0 @@
-import { NodeBase } from "./shared/Node";
-import CatchScope from "../scopes/CatchScope";
-import BlockStatement from "./BlockStatement";
-import Scope from "../scopes/Scope";
-import { PatternNode } from "./shared/Pattern";
-import { NodeType } from "./index";
-export default class CatchClause extends NodeBase {
-	type: NodeType.CatchClause;
-	param: PatternNode;
-	body: BlockStatement;
-	scope: CatchScope;
-	initialiseChildren(): void;
-	initialiseScope(parentScope: Scope): void;
-}

package/dist/typings/src/ast/nodes/ClassBody.d.ts

@@ -1,17 +0,0 @@
-import { NodeBase } from "./shared/Node";
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import CallOptions from "../CallOptions";
-import MethodDefinition from "./MethodDefinition";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import { NodeType } from "./index";
-export default class ClassBody extends NodeBase {
-	type: NodeType.ClassBody;
-	body: MethodDefinition[];
-	classConstructor: MethodDefinition | null;
-	hasEffectsWhenCalledAtPath(
-		path: ObjectPath,
-		callOptions: CallOptions,
-		options: ExecutionPathOptions
-	): boolean;
-	initialiseNode(): void;
-}

package/dist/typings/src/ast/nodes/ClassDeclaration.d.ts

@@ -1,11 +0,0 @@
-import ClassNode from "./shared/ClassNode";
-import Scope from "../scopes/Scope";
-import Identifier from "./Identifier";
-import MagicString from "magic-string";
-import { NodeType } from "./index";
-export default class ClassDeclaration extends ClassNode {
-	type: NodeType.ClassDeclaration;
-	id: Identifier;
-	initialiseChildren(parentScope: Scope): void;
-	render(code: MagicString, es: boolean): void;
-}

package/dist/typings/src/ast/nodes/ClassExpression.d.ts

@@ -1,10 +0,0 @@
-import ClassNode from "./shared/ClassNode";
-import Scope from "../scopes/Scope";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import { NodeType } from "./index";
-export default class ClassExpression extends ClassNode {
-	type: NodeType.ClassExpression;
-	initialiseChildren(parentScope: Scope): void;
-	reassignPath(_path: ObjectPath, _options: ExecutionPathOptions): void;
-}

package/dist/typings/src/ast/nodes/ConditionalExpression.d.ts

@@ -1,50 +0,0 @@
-import ExecutionPathOptions from "../ExecutionPathOptions";
-import CallOptions from "../CallOptions";
-import Scope from "../scopes/Scope";
-import MagicString from "magic-string";
-import { ObjectPath } from "../variables/VariableReassignmentTracker";
-import {
-	ForEachReturnExpressionCallback,
-	SomeReturnExpressionCallback
-} from "./shared/Expression";
-import { NodeType } from "./index";
-import { ExpressionNode, NodeBase } from "./shared/Node";
-export default class ConditionalExpression extends NodeBase {
-	type: NodeType.ConditionalExpression;
-	test: ExpressionNode;
-	alternate: ExpressionNode;
-	consequent: ExpressionNode;
-	testValue: any;
-	reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
-	forEachReturnExpressionWhenCalledAtPath(
-		path: ObjectPath,
-		callOptions: CallOptions,
-		callback: ForEachReturnExpressionCallback,
-		options: ExecutionPathOptions
-	): void;
-	getValue(): any;
-	hasEffects(options: ExecutionPathOptions): boolean;
-	hasEffectsWhenAccessedAtPath(
-		path: ObjectPath,
-		options: ExecutionPathOptions
-	): boolean;
-	hasEffectsWhenAssignedAtPath(
-		path: ObjectPath,
-		options: ExecutionPathOptions
-	): boolean;
-	hasEffectsWhenCalledAtPath(
-		path: ObjectPath,
-		callOptions: CallOptions,
-		options: ExecutionPathOptions
-	): boolean;
-	initialiseChildren(parentScope: Scope): void;
-	render(code: MagicString, es: boolean): void;
-	someReturnExpressionWhenCalledAtPath(
-		path: ObjectPath,
-		callOptions: CallOptions,
-		predicateFunction: SomeReturnExpressionCallback,
-		options: ExecutionPathOptions
-	): boolean;
-	private forEachRelevantBranch(callback);
-	private someRelevantBranch(predicateFunction);
-}