jass 0.9.1

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

@@ -0,0 +1,13 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { PatternNode } from './shared/Pattern';
+import { ExpressionNode, NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+import { ObjectPath } from '../values';
+export default class AssignmentExpression extends NodeBase {
+    type: NodeType.AssignmentExpression;
+    left: PatternNode | ExpressionNode;
+    right: ExpressionNode;
+    bindNode(): void;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,16 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Scope from '../scopes/Scope';
+import { PatternNode } from './shared/Pattern';
+import { ExpressionEntity } from './shared/Expression';
+import { ExpressionNode, NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+import { ObjectPath } from '../values';
+export default class AssignmentPattern extends NodeBase implements PatternNode {
+    type: NodeType.AssignmentPattern;
+    left: PatternNode;
+    right: ExpressionNode;
+    bindNode(): void;
+    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/AssignmentProperty.d.ts

@@ -0,0 +1,10 @@
+import { PatternNode } from './shared/Pattern';
+import { ExpressionNode } from './shared/Node';
+import { NodeType } from './NodeType';
+export default interface AssignmentProperty extends PatternNode {
+    type: NodeType.Property;
+    value: PatternNode;
+    key: ExpressionNode;
+    kind: 'init';
+    method: false;
+}

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

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

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

@@ -0,0 +1,13 @@
+import { ObjectPath } from '../values';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeType } from './NodeType';
+import { ExpressionNode, NodeBase } from './shared/Node';
+export declare type BinaryOperator = '==' | '!=' | '===' | '!==' | '<' | '<=' | '>' | '>=' | '<<' | '>>' | '>>>' | '+' | '-' | '*' | '/' | '%' | ' |' | '^' | '&' | '**' | 'in' | 'instanceof';
+export default class BinaryExpression extends NodeBase {
+    type: NodeType.BinaryExpression;
+    left: ExpressionNode;
+    right: ExpressionNode;
+    operator: BinaryOperator;
+    getValue(): any;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,19 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Scope from '../scopes/Scope';
+import MagicString from 'magic-string';
+import { Node, StatementBase, StatementNode } from './shared/Node';
+import { NodeType } from './NodeType';
+import { RenderOptions } from '../../utils/renderHelpers';
+export declare function isBlockStatement(node: Node): node is BlockStatement;
+export default class BlockStatement extends StatementBase {
+    type: NodeType.BlockStatement;
+    scope: Scope;
+    body: StatementNode[];
+    bindImplicitReturnExpressionToScope(): void;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    includeInBundle(): boolean;
+    initialiseAndReplaceScope(scope: Scope): void;
+    initialiseChildren(_parentScope: Scope): void;
+    initialiseScope(parentScope: Scope): void;
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,9 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Identifier from './Identifier';
+import { NodeType } from './NodeType';
+import { StatementBase } from './shared/Node';
+export default class BreakStatement extends StatementBase {
+    type: NodeType.BreakStatement;
+    label: Identifier | null;
+    hasEffects(options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,22 @@
+import CallOptions from '../CallOptions';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import SpreadElement from './SpreadElement';
+import { ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './shared/Expression';
+import { NodeType } from './NodeType';
+import { ExpressionNode, NodeBase } from './shared/Node';
+import { ObjectPath } from '../values';
+export default class CallExpression extends NodeBase {
+    type: NodeType.CallExpression;
+    callee: ExpressionNode;
+    arguments: (ExpressionNode | SpreadElement)[];
+    private _callOptions;
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    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;
+    initialiseNode(): void;
+    someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,14 @@
+import { NodeBase } from './shared/Node';
+import CatchScope from '../scopes/CatchScope';
+import BlockStatement from './BlockStatement';
+import Scope from '../scopes/Scope';
+import { PatternNode } from './shared/Pattern';
+import { NodeType } from './NodeType';
+export default class CatchClause extends NodeBase {
+    type: NodeType.CatchClause;
+    param: PatternNode;
+    body: BlockStatement;
+    scope: CatchScope;
+    initialiseChildren(): void;
+    initialiseScope(parentScope: Scope): void;
+}

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

@@ -0,0 +1,13 @@
+import { NodeBase } from './shared/Node';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import CallOptions from '../CallOptions';
+import MethodDefinition from './MethodDefinition';
+import { NodeType } from './NodeType';
+import { ObjectPath } from '../values';
+export default class ClassBody extends NodeBase {
+    type: NodeType.ClassBody;
+    body: MethodDefinition[];
+    classConstructor: MethodDefinition | null;
+    hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+    initialiseNode(): void;
+}

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

@@ -0,0 +1,14 @@
+import ClassNode from './shared/ClassNode';
+import Scope from '../scopes/Scope';
+import Identifier from './Identifier';
+import MagicString from 'magic-string';
+import { NodeType } from './NodeType';
+import { Node } from './shared/Node';
+import { RenderOptions } from '../../utils/renderHelpers';
+export declare function isClassDeclaration(node: Node): node is ClassDeclaration;
+export default class ClassDeclaration extends ClassNode {
+    type: NodeType.ClassDeclaration;
+    id: Identifier;
+    initialiseChildren(parentScope: Scope): void;
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,10 @@
+import ClassNode from './shared/ClassNode';
+import Scope from '../scopes/Scope';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeType } from './NodeType';
+import { ObjectPath } from '../values';
+export default class ClassExpression extends ClassNode {
+    type: NodeType.ClassExpression;
+    initialiseChildren(parentScope: Scope): void;
+    reassignPath(_path: ObjectPath, _options: ExecutionPathOptions): void;
+}

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

@@ -0,0 +1,28 @@
+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';
+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;
+    someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+    private forEachRelevantBranch(callback);
+    private someRelevantBranch(predicateFunction);
+}

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

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

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

@@ -0,0 +1,8 @@
+import MagicString from 'magic-string';
+import { NodeType } from './NodeType';
+import { StatementBase } from './shared/Node';
+import { RenderOptions } from '../../utils/renderHelpers';
+export default class EmptyStatement extends StatementBase {
+    type: NodeType.EmptyStatement;
+    render(code: MagicString, _options: RenderOptions): void;
+}

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

@@ -0,0 +1,12 @@
+import { NodeBase } from './shared/Node';
+import Literal from './Literal';
+import MagicString from 'magic-string';
+import { NodeType } from './NodeType';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
+export default class ExportAllDeclaration extends NodeBase {
+    type: NodeType.ExportAllDeclaration;
+    source: Literal<string>;
+    isExportDeclaration: true;
+    needsBoundaries: true;
+    render(code: MagicString, _options: RenderOptions, {start, end}?: NodeRenderOptions): void;
+}

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

@@ -0,0 +1,21 @@
+import { ExpressionNode, NodeBase } from './shared/Node';
+import ExportDefaultVariable from '../variables/ExportDefaultVariable';
+import ClassDeclaration from './ClassDeclaration';
+import FunctionDeclaration from './FunctionDeclaration';
+import MagicString from 'magic-string';
+import { NodeType } from './NodeType';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
+export default class ExportDefaultDeclaration extends NodeBase {
+    type: NodeType.ExportDefaultDeclaration;
+    declaration: FunctionDeclaration | ClassDeclaration | ExpressionNode;
+    needsBoundaries: true;
+    isExportDeclaration: true;
+    variable: ExportDefaultVariable;
+    private declarationName;
+    bindNode(): void;
+    initialiseNode(): void;
+    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);
+}

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

@@ -0,0 +1,21 @@
+import { NodeBase } from './shared/Node';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Literal from './Literal';
+import MagicString from 'magic-string';
+import ExportSpecifier from './ExportSpecifier';
+import FunctionDeclaration from './FunctionDeclaration';
+import ClassDeclaration from './ClassDeclaration';
+import VariableDeclaration from './VariableDeclaration';
+import { NodeType } from './NodeType';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
+export default class ExportNamedDeclaration extends NodeBase {
+    type: NodeType.ExportNamedDeclaration;
+    declaration: FunctionDeclaration | ClassDeclaration | VariableDeclaration | null;
+    specifiers: ExportSpecifier[];
+    source: Literal<string> | null;
+    needsBoundaries: true;
+    isExportDeclaration: true;
+    bindChildren(): void;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    render(code: MagicString, options: RenderOptions, {start, end}?: NodeRenderOptions): void;
+}

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

@@ -0,0 +1,8 @@
+import { Node } from './shared/Node';
+import Identifier from './Identifier';
+import { NodeType } from './NodeType';
+export default interface ExportSpecifier extends Node {
+    type: NodeType.ExportSpecifier;
+    local: Identifier;
+    exported: Identifier;
+}

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

@@ -0,0 +1,10 @@
+import MagicString from 'magic-string';
+import Scope from '../scopes/Scope';
+import { StatementBase } from './shared/Node';
+import { RenderOptions } from '../../utils/renderHelpers';
+export default class ExpressionStatement extends StatementBase {
+    directive?: string;
+    initialiseNode(_parentScope: Scope): void;
+    shouldBeIncluded(): boolean;
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,20 @@
+import VariableDeclaration from './VariableDeclaration';
+import Scope from '../scopes/Scope';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { PatternNode } from './shared/Pattern';
+import { NodeType } from './NodeType';
+import { ExpressionNode, Node, StatementBase, StatementNode } from './shared/Node';
+import MagicString from 'magic-string';
+import { RenderOptions } from '../../utils/renderHelpers';
+export declare function isForInStatement(node: Node): node is ForInStatement;
+export default class ForInStatement extends StatementBase {
+    type: NodeType.ForInStatement;
+    left: VariableDeclaration | PatternNode;
+    right: ExpressionNode;
+    body: StatementNode;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    initialiseChildren(): void;
+    includeInBundle(): boolean;
+    initialiseScope(parentScope: Scope): void;
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,21 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import VariableDeclaration from './VariableDeclaration';
+import Scope from '../scopes/Scope';
+import { PatternNode } from './shared/Pattern';
+import { NodeType } from './NodeType';
+import { ExpressionNode, Node, StatementBase, StatementNode } from './shared/Node';
+import MagicString from 'magic-string';
+import { RenderOptions } from '../../utils/renderHelpers';
+export declare function isForOfStatement(node: Node): node is ForOfStatement;
+export default class ForOfStatement extends StatementBase {
+    type: NodeType.ForOfStatement;
+    left: VariableDeclaration | PatternNode;
+    right: ExpressionNode;
+    body: StatementNode;
+    bindNode(): void;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    includeInBundle(): boolean;
+    initialiseChildren(): void;
+    initialiseScope(parentScope: Scope): void;
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,19 @@
+import VariableDeclaration from './VariableDeclaration';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Scope from '../scopes/Scope';
+import { NodeType } from './NodeType';
+import { ExpressionNode, Node, StatementBase, StatementNode } from './shared/Node';
+import MagicString from 'magic-string';
+import { RenderOptions } from '../../utils/renderHelpers';
+export declare function isForStatement(node: Node): node is ForStatement;
+export default class ForStatement extends StatementBase {
+    type: NodeType.ForStatement;
+    init: VariableDeclaration | ExpressionNode | null;
+    test: ExpressionNode | null;
+    update: ExpressionNode | null;
+    body: StatementNode;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    initialiseChildren(): void;
+    initialiseScope(parentScope: Scope): void;
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,9 @@
+import FunctionNode from './shared/FunctionNode';
+import Scope from '../scopes/Scope';
+import { NodeType } from './NodeType';
+import { Node } from './shared/Node';
+export declare function isFunctionDeclaration(node: Node): node is FunctionDeclaration;
+export default class FunctionDeclaration extends FunctionNode {
+    type: NodeType.FunctionDeclaration;
+    initialiseChildren(parentScope: Scope): void;
+}

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

@@ -0,0 +1,6 @@
+import FunctionNode from './shared/FunctionNode';
+import { NodeType } from './NodeType';
+export default class FunctionExpression extends FunctionNode {
+    type: NodeType.FunctionExpression;
+    initialiseChildren(): void;
+}

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

@@ -0,0 +1,29 @@
+import { Node, NodeBase } from './shared/Node';
+import { ObjectPath } from '../values';
+import Scope from '../scopes/Scope';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Variable from '../variables/Variable';
+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';
+export declare function isIdentifier(node: Node): node is Identifier;
+export default class Identifier extends NodeBase {
+    type: NodeType.Identifier;
+    name: string;
+    variable: Variable;
+    private isBound;
+    bindNode(): 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;
+    includeInBundle(): boolean;
+    initialiseAndDeclare(parentScope: Scope, kind: string, init: ExpressionEntity | null): void;
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    private disallowImportReassignment();
+    renderSystemBindingUpdate(code: MagicString, name: string): void;
+    render(code: MagicString, options: RenderOptions): void;
+    someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,17 @@
+import Scope from '../scopes/Scope';
+import { ExpressionNode, StatementBase, StatementNode } from './shared/Node';
+import MagicString from 'magic-string';
+import { NodeType } from './NodeType';
+import { RenderOptions } from '../../utils/renderHelpers';
+export default class IfStatement extends StatementBase {
+    type: NodeType.IfStatement;
+    test: ExpressionNode;
+    consequent: StatementNode;
+    alternate: StatementNode | null;
+    private testValue;
+    private hoistedVars?;
+    initialiseChildren(parentScope: Scope): void;
+    initialiseNode(): void;
+    render(code: MagicString, options: RenderOptions): void;
+    shouldBeIncluded(): boolean;
+}