jass 0.9.1

data/vendor/node_modules/rollup/dist/typings/ast/utils/extractNames.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '../nodes/shared/Node';
+export default function extractNames(param: Node): string[];

data/vendor/node_modules/rollup/dist/typings/ast/values.d.ts

@@ -0,0 +1,31 @@
+import { ExpressionEntity, SomeReturnExpressionCallback } from './nodes/shared/Expression';
+import CallOptions from './CallOptions';
+import { LiteralValueTypes } from './nodes/Literal';
+import ExecutionPathOptions from './ExecutionPathOptions';
+export interface UnknownKey {
+    type: 'UNKNOWN_KEY';
+}
+export declare type ObjectPathKey = string | UnknownKey;
+export declare type ObjectPath = ObjectPathKey[];
+export declare function isUnknownKey(key: ObjectPathKey): key is UnknownKey;
+export declare const UNKNOWN_KEY: UnknownKey;
+export declare type PathCallback = (path: ObjectPath, expression: ExpressionEntity) => void;
+export declare type PathPredicate = (path: ObjectPath, expression: ExpressionEntity) => boolean;
+export interface MemberDescription {
+    returns: ExpressionEntity;
+    callsArgs: number[] | null;
+}
+export interface MemberDescriptions {
+    [key: string]: MemberDescription;
+}
+export declare const UNKNOWN_VALUE: {
+    toString: () => string;
+};
+export declare const UNKNOWN_EXPRESSION: ExpressionEntity;
+export declare const UNKNOWN_ARRAY_EXPRESSION: ExpressionEntity;
+export declare const UNKNOWN_OBJECT_EXPRESSION: ExpressionEntity;
+export declare const objectMembers: MemberDescriptions;
+export declare const arrayMembers: MemberDescriptions;
+export declare function getLiteralMembersForValue<T = LiteralValueTypes>(value: T): any;
+export declare function hasMemberEffectWhenCalled(members: MemberDescriptions, memberName: ObjectPathKey, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+export declare function someMemberReturnExpressionWhenCalled(members: MemberDescriptions, memberName: ObjectPathKey, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;

data/vendor/node_modules/rollup/dist/typings/ast/variables/ArgumentsVariable.d.ts

@@ -0,0 +1,15 @@
+import LocalVariable from './LocalVariable';
+import { ObjectPath } from '../values';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import CallOptions from '../CallOptions';
+import ParameterVariable from './ParameterVariable';
+import { SomeReturnExpressionCallback } from '../nodes/shared/Expression';
+export default class ArgumentsVariable extends LocalVariable {
+    private _parameters;
+    constructor(parameters: ParameterVariable[]);
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAssignedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+    hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+    someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/ExportDefaultVariable.d.ts

@@ -0,0 +1,16 @@
+import LocalVariable from './LocalVariable';
+import ExportDefaultDeclaration from '../nodes/ExportDefaultDeclaration';
+import Identifier from '../nodes/Identifier';
+import Variable from './Variable';
+export declare function isExportDefaultVariable(variable: Variable): variable is ExportDefaultVariable;
+export default class ExportDefaultVariable extends LocalVariable {
+    isDefault: true;
+    hasId: boolean;
+    private _original;
+    constructor(name: string, exportDefaultDeclaration: ExportDefaultDeclaration);
+    addReference(identifier: Identifier): void;
+    getName(reset?: boolean): string;
+    referencesOriginal(): boolean;
+    getOriginalVariableName(): string;
+    setOriginalVariable(original: Variable): void;
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/ExternalVariable.d.ts

@@ -0,0 +1,12 @@
+import Variable from './Variable';
+import Identifier from '../nodes/Identifier';
+import ExternalModule from '../../ExternalModule';
+export declare function isExternalVariable(variable: Variable): variable is ExternalVariable;
+export default class ExternalVariable extends Variable {
+    module: ExternalModule;
+    isExternal: true;
+    isNamespace: boolean;
+    constructor(module: ExternalModule, name: string);
+    addReference(identifier: Identifier): void;
+    includeVariable(): boolean;
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/GlobalVariable.d.ts

@@ -0,0 +1,11 @@
+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;
+    constructor(name: string);
+    hasEffectsWhenAccessedAtPath(path: ObjectPath): boolean;
+    hasEffectsWhenCalledAtPath(path: ObjectPath): boolean;
+    private isPureFunctionMember(path);
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/LocalVariable.d.ts

@@ -0,0 +1,21 @@
+import Variable from './Variable';
+import VariableReassignmentTracker from './VariableReassignmentTracker';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import CallOptions from '../CallOptions';
+import Identifier from '../nodes/Identifier';
+import ExportDefaultDeclaration from '../nodes/ExportDefaultDeclaration';
+import { ExpressionEntity, ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from '../nodes/shared/Expression';
+import { ObjectPath } from '../values';
+export default class LocalVariable extends Variable {
+    declarations: Set<Identifier | ExportDefaultDeclaration>;
+    boundExpressions: VariableReassignmentTracker;
+    constructor(name: string, declarator: Identifier | ExportDefaultDeclaration | null, init: ExpressionEntity);
+    addDeclaration(identifier: Identifier): void;
+    forEachReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, callback: ForEachReturnExpressionCallback, options: ExecutionPathOptions): void;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAssignedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+    hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+    includeVariable(): boolean;
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/NamespaceVariable.d.ts

@@ -0,0 +1,20 @@
+import Variable from './Variable';
+import Identifier from '../nodes/Identifier';
+import Module from '../../Module';
+import { RenderOptions } from '../../utils/renderHelpers';
+export declare function isNamespaceVariable(variable: Variable): variable is NamespaceVariable;
+export default class NamespaceVariable extends Variable {
+    isNamespace: true;
+    module: Module;
+    needsNamespaceBlock: boolean;
+    referencedEarly: boolean;
+    originals: {
+        [name: string]: Variable;
+    };
+    references: Identifier[];
+    constructor(module: Module);
+    addReference(identifier: Identifier): void;
+    includeVariable(): boolean;
+    renderFirst(): boolean;
+    renderBlock(options: RenderOptions): string;
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/ParameterVariable.d.ts

@@ -0,0 +1,5 @@
+import ReplaceableInitializationVariable from './ReplaceableInitializationVariable';
+import Identifier from '../nodes/Identifier';
+export default class ParameterVariable extends ReplaceableInitializationVariable {
+    constructor(identifier: Identifier);
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/ReplaceableInitializationVariable.d.ts

@@ -0,0 +1,14 @@
+import LocalVariable from './LocalVariable';
+import { ObjectPath } from '../values';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import CallOptions from '../CallOptions';
+import Identifier from '../nodes/Identifier';
+import { ExpressionEntity, SomeReturnExpressionCallback } from '../nodes/shared/Expression';
+export default class ReplaceableInitializationVariable extends LocalVariable {
+    constructor(name: string, declarator: Identifier | null);
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAssignedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+    hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+    someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+    _getInit(options: ExecutionPathOptions): ExpressionEntity;
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/ThisVariable.d.ts

@@ -0,0 +1,4 @@
+import ReplaceableInitializationVariable from './ReplaceableInitializationVariable';
+export default class ThisVariable extends ReplaceableInitializationVariable {
+    constructor();
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/Variable.d.ts

@@ -0,0 +1,43 @@
+import { ObjectPath } from '../values';
+import CallOptions from '../CallOptions';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Identifier from '../nodes/Identifier';
+import { ExpressionEntity, ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from '../nodes/shared/Expression';
+export default class Variable implements ExpressionEntity {
+    exportName?: string;
+    included: boolean;
+    isExternal?: boolean;
+    isGlobal?: boolean;
+    isDefault?: boolean;
+    isNamespace?: boolean;
+    isReassigned: boolean;
+    isId: boolean;
+    name: string;
+    reexported?: boolean;
+    safeName: string;
+    constructor(name: string);
+    /**
+     * Binds identifiers that reference this variable to this variable.
+     * Necessary to be able to change variable names.
+     */
+    addReference(_identifier: Identifier): void;
+    reassignPath(_path: ObjectPath, _options: ExecutionPathOptions): void;
+    forEachReturnExpressionWhenCalledAtPath(_path: ObjectPath, _callOptions: CallOptions, _callback: ForEachReturnExpressionCallback, _options: ExecutionPathOptions): void;
+    getName(reset?: boolean): string;
+    getValue(): {
+        toString: () => string;
+    };
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAssignedAtPath(_path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    hasEffectsWhenCalledAtPath(_path: ObjectPath, _callOptions: CallOptions, _options: ExecutionPathOptions): boolean;
+    /**
+     * Marks this variable as being part of the bundle, which is usually the case when one of
+     * its identifiers becomes part of the bundle. Returns true if it has not been included
+     * previously.
+     * Once a variable is included, it should take care all its declarations are included.
+     */
+    includeVariable(): boolean;
+    someReturnExpressionWhenCalledAtPath(_path: ObjectPath, _callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+    toString(): string;
+    setSafeName(name: string): void;
+}

data/vendor/node_modules/rollup/dist/typings/ast/variables/VariableReassignmentTracker.d.ts

@@ -0,0 +1,11 @@
+import { ObjectPath, PathCallback, PathPredicate } from '../values';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { ExpressionEntity } from '../nodes/shared/Expression';
+export default class VariableReassignmentTracker {
+    private _initialExpression;
+    private _reassignedPathTracker;
+    constructor(initialExpression: ExpressionEntity);
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    forEachAtPath(path: ObjectPath, callback: PathCallback): void;
+    someAtPath(path: ObjectPath, predicateFunction: PathPredicate): boolean;
+}

data/vendor/node_modules/rollup/dist/typings/finalisers/amd.d.ts

@@ -0,0 +1,11 @@
+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;

data/vendor/node_modules/rollup/dist/typings/finalisers/cjs.d.ts

@@ -0,0 +1,10 @@
+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;

data/vendor/node_modules/rollup/dist/typings/finalisers/es.d.ts

@@ -0,0 +1,9 @@
+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;

data/vendor/node_modules/rollup/dist/typings/finalisers/iife.d.ts

@@ -0,0 +1,10 @@
+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;

data/vendor/node_modules/rollup/dist/typings/finalisers/index.d.ts

@@ -0,0 +1,15 @@
+import Chunk 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}: {
+    exportMode: string;
+    indentString: string;
+    getPath: (name: string) => string;
+    intro: string;
+    outro: string;
+    dynamicImport: boolean;
+}, options: OutputOptions) => MagicStringBundle;
+declare const _default: {
+    [format: string]: Finaliser;
+};
+export default _default;

data/vendor/node_modules/rollup/dist/typings/finalisers/shared/esModuleExport.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "Object.defineProperty(exports, '__esModule', { value: true });";
+export default _default;

data/vendor/node_modules/rollup/dist/typings/finalisers/shared/getExportBlock.d.ts

@@ -0,0 +1,2 @@
+import { ChunkExports, ChunkDependencies } from '../../Chunk';
+export default function getExportBlock(exports: ChunkExports, dependencies: ChunkDependencies, exportMode: string, mechanism?: string): string;

data/vendor/node_modules/rollup/dist/typings/finalisers/shared/getGlobalNameMaker.d.ts

@@ -0,0 +1,4 @@
+import { GlobalsOption } from '../../rollup/index';
+import Graph from '../../Graph';
+import { ModuleDeclarationDependency } from '../../Chunk';
+export default function getGlobalNameMaker(globals: GlobalsOption, graph: Graph, fallback?: string): (dependency: ModuleDeclarationDependency) => string;

data/vendor/node_modules/rollup/dist/typings/finalisers/shared/getInteropBlock.d.ts

@@ -0,0 +1,3 @@
+import { OutputOptions } from '../../rollup/index';
+import { ModuleDeclarationDependency } from '../../Chunk';
+export default function getInteropBlock(dependencies: ModuleDeclarationDependency[], options: OutputOptions, varOrConst: string): string;

data/vendor/node_modules/rollup/dist/typings/finalisers/shared/sanitize.d.ts

@@ -0,0 +1,2 @@
+export declare function property(prop: string): string;
+export declare function keypath(keypath: string): string;

data/vendor/node_modules/rollup/dist/typings/finalisers/shared/setupNamespace.d.ts

@@ -0,0 +1,2 @@
+import { GlobalsOption } from '../../rollup/index';
+export default function setupNamespace(name: string, root: string, forAssignment: boolean, globals: GlobalsOption): string;

data/vendor/node_modules/rollup/dist/typings/finalisers/shared/trimEmptyImports.d.ts

@@ -0,0 +1,2 @@
+import { ModuleDeclarationDependency } from '../../Chunk';
+export default function trimEmptyImports(dependencies: ModuleDeclarationDependency[]): ModuleDeclarationDependency[];

data/vendor/node_modules/rollup/dist/typings/finalisers/shared/warnOnBuiltins.d.ts

@@ -0,0 +1,2 @@
+import Chunk from '../../Chunk';
+export default function warnOnBuiltins(chunk: Chunk): void;

data/vendor/node_modules/rollup/dist/typings/finalisers/system.d.ts

@@ -0,0 +1,8 @@
+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;

data/vendor/node_modules/rollup/dist/typings/finalisers/umd.d.ts

@@ -0,0 +1,10 @@
+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;

data/vendor/node_modules/rollup/dist/typings/node-entry.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="../../typings/package.json.d.ts" />
+export * from './rollup/index';
+export * from './watch/index';
+export { default as rollup } from './rollup/index';
+export { default as watch } from './watch/index';
+export { version as VERSION } from 'package.json';

data/vendor/node_modules/rollup/dist/typings/rollup/index.d.ts

@@ -0,0 +1,167 @@
+import { SerializedTimings } from '../utils/timers';
+import { ModuleJSON } from '../Module';
+import { RawSourceMap } from 'source-map';
+import Program from '../ast/nodes/Program';
+import { Node } from '../ast/nodes/shared/Node';
+import { WatcherOptions } from '../watch/index';
+import { TransformContext } from '../utils/transform';
+import { SourceMap } from 'magic-string';
+export declare const VERSION = "<@VERSION@>";
+export declare type SourceDescription = {
+    code: string;
+    map?: RawSourceMap;
+    ast?: Program;
+};
+export declare type ResolveIdHook = (id: string, parent: string) => Promise<string | boolean | void> | string | boolean | void;
+export declare type MissingExportHook = (exportName: string, importingModule: string, importedModule: string, importerStart?: number) => void;
+export declare type IsExternalHook = (id: string, parentId: string, isResolved: boolean) => Promise<boolean | void> | boolean | void;
+export declare type LoadHook = (id: string) => Promise<SourceDescription | string | void> | SourceDescription | string | void;
+export declare type TransformHook = (this: TransformContext, code: string, id: String) => Promise<SourceDescription | string | void>;
+export declare type TransformBundleHook = (code: string, options: OutputOptions) => Promise<SourceDescription | string>;
+export declare type ResolveDynamicImportHook = (specifier: string | Node, parentId: string) => Promise<string | void> | string | void;
+export interface Plugin {
+    name: string;
+    options?: (options: InputOptions) => void;
+    load?: LoadHook;
+    resolveId?: ResolveIdHook;
+    missingExport?: MissingExportHook;
+    transform?: TransformHook;
+    transformBundle?: TransformBundleHook;
+    ongenerate?: (options: OutputOptions, source: SourceDescription) => void;
+    onwrite?: (options: OutputOptions, source: SourceDescription) => void;
+    resolveDynamicImport?: ResolveDynamicImportHook;
+    banner?: () => string;
+    footer?: () => string;
+    intro?: () => string;
+    outro?: () => string;
+}
+export interface TreeshakingOptions {
+    propertyReadSideEffects: boolean;
+    pureExternalModules: boolean;
+}
+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[];
+    external?: ExternalOption;
+    plugins?: Plugin[];
+    onwarn?: WarningHandler;
+    cache?: CachedChunk | CachedChunkSet;
+    acorn?: {};
+    acornInjectPlugins?: Function[];
+    treeshake?: boolean | TreeshakingOptions;
+    context?: string;
+    moduleContext?: string | ((id: string) => string) | {
+        [id: string]: string;
+    };
+    watch?: WatcherOptions;
+    experimentalDynamicImport?: boolean;
+    experimentalCodeSplitting?: boolean;
+    preserveSymlinks?: boolean;
+    experimentalPreserveModules?: boolean;
+    pureExternalModules?: boolean;
+    preferConst?: boolean;
+    perf?: boolean;
+    entry?: string;
+    transform?: TransformHook;
+    load?: LoadHook;
+    resolveId?: ResolveIdHook;
+    resolveExternal?: any;
+}
+export declare type ModuleFormat = 'amd' | 'cjs' | 'system' | 'es' | 'es6' | 'iife' | 'umd';
+export interface OutputOptions {
+    file?: string;
+    dir?: string;
+    format?: ModuleFormat;
+    name?: string;
+    globals?: GlobalsOption;
+    paths?: Record<string, string> | ((id: string, parent: string) => string);
+    banner?: string;
+    footer?: string;
+    intro?: string;
+    outro?: string;
+    sourcemap?: boolean | 'inline';
+    sourcemapFile?: string;
+    interop?: boolean;
+    extend?: boolean;
+    exports?: 'default' | 'named' | 'none' | 'auto';
+    amd?: {
+        id?: string;
+        define?: string;
+    };
+    indent?: boolean;
+    strict?: boolean;
+    freeze?: boolean;
+    namespaceToStringTag?: boolean;
+    legacy?: boolean;
+    noConflict?: boolean;
+    dest?: string;
+    moduleId?: string;
+}
+export interface RollupWarning {
+    message?: string;
+    code?: string;
+    loc?: {
+        file: string;
+        line: number;
+        column: number;
+    };
+    deprecations?: {
+        old: string;
+        new: string;
+    }[];
+    modules?: string[];
+    names?: string[];
+    source?: string;
+    importer?: string;
+    frame?: any;
+    missing?: string;
+    exporter?: string;
+    name?: string;
+    sources?: string[];
+    reexporter?: string;
+    guess?: string;
+    url?: string;
+    id?: string;
+    plugin?: string;
+    pos?: number;
+    pluginCode?: string;
+}
+export declare type WarningHandler = (warning: string | RollupWarning) => void;
+export interface OutputChunk {
+    imports: string[];
+    exports: string[];
+    modules: ModuleJSON[];
+    generate: (outputOptions: OutputOptions) => Promise<{
+        code: string;
+        map: SourceMap;
+    }>;
+    write: (options: OutputOptions) => Promise<void>;
+    getTimings?: () => SerializedTimings;
+}
+export interface OutputChunkSet {
+    chunks: {
+        [chunkName: string]: {
+            name: string;
+            imports: string[];
+            exports: string[];
+            modules: ModuleJSON[];
+        };
+    };
+    generate: (outputOptions: OutputOptions) => Promise<{
+        [chunkName: string]: SourceDescription;
+    }>;
+    write: (options: OutputOptions) => Promise<void>;
+    getTimings?: () => SerializedTimings;
+}
+export default function rollup(rawInputOptions: InputOptions): Promise<OutputChunk | OutputChunkSet>;