rollup 0.55.1 → 0.55.5

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

@@ -1,185 +0,0 @@
-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/ast/nodes/Declaration.d.ts

@@ -1,8 +0,0 @@
-import FunctionDeclaration from "./FunctionDeclaration";
-import VariableDeclaration from "./VariableDeclaration";
-import ClassDeclaration from "./ClassDeclaration";
-declare type Declaration =
-	| FunctionDeclaration
-	| VariableDeclaration
-	| ClassDeclaration;
-export default Declaration;

package/dist/typings/ast/nodes/Expression.d.ts

@@ -1,46 +0,0 @@
-import ThisExpression from "./ThisExpression";
-import ArrayExpression from "./ArrayExpression";
-import ObjectExpression from "./ObjectExpression";
-import FunctionExpression from "./FunctionExpression";
-import UnaryExpression from "./UnaryExpression";
-import UpdateExpression from "./UpdateExpression";
-import BinaryExpression from "./BinaryExpression";
-import AssignmentExpression from "./AssignmentExpression";
-import LogicalExpression from "./LogicalExpression";
-import MemberExpression from "./MemberExpression";
-import ConditionalExpression from "./ConditionalExpression";
-import CallExpression from "./CallExpression";
-import NewExpression from "./NewExpression";
-import SequenceExpression from "./SequenceExpression";
-import ArrowFunctionExpression from "./ArrowFunctionExpression";
-import YieldExpression from "./YieldExpression";
-import Identifier from "./Identifier";
-import Literal from "./Literal";
-import AwaitExpression from "./AwaitExpression";
-import TemplateLiteral from "./TemplateLiteral";
-import TaggedTemplateExpression from "./TaggedTemplateExpression";
-import ClassExpression from "./ClassExpression";
-declare type Expression =
-	| ThisExpression
-	| ArrayExpression
-	| ObjectExpression
-	| FunctionExpression
-	| UnaryExpression
-	| UpdateExpression
-	| BinaryExpression
-	| AssignmentExpression
-	| LogicalExpression
-	| MemberExpression
-	| ConditionalExpression
-	| CallExpression
-	| NewExpression
-	| SequenceExpression
-	| ArrowFunctionExpression
-	| YieldExpression
-	| TemplateLiteral
-	| TaggedTemplateExpression
-	| ClassExpression
-	| Identifier
-	| Literal
-	| AwaitExpression;
-export default Expression;

package/dist/typings/ast/nodes/Pattern.d.ts

@@ -1,12 +0,0 @@
-import ObjectPattern from "./ObjectPattern";
-import ArrayPattern from "./ArrayPattern";
-import RestElement from "./RestElement";
-import AssignmentPattern from "./AssignmentPattern";
-import Identifier from "./Identifier";
-declare type Pattern =
-	| ObjectPattern
-	| ArrayPattern
-	| RestElement
-	| AssignmentPattern
-	| Identifier;
-export default Pattern;

package/dist/typings/ast/nodes/Statement.d.ts

@@ -1,10 +0,0 @@
-import { default as StatementBaseClass } from "./shared/Statement";
-import FunctionDeclaration from "./FunctionDeclaration";
-import VariableDeclaration from "./VariableDeclaration";
-import ClassDeclaration from "./ClassDeclaration";
-declare type Statement =
-	| FunctionDeclaration
-	| VariableDeclaration
-	| ClassDeclaration
-	| StatementBaseClass;
-export default Statement;

package/dist/typings/ast/nodes/shared/VirtualObjectExpression.d.ts

@@ -1,7 +0,0 @@
-import Node from "../../Node";
-import { ObjectPath } from "../../variables/VariableReassignmentTracker";
-export default class VirtualObjectExpression extends Node {
-	hasEffectsWhenAccessedAtPath(path: ObjectPath): boolean;
-	hasEffectsWhenAssignedAtPath(path: ObjectPath): boolean;
-	toString(): string;
-}

package/dist/typings/ast/nodes/shared/disallowIllegalReassignment.d.ts

@@ -1,6 +0,0 @@
-import Scope from "../../scopes/Scope";
-import Node from "../../Node";
-export default function disallowIllegalReassignment(
-	scope: Scope,
-	node: Node
-): void;

package/dist/typings/bin/src/index.d.ts

@@ -1 +0,0 @@
-/// <reference path="../../../../bin/src/index.d.ts" />

package/dist/typings/bin/src/logging.d.ts

