jass 0.9.1

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

@@ -0,0 +1,85 @@
+import { SourceMap } from 'magic-string';
+import Module, { ModuleJSON } from './Module';
+import { OutputOptions } from './rollup/index';
+import Graph from './Graph';
+import ExternalModule from './ExternalModule';
+import Variable from './ast/variables/Variable';
+export interface ModuleDeclarations {
+    exports: ChunkExports;
+    dependencies: ModuleDeclarationDependency[];
+}
+export interface ModuleDeclarationDependency {
+    id: string;
+    name: string;
+    isChunk: boolean;
+    exportsDefault: boolean;
+    exportsNames: boolean;
+    exportsNamespace: boolean;
+    reexports?: ReexportSpecifier[];
+    imports?: ImportSpecifier[];
+}
+export declare type ChunkDependencies = ModuleDeclarationDependency[];
+export declare type ChunkExports = {
+    local: string;
+    exported: string;
+    hoisted: boolean;
+}[];
+export interface ReexportSpecifier {
+    reexported: string;
+    imported: string;
+}
+export interface ImportSpecifier {
+    local: string;
+    imported: string;
+}
+export interface DynamicImportMechanism {
+    left: string;
+    right: string;
+    interopLeft?: string;
+    interopRight?: string;
+}
+export default class Chunk {
+    id: string;
+    name: string;
+    graph: Graph;
+    private orderedModules;
+    private exportedVariableNames;
+    private imports;
+    private exports;
+    private dependencies;
+    entryModule: Module;
+    isEntryModuleFacade: boolean;
+    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;
+        module: Module | ExternalModule;
+    };
+    collectAddon(initialAddon: string, addonName: 'banner' | 'footer' | 'intro' | 'outro', sep?: string): Promise<string>;
+    private setDynamicImportResolutions({format});
+    private setIdentifierRenderResolutions(options);
+    private getCheckReexportDeclarations();
+    private getChunkDependencyDeclarations();
+    private getChunkExportDeclarations();
+    getModuleDeclarations(): ModuleDeclarations;
+    render(options: OutputOptions): Promise<{
+        code: string;
+        map: SourceMap;
+    }>;
+    private createGetPath(options);
+}

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

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

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

@@ -0,0 +1,47 @@
+/// <reference types="acorn" />
+import * as acorn from 'acorn';
+import Module, { ModuleJSON } from './Module';
+import ExternalModule from './ExternalModule';
+import { InputOptions, IsExternalHook, Plugin, RollupWarning, SourceDescription, TreeshakingOptions, WarningHandler } from './rollup/index';
+import { Node } from './ast/nodes/shared/Node';
+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 {
+    acornOptions: acorn.Options;
+    acornParse: acorn.IParse;
+    cachedModules: Map<string, ModuleJSON>;
+    context: string;
+    dynamicImport: boolean;
+    externalModules: ExternalModule[];
+    getModuleContext: (id: string) => string;
+    hasLoaders: boolean;
+    isExternal: IsExternalHook;
+    isPureExternalModule: (id: string) => boolean;
+    load: (id: string) => Promise<SourceDescription | string | void>;
+    handleMissingExport: (exportName: string, importingModule: Module, importedModule: string, importerStart?: number) => 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';
+    treeshake: boolean;
+    constructor(options: InputOptions);
+    getPathRelativeToBaseDirname(resolvedId: string, parentId: string): string;
+    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, graphColouring);
+    private warnCycle(id, parentId, parents);
+    private fetchModule(id, importer);
+    private fetchAllDependencies(module);
+    warn(warning: RollupWarning): void;
+}

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

