jass 0.9.1

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

@@ -0,0 +1,17 @@
+import ThisVariable from '../variables/ThisVariable';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import MagicString from 'magic-string';
+import { NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+import { RenderOptions } from '../../utils/renderHelpers';
+import { ObjectPath } from '../values';
+export default class ThisExpression extends NodeBase {
+    type: NodeType.ThisExpression;
+    variable: ThisVariable;
+    alias: string;
+    initialiseNode(): void;
+    bindNode(): void;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAssignedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+    render(code: MagicString, _options: RenderOptions): void;
+}

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

@@ -0,0 +1,8 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeType } from './NodeType';
+import { ExpressionNode, StatementBase } from './shared/Node';
+export default class ThrowStatement extends StatementBase {
+    type: NodeType.ThrowStatement;
+    argument: ExpressionNode;
+    hasEffects(_options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,16 @@
+import { ObjectPath } from '../values';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeType } from './NodeType';
+import { ExpressionNode, NodeBase } from './shared/Node';
+export default class UnaryExpression extends NodeBase {
+    type: NodeType.UnaryExpression;
+    operator: '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';
+    prefix: boolean;
+    argument: ExpressionNode;
+    value: any;
+    bindNode(): void;
+    getValue(): any;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    initialiseNode(): void;
+}

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

@@ -0,0 +1,5 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeBase } from './shared/Node';
+export default class UnknownNode extends NodeBase {
+    hasEffects(_options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,13 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeType } from './NodeType';
+import { ExpressionNode, NodeBase } from './shared/Node';
+import { ObjectPath } from '../values';
+export default class UpdateExpression extends NodeBase {
+    type: NodeType.UpdateExpression;
+    operator: '++' | '--' | '**';
+    argument: ExpressionNode;
+    prefix: boolean;
+    bindNode(): void;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,21 @@
+import { Node, NodeBase } from './shared/Node';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import VariableDeclarator from './VariableDeclarator';
+import MagicString from 'magic-string';
+import { NodeType } from './NodeType';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
+import { ObjectPath } from '../values';
+export declare function isVariableDeclaration(node: Node): node is VariableDeclaration;
+export default class VariableDeclaration extends NodeBase {
+    type: NodeType.VariableDeclaration;
+    declarations: VariableDeclarator[];
+    kind: 'var' | 'let' | 'const';
+    reassignPath(_path: ObjectPath, _options: ExecutionPathOptions): void;
+    hasEffectsWhenAssignedAtPath(_path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    includeWithAllDeclaredVariables(): boolean;
+    includeInBundle(): boolean;
+    initialiseChildren(): void;
+    render(code: MagicString, options: RenderOptions, nodeRenderOptions?: NodeRenderOptions): void;
+    private renderReplacedDeclarations(code, options, {start, end, isNoStatement});
+    private renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, addSemicolon);
+}

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

@@ -0,0 +1,13 @@
+import { ExpressionNode, NodeBase } from './shared/Node';
+import Scope from '../scopes/Scope';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { PatternNode } from './shared/Pattern';
+import { NodeType } from './NodeType';
+import { ObjectPath } from '../values';
+export default class VariableDeclarator extends NodeBase {
+    type: NodeType.VariableDeclarator;
+    id: PatternNode;
+    init: ExpressionNode | null;
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    initialiseDeclarator(parentScope: Scope, kind: string): void;
+}

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

@@ -0,0 +1,9 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeType } from './NodeType';
+import { ExpressionNode, StatementBase, StatementNode } from './shared/Node';
+export default class WhileStatement extends StatementBase {
+    type: NodeType.WhileStatement;
+    test: ExpressionNode;
+    body: StatementNode;
+    hasEffects(options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,9 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeType } from './NodeType';
+import { ExpressionNode, NodeBase } from './shared/Node';
+export default class YieldExpression extends NodeBase {
+    type: NodeType.YieldExpression;
+    argument: ExpressionNode | null;
+    delegate: boolean;
+    hasEffects(options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,6 @@
+import { NodeBase } from './shared/Node';
+declare const nodes: {
+    [name: string]: typeof NodeBase;
+};
+export { NodeType } from './NodeType';
+export default nodes;

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

@@ -0,0 +1,17 @@
+import Scope from '../../scopes/Scope';
+import CallOptions from '../../CallOptions';
+import ExecutionPathOptions from '../../ExecutionPathOptions';
+import Identifier from '../Identifier';
+import ClassBody from '../ClassBody';
+import { ExpressionNode, NodeBase } from './Node';
+import { ObjectPath } from '../../values';
+export default class ClassNode extends NodeBase {
+    body: ClassBody;
+    superClass: ExpressionNode | null;
+    id: Identifier | null;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAssignedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+    initialiseChildren(_parentScope: Scope): void;
+    initialiseScope(parentScope: Scope): void;
+}

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

@@ -0,0 +1,21 @@
+import { WritableEntity } from '../../Entity';
+import CallOptions from '../../CallOptions';
+import ExecutionPathOptions from '../../ExecutionPathOptions';
+import { ObjectPath } from '../../values';
+export declare type PredicateFunction = (node: ExpressionEntity) => boolean;
+export declare type SomeReturnExpressionCallback = (options: ExecutionPathOptions) => PredicateFunction;
+export declare type ForEachReturnExpressionCallback = (options: ExecutionPathOptions) => (node: ExpressionEntity) => void;
+export interface ExpressionEntity extends WritableEntity {
+    /**
+     * Executes the callback on each possible return expression when calling this node.
+     */
+    forEachReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, callback: ForEachReturnExpressionCallback, options: ExecutionPathOptions): void;
+    getValue(): any;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+    hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+    /**
+     * Should return true if some possible return expression when called at the given
+     * path returns true.
+     */
+    someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,25 @@
+import FunctionScope from '../../scopes/FunctionScope';
+import BlockScope from '../../scopes/FunctionScope';
+import BlockStatement from '../BlockStatement';
+import Identifier from '../Identifier';
+import CallOptions from '../../CallOptions';
+import ExecutionPathOptions from '../../ExecutionPathOptions';
+import { PatternNode } from './Pattern';
+import { ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './Expression';
+import { NodeBase } from './Node';
+import { ObjectPath } from '../../values';
+export default class FunctionNode extends NodeBase {
+    id: Identifier;
+    body: BlockStatement;
+    scope: BlockScope;
+    params: PatternNode[];
+    bindNode(): void;
+    forEachReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, callback: ForEachReturnExpressionCallback, options: ExecutionPathOptions): void;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath): boolean;
+    hasEffectsWhenAssignedAtPath(path: ObjectPath): boolean;
+    hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+    includeInBundle(): boolean;
+    initialiseScope(parentScope: FunctionScope): void;
+    someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,133 @@
+import ExecutionPathOptions from '../../ExecutionPathOptions';
+import Scope from '../../scopes/Scope';
+import Module from '../../../Module';
+import MagicString from 'magic-string';
+import Variable from '../../variables/Variable';
+import { ExpressionEntity, ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './Expression';
+import CallOptions from '../../CallOptions';
+import { ObjectPath } from '../../values';
+import { Entity } from '../../Entity';
+import { NodeRenderOptions, RenderOptions } from '../../../utils/renderHelpers';
+export interface Node extends Entity {
+    end: number;
+    included: boolean;
+    keys: string[];
+    module: Module;
+    needsBoundaries?: boolean;
+    parent: Node | {
+        type?: string;
+    };
+    start: number;
+    type: string;
+    variable?: Variable;
+    __enhanced: boolean;
+    /**
+     * 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;
+    eachChild(callback: (node: Node) => void): void;
+    /**
+     * 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.
+     */
+    hasEffects(options: ExecutionPathOptions): 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.
+     */
+    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.
+     */
+    includeWithAllDeclaredVariables(): 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.
+     */
+    initialise(parentScope: Scope): void;
+    initialiseAndDeclare(parentScope: Scope, kind: string, init: ExpressionEntity | null): void;
+    render(code: MagicString, options: RenderOptions, nodeRenderOptions?: NodeRenderOptions): 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.
+     */
+    shouldBeIncluded(): boolean;
+    someChild(callback: (node: Node) => boolean): boolean;
+}
+export interface StatementNode extends Node {
+}
+export interface ExpressionNode extends ExpressionEntity, Node {
+}
+export declare class NodeBase implements ExpressionNode {
+    type: string;
+    keys: string[];
+    included: boolean;
+    scope: Scope;
+    start: number;
+    end: number;
+    module: Module;
+    parent: Node | {
+        type?: string;
+    };
+    __enhanced: boolean;
+    constructor();
+    bind(): 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;
+    forEachReturnExpressionWhenCalledAtPath(_path: ObjectPath, _callOptions: CallOptions, _callback: ForEachReturnExpressionCallback, _options: ExecutionPathOptions): void;
+    getValue(): {
+        toString: () => string;
+    };
+    hasEffects(options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAssignedAtPath(_path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    hasEffectsWhenCalledAtPath(_path: ObjectPath, _callOptions: CallOptions, _options: ExecutionPathOptions): boolean;
+    private hasIncludedChild();
+    includeInBundle(): boolean;
+    includeWithAllDeclaredVariables(): boolean;
+    initialise(parentScope: Scope): void;
+    initialiseAndDeclare(_parentScope: Scope, _kind: string, _init: ExpressionEntity | null): void;
+    /**
+     * Override to change how and with what scopes children are initialised
+     */
+    initialiseChildren(_parentScope: Scope): void;
+    /**
+     * Override to perform special initialisation steps after the scope is initialised
+     */
+    initialiseNode(_parentScope: Scope): void;
+    /**
+     * Override if this scope should receive a different scope than the parent scope.
+     */
+    initialiseScope(parentScope: Scope): void;
+    insertSemicolon(code: MagicString): void;
+    locate(): any;
+    reassignPath(_path: ObjectPath, _options: ExecutionPathOptions): void;
+    render(code: MagicString, options: RenderOptions): void;
+    shouldBeIncluded(): boolean;
+    someChild(callback: (node: NodeBase) => boolean): boolean;
+    someReturnExpressionWhenCalledAtPath(_path: ObjectPath, _callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+    toString(): string;
+}
+export { NodeBase as StatementBase };

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

@@ -0,0 +1,4 @@
+import { WritableEntity } from '../../Entity';
+import { Node } from './Node';
+export interface PatternNode extends WritableEntity, Node {
+}

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

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

data/vendor/node_modules/rollup/dist/typings/ast/scopes/BlockScope.d.ts

@@ -0,0 +1,9 @@
+import Scope from './Scope';
+import Identifier from '../nodes/Identifier';
+import LocalVariable from '../variables/LocalVariable';
+export default class BlockScope extends Scope {
+    parent: Scope;
+    addDeclaration(identifier: Identifier, options?: {
+        isHoisted: boolean;
+    }): LocalVariable;
+}

data/vendor/node_modules/rollup/dist/typings/ast/scopes/CatchScope.d.ts

@@ -0,0 +1,10 @@
+import ParameterScope from './ParameterScope';
+import Identifier from '../nodes/Identifier';
+import Scope from './Scope';
+import LocalVariable from '../variables/LocalVariable';
+export default class CatchScope extends ParameterScope {
+    parent: Scope;
+    addDeclaration(identifier: Identifier, options?: {
+        isHoisted: boolean;
+    }): LocalVariable;
+}

data/vendor/node_modules/rollup/dist/typings/ast/scopes/FunctionScope.d.ts

@@ -0,0 +1,20 @@
+import ReturnValueScope from './ReturnValueScope';
+import ArgumentsVariable from '../variables/ArgumentsVariable';
+import ThisVariable from '../variables/ThisVariable';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import CallOptions from '../CallOptions';
+import ExportDefaultVariable from '../variables/ExportDefaultVariable';
+import LocalVariable from '../variables/LocalVariable';
+import GlobalVariable from '../variables/GlobalVariable';
+import ExternalVariable from '../variables/ExternalVariable';
+export default class FunctionScope extends ReturnValueScope {
+    variables: {
+        this: ThisVariable;
+        default: ExportDefaultVariable;
+        arguments: ArgumentsVariable;
+        [name: string]: LocalVariable | GlobalVariable | ExternalVariable | ArgumentsVariable;
+    };
+    constructor(options?: {});
+    findLexicalBoundary(): this;
+    getOptionsWhenCalledWith({args, withNew}: CallOptions, options: ExecutionPathOptions): ExecutionPathOptions;
+}

data/vendor/node_modules/rollup/dist/typings/ast/scopes/GlobalScope.d.ts

@@ -0,0 +1,7 @@
+import GlobalVariable from '../variables/GlobalVariable';
+import Scope from './Scope';
+export default class GlobalScope extends Scope {
+    parent: void;
+    findVariable(name: string): GlobalVariable;
+    deshadow(names: Set<string>, children?: Scope[]): void;
+}

data/vendor/node_modules/rollup/dist/typings/ast/scopes/ModuleScope.d.ts

@@ -0,0 +1,11 @@
+import Scope from './Scope';
+import Module from '../../Module';
+import Variable from '../variables/Variable';
+export default class ModuleScope extends Scope {
+    parent: Scope;
+    module: Module;
+    constructor(module: Module);
+    deshadow(names: Set<string>, children?: Scope[]): void;
+    findLexicalBoundary(): this;
+    findVariable(name: string): Variable;
+}

data/vendor/node_modules/rollup/dist/typings/ast/scopes/ParameterScope.d.ts

@@ -0,0 +1,16 @@
+import Scope from './Scope';
+import ParameterVariable from '../variables/ParameterVariable';
+import Identifier from '../nodes/Identifier';
+export default class ParameterScope extends Scope {
+    parent: Scope;
+    _parameters: ParameterVariable[];
+    constructor(options?: {});
+    /**
+     * Adds a parameter to this scope. Parameters must be added in the correct
+     * order, e.g. from left to right.
+     * @param {Identifier} identifier
+     * @returns {Variable}
+     */
+    addParameterDeclaration(identifier: Identifier): ParameterVariable;
+    getParameterVariables(): ParameterVariable[];
+}

data/vendor/node_modules/rollup/dist/typings/ast/scopes/ReturnValueScope.d.ts

@@ -0,0 +1,11 @@
+import ParameterScope from './ParameterScope';
+import CallOptions from '../CallOptions';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { ExpressionEntity, ForEachReturnExpressionCallback } from '../nodes/shared/Expression';
+export default class ReturnValueScope extends ParameterScope {
+    _returnExpressions: Set<ExpressionEntity>;
+    constructor(options?: {});
+    addReturnExpression(expression: ExpressionEntity): void;
+    forEachReturnExpressionWhenCalled(_callOptions: CallOptions, callback: ForEachReturnExpressionCallback, options: ExecutionPathOptions): void;
+    someReturnExpressionWhenCalled(_callOptions: CallOptions, predicateFunction: (options: ExecutionPathOptions) => (node: ExpressionEntity) => boolean, options: ExecutionPathOptions): boolean;
+}

data/vendor/node_modules/rollup/dist/typings/ast/scopes/Scope.d.ts

@@ -0,0 +1,42 @@
+import LocalVariable from '../variables/LocalVariable';
+import ExportDefaultVariable from '../variables/ExportDefaultVariable';
+import Identifier from '../nodes/Identifier';
+import ExportDefaultDeclaration from '../nodes/ExportDefaultDeclaration';
+import GlobalVariable from '../variables/GlobalVariable';
+import ThisVariable from '../variables/ThisVariable';
+import ArgumentsVariable from '../variables/ArgumentsVariable';
+import Variable from '../variables/Variable';
+import { ExpressionEntity } from '../nodes/shared/Expression';
+import ExternalVariable from '../variables/ExternalVariable';
+export default class Scope {
+    parent: Scope | void;
+    variables: {
+        this: ThisVariable | LocalVariable;
+        default: ExportDefaultVariable;
+        arguments: ArgumentsVariable;
+        [name: string]: LocalVariable | GlobalVariable | ExternalVariable | ArgumentsVariable;
+    };
+    isModuleScope: boolean;
+    children: Scope[];
+    constructor(options?: {
+        parent?: Scope;
+        isModuleScope?: boolean;
+    });
+    /**
+     * @param identifier
+     * @param {Object} [options] - valid options are
+     *        {(Node|null)} init
+     *        {boolean} isHoisted
+     * @return {Variable}
+     */
+    addDeclaration(identifier: Identifier, options?: {
+        init?: ExpressionEntity | null;
+        isHoisted?: boolean;
+    }): LocalVariable | GlobalVariable | ExternalVariable | ArgumentsVariable;
+    addExportDefaultDeclaration(name: string, exportDefaultDeclaration: ExportDefaultDeclaration): ExportDefaultVariable;
+    addReturnExpression(expression: ExpressionEntity): void;
+    contains(name: string): boolean;
+    deshadow(names: Set<string>, children?: Scope[]): void;
+    findLexicalBoundary(): Scope;
+    findVariable(name: string): Variable;
+}