@@ -1,3 +0,0 @@
-import { RollupError } from "../../src/utils/error";
-export declare const stderr: any;
-export declare function handleError(err: RollupError, recover?: boolean): void;

package/dist/typings/bin/src/run/alternateScreen.d.ts

@@ -1,8 +0,0 @@
-/// <reference path="../../../../../bin/src/run/alternateScreen.d.ts" />
-export default function alternateScreen(
-	enabled: boolean
-): {
-	open(): void;
-	close(): void;
-	reset(heading: string): void;
-};

package/dist/typings/bin/src/run/batchWarnings.d.ts

@@ -1,11 +0,0 @@
-import { RollupWarning } from "../../../src/rollup/index";
-export interface BatchWarnings {
-	readonly count: number;
-	add: (warning: string | RollupWarning) => void;
-	flush: () => void;
-}
-export default function batchWarnings(): {
-	readonly count: number;
-	add: (warning: string | RollupWarning) => void;
-	flush: () => void;
-};

package/dist/typings/bin/src/run/build.d.ts

@@ -1,9 +0,0 @@
-/// <reference path="../../../../../bin/src/run/build.d.ts" />
-import { InputOptions, OutputOptions } from "../../../src/rollup/index";
-import { BatchWarnings } from "./batchWarnings";
-export default function build(
-	inputOptions: InputOptions,
-	outputOptions: OutputOptions[],
-	warnings: BatchWarnings,
-	silent?: boolean
-): any;

package/dist/typings/bin/src/run/index.d.ts

@@ -1 +0,0 @@
-export default function runRollup(command: any): Promise<{}[]>;

package/dist/typings/bin/src/run/loadConfigFile.d.ts

@@ -1,6 +0,0 @@
-/// <reference path="../../../../../bin/src/run/loadConfigFile.d.ts" />
-import { InputOptions } from "../../../src/rollup/index";
-export default function loadConfigFile(
-	configFile: string,
-	silent?: boolean
-): Promise<InputOptions[]>;

package/dist/typings/bin/src/run/watch.d.ts

@@ -1,8 +0,0 @@
-/// <reference path="../../../../../bin/src/run/watch.d.ts" />
-import { RollupWatchOptions } from "../../../src/watch/index";
-export default function watch(
-	configFile: string,
-	configs: RollupWatchOptions[],
-	command: any,
-	silent?: boolean
-): void;

package/dist/typings/bin/src/sourceMappingUrl.d.ts

@@ -1,2 +0,0 @@
-declare let SOURCEMAPPING_URL: string;
-export default SOURCEMAPPING_URL;

package/dist/typings/bin/src/utils/sequence.d.ts

@@ -1,4 +0,0 @@
-export default function sequence<T, U>(
-	array: T[],
-	fn: (member: T) => Promise<U>
-): Promise<U[]>;

package/dist/typings/browser/fs.d.ts

@@ -1,5 +0,0 @@
-export declare const lstatSync: string;
-export declare const readdirSync: string;
-export declare const readFileSync: string;
-export declare const realpathSync: string;
-export declare const writeFile: string;

package/dist/typings/browser/path.d.ts

@@ -1,10 +0,0 @@
-export declare const absolutePath: RegExp;
-export declare const relativePath: RegExp;
-export declare function isAbsolute(path: string): boolean;
-export declare function isRelative(path: string): boolean;
-export declare function normalize(path: string): string;
-export declare function basename(path: string): string;
-export declare function dirname(path: string): string;
-export declare function extname(path: string): string;
-export declare function relative(from: string, to: string): string;
-export declare function resolve(...paths: string[]): string;

package/dist/typings/src/Bundle.d.ts

@@ -1,29 +0,0 @@
-import Module from "./Module";
-import { OutputOptions } from "./rollup/index";
-import Graph from "./Graph";
-import ExternalModule from "./ExternalModule";
-export default class Bundle {
-	graph: Graph;
-	orderedModules: Module[];
-	externalModules: ExternalModule[];
-	entryModule: Module;
-	constructor(graph: Graph, orderedModules: Module[]);
-	bind(): void;
-	includeMarked(treeshake: boolean): void;
-	setFascade(entryModule: Module): void;
-	processExternals(): void;
-	collectAddon(
-		initialAddon: string,
-		addonName: "banner" | "footer" | "intro" | "outro",
-		sep?: string
-	): Promise<string>;
-	getPathRelativeToEntryDirname(resolvedId: string): string;
-	deconflict(): void;
-	private setRenderResolutions(options);
-	render(
-		options: OutputOptions
-	): Promise<{
-		code: string;
-		map: any;
-	}>;
-}