@@ -0,0 +1,130 @@
+/// <reference types="acorn" />
+import { Options as AcornOptions } from 'acorn';
+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';
+import Chunk from './Chunk';
+import { RenderOptions } from './utils/renderHelpers';
+export interface IdMap {
+    [key: string]: string;
+}
+export interface CommentDescription {
+    block: boolean;
+    text: string;
+    start: number;
+    end: number;
+}
+export interface ImportDescription {
+    source: string;
+    specifier: ImportSpecifier | ImportNamespaceSpecifier | ImportDefaultSpecifier;
+    name: string;
+    module: Module | ExternalModule | null;
+}
+export interface ExportDescription {
+    localName: string;
+    identifier?: string;
+}
+export interface ReexportDescription {
+    localName: string;
+    start: number;
+    source: string;
+    module: Module;
+}
+export declare const defaultAcornOptions: AcornOptions;
+export interface ModuleJSON {
+    id: string;
+    dependencies: string[];
+    code: string;
+    originalCode: string;
+    originalSourcemap: RawSourceMap | void;
+    ast: Program;
+    sourcemapChain: RawSourceMap[];
+    resolvedIds: IdMap;
+}
+export default class Module {
+    type: 'Module';
+    graph: Graph;
+    code: string;
+    comments: CommentDescription[];
+    context: string;
+    dependencies: (Module | ExternalModule)[];
+    excludeFromSourcemap: boolean;
+    exports: {
+        [name: string]: ExportDescription;
+    };
+    exportsAll: {
+        [name: string]: string;
+    };
+    exportAllSources: string[];
+    id: string;
+    imports: {
+        [name: string]: ImportDescription;
+    };
+    isExternal: false;
+    magicString: MagicString;
+    originalCode: string;
+    originalSourcemap: RawSourceMap | void;
+    reexports: {
+        [name: string]: ReexportDescription;
+    };
+    resolvedIds: IdMap;
+    scope: ModuleScope;
+    sourcemapChain: RawSourceMap[];
+    sources: string[];
+    dynamicImports: Import[];
+    dynamicImportResolutions: (Module | ExternalModule | string | void)[];
+    execIndex: number;
+    isEntryPoint: boolean;
+    entryPointsHash: Uint8Array;
+    chunk: Chunk;
+    ast: Program;
+    private astClone;
+    declarations: {
+        '*'?: NamespaceVariable;
+        [name: string]: Variable | undefined;
+    };
+    exportAllModules: (Module | ExternalModule)[];
+    constructor(graph: Graph, id: string);
+    setSource({code, originalCode, originalSourcemap, ast, sourcemapChain, resolvedIds}: {
+        code: string;
+        originalCode: string;
+        originalSourcemap: RawSourceMap;
+        ast: Program;
+        sourcemapChain: RawSourceMap[];
+        resolvedIds?: IdMap;
+    }): void;
+    private removeExistingSourceMap();
+    private addExport(node);
+    private addImport(node);
+    private analyse();
+    basename(): string;
+    markExports(): void;
+    linkDependencies(): void;
+    bindReferences(): void;
+    getDynamicImportExpressions(): (string | Node)[];
+    private getOriginalLocation(sourcemapChain, location);
+    error(props: RollupError, pos: number): void;
+    getAllExports(): string[];
+    getExports(): string[];
+    getReexports(): string[];
+    includeAllInBundle(): void;
+    includeInBundle(): boolean;
+    namespace(): NamespaceVariable;
+    render(options: RenderOptions): MagicString;
+    toJSON(): ModuleJSON;
+    trace(name: string): Variable;
+    traceExport(name: string): Variable;
+    warn(warning: RollupWarning, pos: number): void;
+}

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

@@ -0,0 +1,20 @@
+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)[];
+    callIdentifier: Object;
+}
+export default class CallOptions implements CallCreateOptions {
+    withNew: boolean;
+    args: (ExpressionEntity | SpreadElement)[];
+    callIdentifier: Object;
+    static create(callOptions: CallCreateOptions): CallOptions;
+    constructor({withNew, args, callIdentifier}?: CallCreateOptions);
+    equals(callOptions: CallOptions): boolean;
+}

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

@@ -0,0 +1,16 @@
+import ExecutionPathOptions from './ExecutionPathOptions';
+import { ObjectPath } from './values';
+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;
+}

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

@@ -0,0 +1,57 @@
+import CallExpression from './nodes/CallExpression';
+import CallOptions from './CallOptions';
+import ThisVariable from './variables/ThisVariable';
+import ParameterVariable from './variables/ParameterVariable';
+import { Entity, WritableEntity } from './Entity';
+import Property from './nodes/Property';
+import { ExpressionEntity } from './nodes/shared/Expression';
+import { ObjectPath } from './values';
+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;
+}

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

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

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

@@ -0,0 +1,3 @@
+import Module from '../Module';
+import Import from './nodes/Import';
+export default function enhance(ast: any, module: Module, dynamicImportReturnList: Import[]): void;

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

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

data/vendor/node_modules/rollup/dist/typings/ast/nodes/ArrayExpression.d.ts

@@ -0,0 +1,14 @@
+import SpreadElement from './SpreadElement';
+import { SomeReturnExpressionCallback } from './shared/Expression';
+import { ExpressionNode, NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+import CallOptions from '../CallOptions';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { ObjectPath } from '../values';
+export default class ArrayExpression extends NodeBase {
+    type: NodeType.ArrayExpression;
+    elements: (ExpressionNode | SpreadElement | null)[];
+    hasEffectsWhenAccessedAtPath(path: ObjectPath): 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/nodes/ArrayPattern.d.ts

@@ -0,0 +1,14 @@
+import { ObjectPath } from '../values';
+import Scope from '../scopes/Scope';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { PatternNode } from './shared/Pattern';
+import { ExpressionEntity } from './shared/Expression';
+import { NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+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;
+}

data/vendor/node_modules/rollup/dist/typings/ast/nodes/ArrowFunctionExpression.d.ts

@@ -0,0 +1,25 @@
+import Scope from '../scopes/Scope';
+import ReturnValueScope from '../scopes/ReturnValueScope';
+import BlockStatement from './BlockStatement';
+import CallOptions from '../CallOptions';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './shared/Expression';
+import { PatternNode } from './shared/Pattern';
+import { NodeType } from './NodeType';
+import { ExpressionNode, NodeBase } from './shared/Node';
+import { ObjectPath } from '../values';
+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;
+}