rollup 0.57.0 → 0.58.2

package/dist/typings/Chunk.d.ts

@@ -1,9 +1,10 @@
 import { SourceMap } from 'magic-string';
-import Module, { ModuleJSON } from './Module';
+import Module from './Module';
 import { OutputOptions } from './rollup/index';
 import Graph from './Graph';
 import ExternalModule from './ExternalModule';
 import Variable from './ast/variables/Variable';
+import { Addons } from './utils/addons';
 export interface ModuleDeclarations {
     exports: ChunkExports;
     dependencies: ModuleDeclarationDependency[];
@@ -11,6 +12,7 @@ export interface ModuleDeclarations {
 export interface ModuleDeclarationDependency {
     id: string;
     name: string;
+    globalName: string;
     isChunk: boolean;
     exportsDefault: boolean;
     exportsNames: boolean;
@@ -39,47 +41,57 @@ export interface DynamicImportMechanism {
     interopRight?: string;
 }
 export default class Chunk {
+    hasDynamicImport: boolean;
+    indentString: string;
+    usedModules: Module[];
     id: string;
     name: string;
     graph: Graph;
     private orderedModules;
-    private exportedVariableNames;
     private imports;
     private exports;
+    private exportNames;
     private dependencies;
     entryModule: Module;
     isEntryModuleFacade: boolean;
+    isManualChunk: boolean;
+    private renderedHash;
+    private renderedModuleSources;
+    private renderedSource;
+    private renderedSourceLength;
+    private renderedDeclarations;
     constructor(graph: Graph, orderedModules: Module[]);
-    setId(id: string): void;
-    ensureExport(module: Module | ExternalModule, variable: Variable, exportName: string): string;
-    generateEntryExports(entryModule: Module, onlyIncluded?: boolean): void;
-    collectDependencies(entryFacade?: Module): void;
-    generateImports(): void;
-    populateImport(variable: Variable, tracedExport: {
-        name: string;
-        module: Module | ExternalModule;
-    }): void;
     getImportIds(): string[];
     getExportNames(): string[];
-    getJsonModules(): ModuleJSON[];
-    traceImport(module: Module | ExternalModule, exportName: string): {
-        name: string;
-        module: ExternalModule | Module;
-    };
-    traceExport(module: Module | ExternalModule, name: string): {
-        name: string;
+    getModuleIds(): string[];
+    private inlineDeepModuleDependencies();
+    linkFacade(entryFacade: Module): void;
+    link(): void;
+    populateEntryExports(preserveModules: boolean): void;
+    private traceImport(exportName, module);
+    traceExport(name: string, module: Module | ExternalModule): {
+        variable: Variable;
         module: Module | ExternalModule;
     };
-    collectAddon(initialAddon: string, addonName: 'banner' | 'footer' | 'intro' | 'outro', sep?: string): Promise<string>;
-    private setDynamicImportResolutions({format});
+    getVariableExportName(variable: Variable): string;
+    generateInternalExports(options: OutputOptions): void;
+    private prepareDynamicImports({format});
+    private finaliseDynamicImports();
     private setIdentifierRenderResolutions(options);
-    private getCheckReexportDeclarations();
-    private getChunkDependencyDeclarations();
+    private getChunkDependencyDeclarations(options);
     private getChunkExportDeclarations();
-    getModuleDeclarations(): ModuleDeclarations;
-    render(options: OutputOptions): Promise<{
+    getRenderedHash(): string;
+    postVisitChunkDependencies(visitor: (dep: Chunk | ExternalModule) => any): boolean;
+    private computeFullHash(addons, options);
+    preRender(options: OutputOptions): void;
+    getRenderedSourceLength(): number;
+    merge(chunk: Chunk, chunkList: Chunk[], options: OutputOptions): void;
+    generateNamePreserveModules(preserveModulesRelativeDir: string): string;
+    generateName(pattern: string, addons: Addons, options: OutputOptions, existingNames?: {
+        [name: string]: boolean;
+    }): void;
+    render(options: OutputOptions, addons: Addons): Promise<{
         code: string;
         map: SourceMap;
     }>;
-    private createGetPath(options);
 }

package/dist/typings/ExternalModule.d.ts

@@ -1,6 +1,7 @@
 import ExternalVariable from './ast/variables/ExternalVariable';
 import Graph from './Graph';
 import Variable from './ast/variables/Variable';
+import { OutputOptions } from './rollup';
 export default class ExternalModule {
     private graph;
     chunk: void;
@@ -10,6 +11,7 @@ export default class ExternalModule {
     exportsNames: boolean;
     exportsNamespace: boolean;
     id: string;
+    renderPath: string;
     isExternal: true;
     isEntryPoint: false;
     name: string;
@@ -24,6 +26,7 @@ export default class ExternalModule {
         graph: Graph;
         id: string;
     });
+    setRenderPath(options: OutputOptions, inputPath: string): void;
     suggestName(name: string): void;
     warnUnusedImports(): void;
     traceExport(name: string): Variable;

package/dist/typings/Graph.d.ts

@@ -8,6 +8,7 @@ import Chunk from './Chunk';
 import GlobalScope from './ast/scopes/GlobalScope';
 export declare type ResolveDynamicImportHandler = (specifier: string | Node, parentId: string) => Promise<string | void>;
 export default class Graph {
+    curChunkIndex: number;
     acornOptions: acorn.Options;
     acornParse: acorn.IParse;
     cachedModules: Map<string, ModuleJSON>;
@@ -18,7 +19,6 @@ export default class Graph {
     hasLoaders: boolean;
     isExternal: IsExternalHook;
     isPureExternalModule: (id: string) => boolean;
-    legacy: boolean;
     load: (id: string) => Promise<SourceDescription | string | void>;
     handleMissingExport: (exportName: string, importingModule: Module, importedModule: string, importerStart?: number) => void;
     moduleById: Map<string, Module | ExternalModule>;
@@ -32,15 +32,16 @@ export default class Graph {
     varOrConst: 'var' | 'const';
     treeshake: boolean;
     constructor(options: InputOptions);
-    getPathRelativeToBaseDirname(resolvedId: string, parentId: string): string;
+    getCache(): {
+        modules: ModuleJSON[];
+    };
     private loadModule(entryName);
     private link();
     includeMarked(modules: Module[]): void;
     buildSingle(entryModuleId: string): Promise<Chunk>;
-    buildChunks(entryModuleIds: string[], preserveModules: boolean): Promise<{
-        [name: string]: Chunk;
-    }>;
-    private analyseExecution(entryModules, preserveModules?);
+    private loadEntryModules(entryModules, manualChunks);
+    buildChunks(entryModules: Record<string, string> | string[], manualChunks: Record<string, string[]> | void, preserveModules: boolean): Promise<Chunk[]>;
+    private analyseExecution(entryModules, graphColouring, chunkModules?);
     private warnCycle(id, parentId, parents);
     private fetchModule(id, importer);
     private fetchAllDependencies(module);

package/dist/typings/Module.d.ts

@@ -84,9 +84,13 @@ export default class Module {
     sourcemapChain: RawSourceMap[];
     sources: string[];
     dynamicImports: Import[];
-    dynamicImportResolutions: (Module | ExternalModule | string | void)[];
+    dynamicImportResolutions: {
+        alias: string;
+        resolution: Module | ExternalModule | string | void;
+    }[];
     execIndex: number;
     isEntryPoint: boolean;
+    chunkAlias: string;
     entryPointsHash: Uint8Array;
     chunk: Chunk;
     ast: Program;

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

@@ -1,27 +1,25 @@
 import { ObjectPath } from '../values';
 import ExecutionPathOptions from '../ExecutionPathOptions';
 import CallOptions from '../CallOptions';
-import Scope from '../scopes/Scope';
 import MagicString from 'magic-string';
 import { ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './shared/Expression';
 import { NodeType } from './NodeType';
 import { ExpressionNode, NodeBase } from './shared/Node';
-import { RenderOptions } from '../../utils/renderHelpers';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
 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, options: RenderOptions): void;
+    includeInBundle(): boolean;
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    render(code: MagicString, options: RenderOptions, {renderedParentType, isCalleeOfRenderedParent}?: NodeRenderOptions): void;
     someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
     private forEachRelevantBranch(callback);
     private someRelevantBranch(predicateFunction);

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

@@ -17,5 +17,4 @@ export default class ExportDefaultDeclaration extends NodeBase {
     render(code: MagicString, options: RenderOptions, {start, end}?: NodeRenderOptions): void;
     private renderNamedDeclaration(code, declarationStart, declarationKeyword, needsId, options);
     private renderVariableDeclaration(code, declarationStart, options);
-    private renderForSideEffectsOnly(code, declarationStart);
 }

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

@@ -7,7 +7,7 @@ import CallOptions from '../CallOptions';
 import MagicString from 'magic-string';
 import { ExpressionEntity, ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './shared/Expression';
 import { NodeType } from './NodeType';
-import { RenderOptions } from '../../utils/renderHelpers';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
 export declare function isIdentifier(node: Node): node is Identifier;
 export default class Identifier extends NodeBase {
     type: NodeType.Identifier;
@@ -24,6 +24,6 @@ export default class Identifier extends NodeBase {
     reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
     private disallowImportReassignment();
     renderSystemBindingUpdate(code: MagicString, name: string): void;
-    render(code: MagicString, options: RenderOptions): void;
+    render(code: MagicString, options: RenderOptions, {renderedParentType, isCalleeOfRenderedParent}?: NodeRenderOptions): void;
     someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
 }

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

@@ -2,13 +2,15 @@ import CallExpression from './CallExpression';
 import { NodeType } from './NodeType';
 import { NodeBase } from './shared/Node';
 import MagicString from 'magic-string';
-import NamespaceVariable from '../variables/NamespaceVariable';
 import { RenderOptions } from '../../utils/renderHelpers';
 export default class Import extends NodeBase {
     type: NodeType.Import;
     parent: CallExpression;
-    private resolution;
+    constructor();
+    private resolutionNamespace;
     private resolutionInterop;
-    setResolution(resolution: NamespaceVariable | string | void, interop: boolean): void;
+    private rendered;
+    setResolution(interop: boolean, namespace?: string): void;
+    renderFinalResolution(code: MagicString, resolution: string): void;
     render(code: MagicString, options: RenderOptions): void;
 }

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

@@ -1,23 +1,27 @@
 import { ObjectPath } from '../values';
 import CallOptions from '../CallOptions';
 import ExecutionPathOptions from '../ExecutionPathOptions';
-import { ForEachReturnExpressionCallback, PredicateFunction, SomeReturnExpressionCallback } from './shared/Expression';
+import { ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './shared/Expression';
 import { NodeType } from './NodeType';
 import { ExpressionNode, NodeBase } from './shared/Node';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
+import MagicString from 'magic-string';
 export declare type LogicalOperator = '||' | '&&';
 export default class LogicalExpression extends NodeBase {
     type: NodeType.LogicalExpression;
     operator: LogicalOperator;
     left: ExpressionNode;
     right: ExpressionNode;
-    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;
+    includeInBundle(): boolean;
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    render(code: MagicString, options: RenderOptions, {renderedParentType, isCalleeOfRenderedParent}?: NodeRenderOptions): void;
     someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
-    _forEachRelevantBranch(callback: (node: ExpressionNode) => void): void;
-    _someRelevantBranch(predicateFunction: PredicateFunction): boolean;
+    private forEachRelevantBranch(callback);
+    private someRelevantBranch(predicateFunction);
 }

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

@@ -5,7 +5,7 @@ import CallOptions from '../CallOptions';
 import MagicString from 'magic-string';
 import { ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './shared/Expression';
 import { NodeType } from './NodeType';
-import { RenderOptions } from '../../utils/renderHelpers';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
 import { ObjectPath, ObjectPathKey } from '../values';
 export declare function isMemberExpression(node: Node): node is MemberExpression;
 export default class MemberExpression extends NodeBase {
@@ -29,6 +29,6 @@ export default class MemberExpression extends NodeBase {
     initialiseNode(): void;
     reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
     private disallowNamespaceReassignment();
-    render(code: MagicString, options: RenderOptions): void;
+    render(code: MagicString, options: RenderOptions, {renderedParentType, isCalleeOfRenderedParent}?: NodeRenderOptions): void;
     someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
 }

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

@@ -5,6 +5,8 @@ import { ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from '.
 import { ObjectPath, ObjectPathKey } from '../values';
 import { Node, NodeBase } from './shared/Node';
 import { NodeType } from './NodeType';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
+import MagicString from 'magic-string';
 export declare function isObjectExpression(node: Node): node is ObjectExpression;
 export default class ObjectExpression extends NodeBase {
     type: NodeType.ObjectExpression;
@@ -18,5 +20,6 @@ export default class ObjectExpression extends NodeBase {
     hasEffectsWhenAccessedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
     hasEffectsWhenAssignedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
     hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+    render(code: MagicString, options: RenderOptions, {renderedParentType}?: NodeRenderOptions): void;
     someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
 }

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

@@ -2,12 +2,20 @@ import ExecutionPathOptions from '../ExecutionPathOptions';
 import MagicString from 'magic-string';
 import { ExpressionNode, NodeBase } from './shared/Node';
 import { NodeType } from './NodeType';
-import { RenderOptions } from '../../utils/renderHelpers';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
+import { ObjectPath } from '../values';
+import CallOptions from '../CallOptions';
+import { ForEachReturnExpressionCallback } from './shared/Expression';
 export default class SequenceExpression extends NodeBase {
     type: NodeType.SequenceExpression;
     expressions: ExpressionNode[];
+    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;
     includeInBundle(): boolean;
-    render(code: MagicString, options: RenderOptions): void;
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    render(code: MagicString, options: RenderOptions, {renderedParentType, isCalleeOfRenderedParent}?: NodeRenderOptions): void;
 }

package/dist/typings/ast/variables/GlobalVariable.d.ts

@@ -1,6 +1,5 @@
 import Variable from './Variable';
 import { ObjectPath } from '../values';
-export declare function isGlobalVariable(variable: Variable): variable is GlobalVariable;
 export default class GlobalVariable extends Variable {
     isExternal: true;
     isGlobal: true;

package/dist/typings/chunk-optimization.d.ts

@@ -0,0 +1,3 @@
+import Chunk from './Chunk';
+import { OutputOptions } from './rollup';
+export declare function optimizeChunks(chunks: Chunk[], options: OutputOptions, CHUNK_GROUPING_SIZE: number): Chunk[];

package/dist/typings/finalisers/amd.d.ts

@@ -1,11 +1,4 @@
-import Chunk from '../Chunk';
 import { Bundle as MagicStringBundle } from 'magic-string';
 import { OutputOptions } from '../rollup/index';
-export default function amd(chunk: Chunk, magicString: MagicStringBundle, {exportMode, getPath, indentString, intro, outro, dynamicImport}: {
-    exportMode: string;
-    indentString: string;
-    getPath: (name: string) => string;
-    intro: string;
-    outro: string;
-    dynamicImport: boolean;
-}, options: OutputOptions): MagicStringBundle;
+import { FinaliserOptions } from './index';
+export default function amd(magicString: MagicStringBundle, {graph, exportMode, indentString, intro, outro, dynamicImport, dependencies, exports, isEntryModuleFacade}: FinaliserOptions, options: OutputOptions): MagicStringBundle;

package/dist/typings/finalisers/cjs.d.ts

@@ -1,10 +1,4 @@
 import { OutputOptions } from '../rollup/index';
 import { Bundle as MagicStringBundle } from 'magic-string';
-import Chunk from '../Chunk';
-export default function cjs(chunk: Chunk, magicString: MagicStringBundle, {exportMode, getPath, intro, outro}: {
-    exportMode: string;
-    indentString: string;
-    getPath: (name: string) => string;
-    intro: string;
-    outro: string;
-}, options: OutputOptions): MagicStringBundle;
+import { FinaliserOptions } from './index';
+export default function cjs(magicString: MagicStringBundle, {graph, isEntryModuleFacade, exportMode, intro, outro, dependencies, exports}: FinaliserOptions, options: OutputOptions): MagicStringBundle;

package/dist/typings/finalisers/es.d.ts

@@ -1,9 +1,3 @@
 import { Bundle as MagicStringBundle } from 'magic-string';
-import Chunk from '../Chunk';
-export default function es(chunk: Chunk, magicString: MagicStringBundle, {getPath, intro, outro}: {
-    exportMode: string;
-    indentString: string;
-    getPath: (name: string) => string;
-    intro: string;
-    outro: string;
-}): MagicStringBundle;
+import { FinaliserOptions } from './index';
+export default function es(magicString: MagicStringBundle, {intro, outro, dependencies, exports}: FinaliserOptions): MagicStringBundle;

package/dist/typings/finalisers/iife.d.ts

@@ -1,10 +1,4 @@
-import Chunk from '../Chunk';
 import { Bundle as MagicStringBundle } from 'magic-string';
 import { OutputOptions } from '../rollup/index';
-export default function iife(chunk: Chunk, magicString: MagicStringBundle, {exportMode, indentString, intro, outro}: {
-    exportMode: string;
-    indentString: string;
-    getPath: (name: string) => string;
-    intro: string;
-    outro: string;
-}, options: OutputOptions): MagicStringBundle;
+import { FinaliserOptions } from './index';
+export default function iife(magicString: MagicStringBundle, {graph, exportMode, indentString, intro, outro, dependencies, exports}: FinaliserOptions, options: OutputOptions): MagicStringBundle;

package/dist/typings/finalisers/index.d.ts

@@ -1,14 +1,19 @@
-import Chunk from '../Chunk';
+import { ChunkDependencies, ChunkExports } from '../Chunk';
 import { Bundle as MagicStringBundle } from 'magic-string';
 import { OutputOptions } from '../rollup/index';
-export declare type Finaliser = (chunk: Chunk, magicString: MagicStringBundle, {exportMode, getPath, indentString, intro, outro}: {
+import Graph from '../Graph';
+export interface FinaliserOptions {
     exportMode: string;
     indentString: string;
-    getPath: (name: string) => string;
     intro: string;
     outro: string;
     dynamicImport: boolean;
-}, options: OutputOptions) => MagicStringBundle;
+    dependencies: ChunkDependencies;
+    exports: ChunkExports;
+    graph: Graph;
+    isEntryModuleFacade: boolean;
+}
+export declare type Finaliser = (magicString: MagicStringBundle, finaliserOptions: FinaliserOptions, options: OutputOptions) => MagicStringBundle;
 declare const _default: {
     [format: string]: Finaliser;
 };

package/dist/typings/finalisers/shared/warnOnBuiltins.d.ts

@@ -1,2 +1,3 @@
-import Chunk from '../../Chunk';
-export default function warnOnBuiltins(chunk: Chunk): void;
+import { ChunkDependencies } from '../../Chunk';
+import Graph from '../../Graph';
+export default function warnOnBuiltins(graph: Graph, dependencies: ChunkDependencies): void;

package/dist/typings/finalisers/system.d.ts

@@ -1,8 +1,3 @@
-import Chunk from '../Chunk';
 import { Bundle as MagicStringBundle } from 'magic-string';
-export default function system(chunk: Chunk, magicString: MagicStringBundle, {getPath, indentString: t, intro, outro}: {
-    indentString: string;
-    getPath: (name: string) => string;
-    intro: string;
-    outro: string;
-}): MagicStringBundle;
+import { FinaliserOptions } from './index';
+export default function system(magicString: MagicStringBundle, {graph, indentString: t, intro, outro, dependencies, exports}: FinaliserOptions): MagicStringBundle;

package/dist/typings/finalisers/umd.d.ts

@@ -1,10 +1,4 @@
-import Chunk from '../Chunk';
 import { Bundle as MagicStringBundle } from 'magic-string';
 import { OutputOptions } from '../rollup/index';
-export default function umd(chunk: Chunk, magicString: MagicStringBundle, {exportMode, indentString, getPath, intro, outro}: {
-    exportMode: string;
-    indentString: string;
-    getPath: (name: string) => string;
-    intro: string;
-    outro: string;
-}, options: OutputOptions): MagicStringBundle;
+import { FinaliserOptions } from './index';
+export default function umd(magicString: MagicStringBundle, {graph, exportMode, indentString, intro, outro, dependencies, exports}: FinaliserOptions, options: OutputOptions): MagicStringBundle;

package/dist/typings/rollup/index.d.ts

@@ -1,4 +1,5 @@
 import { SerializedTimings } from '../utils/timers';
+import { GenericConfigObject } from '../utils/mergeOptions';
 import { ModuleJSON } from '../Module';
 import { RawSourceMap } from 'source-map';
 import Program from '../ast/nodes/Program';
@@ -43,20 +44,19 @@ export declare type ExternalOption = string[] | IsExternalHook;
 export declare type GlobalsOption = {
     [name: string]: string;
 } | ((name: string) => string);
-export declare type CachedChunk = {
-    modules: ModuleJSON[];
-};
-export declare type CachedChunkSet = {
-    chunks: {
-        [chunkName: string]: CachedChunk;
-    };
-};
 export interface InputOptions {
-    input: string | string[];
+    input: string | string[] | {
+        [entryAlias: string]: string;
+    };
+    manualChunks?: {
+        [chunkAlias: string]: string[];
+    };
     external?: ExternalOption;
     plugins?: Plugin[];
     onwarn?: WarningHandler;
-    cache?: CachedChunk | CachedChunkSet;
+    cache?: {
+        modules: ModuleJSON[];
+    };
     acorn?: {};
     acornInjectPlugins?: Function[];
     treeshake?: boolean | TreeshakingOptions;
@@ -64,12 +64,13 @@ export interface InputOptions {
     moduleContext?: string | ((id: string) => string) | {
         [id: string]: string;
     };
-    legacy?: boolean;
     watch?: WatcherOptions;
     experimentalDynamicImport?: boolean;
     experimentalCodeSplitting?: boolean;
     preserveSymlinks?: boolean;
     experimentalPreserveModules?: boolean;
+    optimizeChunks?: boolean;
+    chunkGroupingSize?: number;
     pureExternalModules?: boolean;
     preferConst?: boolean;
     perf?: boolean;
@@ -80,13 +81,16 @@ export interface InputOptions {
     resolveExternal?: any;
 }
 export declare type ModuleFormat = 'amd' | 'cjs' | 'system' | 'es' | 'es6' | 'iife' | 'umd';
+export declare type OptionsPaths = Record<string, string> | ((id: string) => string);
 export interface OutputOptions {
     file?: string;
     dir?: string;
     format?: ModuleFormat;
     name?: string;
     globals?: GlobalsOption;
-    paths?: Record<string, string> | ((id: string, parent: string) => string);
+    chunkNames?: string;
+    entryNames?: string;
+    paths?: OptionsPaths;
     banner?: string;
     footer?: string;
     intro?: string;
@@ -140,29 +144,33 @@ export interface RollupWarning {
 }
 export declare type WarningHandler = (warning: string | RollupWarning) => void;
 export interface OutputChunk {
+    imports: string[];
+    exports: string[];
+    modules: string[];
+    code: string;
+    map?: SourceMap;
+}
+export interface Bundle {
     imports: string[];
     exports: string[];
     modules: ModuleJSON[];
-    generate: (outputOptions: OutputOptions) => Promise<{
-        code: string;
-        map: SourceMap;
-    }>;
-    write: (options: OutputOptions) => Promise<void>;
+    cache: {
+        modules: ModuleJSON[];
+    };
+    generate: (outputOptions: OutputOptions) => Promise<OutputChunk>;
+    write: (options: OutputOptions) => Promise<OutputChunk>;
     getTimings?: () => SerializedTimings;
 }
-export interface OutputChunkSet {
-    chunks: {
-        [chunkName: string]: {
-            name: string;
-            imports: string[];
-            exports: string[];
-            modules: ModuleJSON[];
-        };
+export interface BundleSet {
+    cache: {
+        modules: ModuleJSON[];
     };
     generate: (outputOptions: OutputOptions) => Promise<{
-        [chunkName: string]: SourceDescription;
+        [chunkName: string]: OutputChunk;
+    }>;
+    write: (options: OutputOptions) => Promise<{
+        [chunkName: string]: OutputChunk;
     }>;
-    write: (options: OutputOptions) => Promise<void>;
     getTimings?: () => SerializedTimings;
 }
-export default function rollup(rawInputOptions: InputOptions): Promise<OutputChunk | OutputChunkSet>;
+export default function rollup(rawInputOptions: GenericConfigObject | InputOptions): Promise<Bundle | BundleSet>;

package/dist/typings/utils/addons.d.ts

@@ -0,0 +1,10 @@
+import Graph from '../Graph';
+import { OutputOptions } from '../rollup';
+export interface Addons {
+    intro?: string;
+    outro?: string;
+    banner?: string;
+    footer?: string;
+    hash: Uint8Array;
+}
+export declare function createAddons(graph: Graph, options: OutputOptions): Promise<Addons>;

package/dist/typings/utils/blank.d.ts

@@ -0,0 +1 @@
+export declare const BLANK: any;

package/dist/typings/utils/collapseSourcemaps.d.ts

@@ -1,5 +1,5 @@
 import Module from '../Module';
 import { RawSourceMap } from 'source-map';
 import Chunk from '../Chunk';
-import { SourceMap } from 'magic-string';
-export default function collapseSourcemaps(bundle: Chunk, file: string, map: SourceMap, modules: Module[], bundleSourcemapChain: RawSourceMap[]): SourceMap;
+import { SourceMap, DecodedSourceMap } from 'magic-string';
+export default function collapseSourcemaps(bundle: Chunk, file: string, map: DecodedSourceMap, modules: Module[], bundleSourcemapChain: RawSourceMap[]): SourceMap;

package/dist/typings/utils/defaults.d.ts

@@ -1,6 +1,6 @@
 import Module from '../Module';
 import { InputOptions } from '../rollup';
 export declare function load(id: string): string;
-export declare function resolveId(options: InputOptions): (importee: string, importer: string) => string | void;
+export declare function resolveId(options: InputOptions): (importee: string, importer: string) => string;
 export declare function makeOnwarn(): (warning: any) => void;
 export declare function handleMissingExport(exportName: string, importingModule: Module, importedModule: string, importerStart?: number): void;

package/dist/typings/utils/mergeOptions.d.ts

@@ -3,7 +3,10 @@ import { WarningHandler } from '../rollup/index';
 export declare type GenericConfigObject = {
     [key: string]: any;
 };
-export default function mergeOptions({config, command, deprecateConfig, defaultOnWarnHandler}: {
+export declare const commandAliases: {
+    [key: string]: string;
+};
+export default function mergeOptions({config, command: rawCommandOptions, deprecateConfig, defaultOnWarnHandler}: {
     config: GenericConfigObject;
     command?: GenericConfigObject;
     deprecateConfig?: GenericConfigObject;