package/dist/typings/src/ExternalModule.d.ts

@@ -1,23 +0,0 @@
-import Variable from "./ast/variables/Variable";
-import Graph from "./Graph";
-export default class ExternalModule {
-	graph: Graph;
-	declarations: {
-		[name: string]: Variable;
-	};
-	exportsNames: boolean;
-	exportsNamespace: boolean;
-	id: string;
-	isExternal: boolean;
-	name: string;
-	mostCommonSuggestion: number;
-	nameSuggestions: {
-		[name: string]: number;
-	};
-	reexported: boolean;
-	used: boolean;
-	constructor(graph: Graph, id: string);
-	suggestName(name: string): void;
-	warnUnusedImports(): void;
-	traceExport(name: string): Variable;
-}

package/dist/typings/src/Graph.d.ts

@@ -1,60 +0,0 @@
-import Module, { ModuleJSON } from "./Module";
-import ExternalModule from "./ExternalModule";
-import GlobalScope from "./ast/scopes/GlobalScope";
-import {
-	InputOptions,
-	IsExternalHook,
-	Plugin,
-	RollupWarning,
-	SourceDescription,
-	TreeshakingOptions,
-	WarningHandler
-} from "./rollup/index";
-import { Node } from "./ast/nodes/shared/Node";
-import Bundle from "./Bundle";
-export declare type ResolveDynamicImportHandler = (
-	specifier: string | Node,
-	parentId: string
-) => Promise<string | void>;
-export default class Graph {
-	acornOptions: any;
-	cachedModules: Map<string, ModuleJSON>;
-	context: string;
-	dynamicImport: boolean;
-	externalModules: ExternalModule[];
-	getModuleContext: (id: string) => string;
-	hasLoaders: boolean;
-	isExternal: IsExternalHook;
-	isPureExternalModule: (id: string) => boolean;
-	legacy: boolean;
-	load: (id: string) => Promise<SourceDescription | string | void>;
-	moduleById: Map<string, Module | ExternalModule>;
-	modules: Module[];
-	onwarn: WarningHandler;
-	plugins: Plugin[];
-	resolveDynamicImport: ResolveDynamicImportHandler;
-	resolveId: (id: string, parent: string) => Promise<string | boolean | void>;
-	scope: GlobalScope;
-	treeshakingOptions: TreeshakingOptions;
-	varOrConst: "var" | "const";
-	dependsOn: {
-		[id: string]: {
-			[id: string]: boolean;
-		};
-	};
-	stronglyDependsOn: {
-		[id: string]: {
-			[id: string]: boolean;
-		};
-	};
-	treeshake: boolean;
-	constructor(options: InputOptions);
-	private loadModule(entryName);
-	private link();
-	buildSingle(entryModuleId: string): Promise<Bundle>;
-	private analyseExecution(entryModule);
-	private warnCycle(ordered, entryModules);
-	private fetchModule(id, importer);
-	private fetchAllDependencies(module);
-	warn(warning: RollupWarning): void;
-}

package/dist/typings/src/Module.d.ts

@@ -1,137 +0,0 @@
-import MagicString from "magic-string";
-import { RollupError } from "./utils/error";
-import NamespaceVariable from "./ast/variables/NamespaceVariable";
-import ModuleScope from "./ast/scopes/ModuleScope";
-import { RawSourceMap } from "source-map";
-import ImportSpecifier from "./ast/nodes/ImportSpecifier";
-import Graph from "./Graph";
-import Variable from "./ast/variables/Variable";
-import Program from "./ast/nodes/Program";
-import { Node } from "./ast/nodes/shared/Node";
-import ImportDefaultSpecifier from "./ast/nodes/ImportDefaultSpecifier";
-import ImportNamespaceSpecifier from "./ast/nodes/ImportNamespaceSpecifier";
-import { RollupWarning } from "./rollup/index";
-import ExternalModule from "./ExternalModule";
-import Import from "./ast/nodes/Import";
-export interface IdMap {
-	[key: string]: string;
-}
-export interface CommentDescription {
-	block: boolean;
-	text: string;
-	start: number;
-	end: number;
-}
-export interface ExportDescription {
-	localName: string;
-	identifier?: string;
-}
-export interface ReexportDescription {
-	localName: string;
-	start: number;
-	source: string;
-	module: Module;
-}
-export interface ModuleJSON {
-	id: string;
-	dependencies: string[];
-	code: string;
-	originalCode: string;
-	originalSourcemap: RawSourceMap;
-	ast: Program;
-	sourcemapChain: RawSourceMap[];
-	resolvedIds: IdMap;
-	resolvedExternalIds: IdMap;
-}
-export default class Module {
-	type: "Module";
-	graph: Graph;
-	code: string;
-	comments: CommentDescription[];
-	context: string;
-	dependencies: Module[];
-	excludeFromSourcemap: boolean;
-	exports: {
-		[name: string]: ExportDescription;
-	};
-	exportsAll: {
-		[name: string]: string;
-	};
-	exportAllSources: string[];
-	id: string;
-	imports: {
-		[name: string]: {
-			source: string;
-			specifier:
-				| ImportSpecifier
-				| ImportNamespaceSpecifier
-				| ImportDefaultSpecifier;
-			name: string;
-			module: Module | ExternalModule | null;
-		};
-	};
-	isExternal: false;
-	magicString: MagicString;
-	originalCode: string;
-	originalSourcemap: RawSourceMap;
-	reexports: {
-		[name: string]: ReexportDescription;
-	};
-	resolvedExternalIds: IdMap;
-	resolvedIds: IdMap;
-	scope: ModuleScope;
-	sourcemapChain: RawSourceMap[];
-	sources: string[];
-	strongDependencies: (Module | ExternalModule)[];
-	dynamicImports: Import[];
-	dynamicImportResolutions: (Module | ExternalModule | string | void)[];
-	ast: Program;
-	private astClone;
-	declarations: {
-		"*"?: NamespaceVariable;
-		[name: string]: Variable;
-	};
-	private exportAllModules;
-	constructor({
-		id,
-		code,
-		originalCode,
-		originalSourcemap,
-		ast,
-		sourcemapChain,
-		resolvedIds,
-		resolvedExternalIds,
-		graph
-	}: {
-		id: string;
-		code: string;
-		originalCode: string;
-		originalSourcemap: RawSourceMap;
-		ast: Program;
-		sourcemapChain: RawSourceMap[];
-		resolvedIds: IdMap;
-		resolvedExternalIds?: IdMap;
-		graph: Graph;
-	});
-	private addExport(node);
-	private addImport(node);
-	private analyse();
-	basename(): string;
-	mark(): void;
-	link(): void;
-	bindImportSpecifiers(): void;
-	bindReferences(): void;
-	getDynamicImportExpressions(): (string | Node)[];
-	private getOriginalLocation(sourcemapChain, line, column);
-	error(props: RollupError, pos: number): void;
-	getExports(): string[];
-	getReexports(): string[];
-	includeAllInBundle(): void;
-	includeInBundle(): boolean;
-	namespace(): NamespaceVariable;
-	render(es: boolean, legacy: boolean, freeze: boolean): MagicString;
-	toJSON(): ModuleJSON;
-	trace(name: string): Variable;
-	traceExport(name: string): Variable;
-	warn(warning: RollupWarning, pos: number): void;
-}

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

@@ -1,24 +0,0 @@
-import { ExpressionEntity } from "./nodes/shared/Expression";
-import SpreadElement from "./nodes/SpreadElement";
-import TaggedTemplateExpression from "./nodes/TaggedTemplateExpression";
-import NewExpression from "./nodes/NewExpression";
-import Property from "./nodes/Property";
-import CallExpression from "./nodes/CallExpression";
-export declare type CallExpressionType =
-	| TaggedTemplateExpression
-	| CallExpression
-	| NewExpression
-	| Property;
-export interface CallCreateOptions {
-	withNew: boolean;
-	args?: (ExpressionEntity | SpreadElement)[];
-	caller: CallExpressionType;
-}
-export default class CallOptions implements CallCreateOptions {
-	withNew: boolean;
-	args: (ExpressionEntity | SpreadElement)[];
-	caller: CallExpressionType;
-	static create(callOptions: CallCreateOptions): CallOptions;
-	constructor({ withNew, args, caller }?: CallCreateOptions);
-	equals(callOptions: CallOptions): boolean;
-}

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

@@ -1,19 +0,0 @@
-import ExecutionPathOptions from "./ExecutionPathOptions";
-import { ObjectPath } from "./variables/VariableReassignmentTracker";
-export interface Entity {
-	toString: () => string;
-}
-export interface WritableEntity extends Entity {
-	hasEffectsWhenAssignedAtPath(
-		path: ObjectPath,
-		options: ExecutionPathOptions
-	): boolean;
-	/**
-	 * 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.
-	 */
-	reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
-}