jass 0.9.1

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

@@ -0,0 +1,14 @@
+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;
+    private resolutionInterop;
+    setResolution(resolution: NamespaceVariable | string | void, interop: boolean): void;
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,17 @@
+import { NodeBase } from './shared/Node';
+import Literal from './Literal';
+import ImportSpecifier from './ImportSpecifier';
+import ImportDefaultSpecifier from './ImportDefaultSpecifier';
+import ImportNamespaceSpecifier from './ImportNamespaceSpecifier';
+import MagicString from 'magic-string';
+import { NodeType } from './NodeType';
+import { NodeRenderOptions, RenderOptions } from '../../utils/renderHelpers';
+export default class ImportDeclaration extends NodeBase {
+    type: NodeType.ImportDeclaration;
+    specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[];
+    source: Literal<string>;
+    isImportDeclaration: true;
+    needsBoundaries: true;
+    bindChildren(): void;
+    render(code: MagicString, _options: RenderOptions, {start, end}?: NodeRenderOptions): void;
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import MagicString from 'magic-string';
+import { SomeReturnExpressionCallback } from './shared/Expression';
+import { Node, NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+import CallOptions from '../CallOptions';
+import { ObjectPath } from '../values';
+import { RenderOptions } from '../../utils/renderHelpers';
+export declare type LiteralValueTypes = string | boolean | null | number | RegExp;
+export declare function isLiteral(node: Node): node is Literal;
+export default class Literal<T = LiteralValueTypes> extends NodeBase {
+    type: NodeType.Literal;
+    value: T;
+    private members;
+    getValue(): T;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAssignedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+    initialiseNode(): 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/LogicalExpression.d.ts

@@ -0,0 +1,23 @@
+import { ObjectPath } from '../values';
+import CallOptions from '../CallOptions';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { ForEachReturnExpressionCallback, PredicateFunction, SomeReturnExpressionCallback } from './shared/Expression';
+import { NodeType } from './NodeType';
+import { ExpressionNode, NodeBase } from './shared/Node';
+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;
+    someReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, predicateFunction: SomeReturnExpressionCallback, options: ExecutionPathOptions): boolean;
+    _forEachRelevantBranch(callback: (node: ExpressionNode) => void): void;
+    _someRelevantBranch(predicateFunction: PredicateFunction): boolean;
+}

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

@@ -0,0 +1,34 @@
+import { ExpressionNode, Node, NodeBase } from './shared/Node';
+import Variable from '../variables/Variable';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+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 { ObjectPath, ObjectPathKey } from '../values';
+export declare function isMemberExpression(node: Node): node is MemberExpression;
+export default class MemberExpression extends NodeBase {
+    type: NodeType.MemberExpression;
+    object: ExpressionNode;
+    property: ExpressionNode;
+    computed: boolean;
+    propertyKey: ObjectPathKey;
+    variable: Variable;
+    private isBound;
+    private replacement;
+    private arePropertyReadSideEffectsChecked;
+    bind(): void;
+    private resolveNamespaceVariables(baseVariable, path);
+    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;
+    includeInBundle(): boolean;
+    initialiseNode(): void;
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    private disallowNamespaceReassignment();
+    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/MethodDefinition.d.ts

@@ -0,0 +1,16 @@
+import { ExpressionNode, NodeBase } from './shared/Node';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import FunctionExpression from './FunctionExpression';
+import CallOptions from '../CallOptions';
+import { NodeType } from './NodeType';
+import { ObjectPath } from '../values';
+export default class MethodDefinition extends NodeBase {
+    type: NodeType.MethodDefinition;
+    key: ExpressionNode;
+    value: FunctionExpression;
+    kind: 'constructor' | 'method' | 'get' | 'set';
+    computed: boolean;
+    static: boolean;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    hasEffectsWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,14 @@
+import CallOptions from '../CallOptions';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { ExpressionNode, NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+import { ObjectPath } from '../values';
+export default class NewExpression extends NodeBase {
+    type: NodeType.NewExpression;
+    callee: ExpressionNode;
+    arguments: ExpressionNode[];
+    _callOptions: CallOptions;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    hasEffectsWhenAccessedAtPath(path: ObjectPath, _options: ExecutionPathOptions): boolean;
+    initialiseNode(): void;
+}

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

@@ -0,0 +1,64 @@
+export declare const enum NodeType {
+    ArrayExpression = "ArrayExpression",
+    ArrayPattern = "ArrayPattern",
+    ArrowFunctionExpression = "ArrowFunctionExpression",
+    AssignmentExpression = "AssignmentExpression",
+    AssignmentPattern = "AssignmentPattern",
+    AwaitExpression = "AwaitExpression",
+    BinaryExpression = "BinaryExpression",
+    BlockStatement = "BlockStatement",
+    BreakStatement = "BreakStatement",
+    CallExpression = "CallExpression",
+    CatchClause = "CatchClause",
+    ClassBody = "ClassBody",
+    ClassDeclaration = "ClassDeclaration",
+    ClassExpression = "ClassExpression",
+    ConditionalExpression = "ConditionalExpression",
+    DoWhileStatement = "DoWhileStatement",
+    EmptyStatement = "EmptyStatement",
+    ExportAllDeclaration = "ExportAllDeclaration",
+    ExportDefaultDeclaration = "ExportDefaultDeclaration",
+    ExportNamedDeclaration = "ExportNamedDeclaration",
+    ExportSpecifier = "ExportSpecifier",
+    ExpressionStatement = "ExpressionStatement",
+    ForStatement = "ForStatement",
+    ForInStatement = "ForInStatement",
+    ForOfStatement = "ForOfStatement",
+    FunctionDeclaration = "FunctionDeclaration",
+    FunctionExpression = "FunctionExpression",
+    Identifier = "Identifier",
+    IfStatement = "IfStatement",
+    Import = "Import",
+    ImportDeclaration = "ImportDeclaration",
+    ImportDefaultSpecifier = "ImportDefaultSpecifier",
+    ImportNamespaceSpecifier = "ImportNamespaceSpecifier",
+    ImportSpecifier = "ImportSpecifier",
+    LabeledStatement = "LabeledStatement",
+    Literal = "Literal",
+    LogicalExpression = "LogicalExpression",
+    MemberExpression = "MemberExpression",
+    MethodDefinition = "MethodDefinition",
+    NewExpression = "NewExpression",
+    ObjectExpression = "ObjectExpression",
+    ObjectPattern = "ObjectPattern",
+    Program = "Program",
+    Property = "Property",
+    RestElement = "RestElement",
+    ReturnStatement = "ReturnStatement",
+    SequenceExpression = "SequenceExpression",
+    SpreadElement = "SpreadElement",
+    SwitchCase = "SwitchCase",
+    SwitchStatement = "SwitchStatement",
+    TaggedTemplateExpression = "TaggedTemplateExpression",
+    TemplateElement = "TemplateElement",
+    TemplateLiteral = "TemplateLiteral",
+    ThisExpression = "ThisExpression",
+    ThrowStatement = "ThrowStatement",
+    TryStatement = "TryStatement",
+    UnaryExpression = "UnaryExpression",
+    UpdateExpression = "UpdateExpression",
+    VariableDeclarator = "VariableDeclarator",
+    VariableDeclaration = "VariableDeclaration",
+    WhileStatement = "WhileStatement",
+    YieldExpression = "YieldExpression",
+}

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

@@ -0,0 +1,22 @@
+import Property from './Property';
+import CallOptions from '../CallOptions';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './shared/Expression';
+import { ObjectPath, ObjectPathKey } from '../values';
+import { Node, NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+export declare function isObjectExpression(node: Node): node is ObjectExpression;
+export default class ObjectExpression extends NodeBase {
+    type: NodeType.ObjectExpression;
+    properties: Property[];
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): void;
+    forEachReturnExpressionWhenCalledAtPath(path: ObjectPath, callOptions: CallOptions, callback: ForEachReturnExpressionCallback, options: ExecutionPathOptions): void;
+    _getPossiblePropertiesWithName(name: ObjectPathKey, kinds: ObjectPath): {
+        properties: Property[];
+        hasCertainHit: boolean;
+    };
+    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/nodes/ObjectPattern.d.ts

@@ -0,0 +1,15 @@
+import AssignmentProperty from './AssignmentProperty';
+import Scope from '../scopes/Scope';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { ExpressionEntity } from './shared/Expression';
+import { PatternNode } from './shared/Pattern';
+import { NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+import { ObjectPath } from '../values';
+export default class ObjectPattern extends NodeBase implements PatternNode {
+    type: NodeType.ObjectPattern;
+    properties: AssignmentProperty[];
+    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/Program.d.ts

@@ -0,0 +1,9 @@
+import MagicString from 'magic-string';
+import { NodeBase, StatementNode } from './shared/Node';
+import { NodeType } from './NodeType';
+import { RenderOptions } from '../../utils/renderHelpers';
+export default class Program extends NodeBase {
+    type: NodeType.Program;
+    body: StatementNode[];
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,30 @@
+import { ExpressionNode, Node, NodeBase } from './shared/Node';
+import CallOptions from '../CallOptions';
+import { ObjectPath } from '../values';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Scope from '../scopes/Scope';
+import MagicString from 'magic-string';
+import { ExpressionEntity, ForEachReturnExpressionCallback, SomeReturnExpressionCallback } from './shared/Expression';
+import { NodeType } from './NodeType';
+import { RenderOptions } from '../../utils/renderHelpers';
+export declare function isProperty(node: Node): node is Property;
+export default class Property extends NodeBase {
+    type: NodeType.Property;
+    key: ExpressionNode;
+    value: ExpressionNode;
+    kind: 'init' | 'get' | 'set';
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+    private _accessorCallOptions;
+    reassignPath(path: ObjectPath, options: ExecutionPathOptions): 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;
+    initialiseAndDeclare(parentScope: Scope, kind: string, _init: ExpressionEntity | null): void;
+    initialiseNode(_parentScope: Scope): 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/RestElement.d.ts

@@ -0,0 +1,14 @@
+import { ObjectPath } from '../values';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Scope from '../scopes/Scope';
+import { PatternNode } from './shared/Pattern';
+import { ExpressionEntity } from './shared/Expression';
+import { NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+export default class RestElement extends NodeBase implements PatternNode {
+    type: NodeType.RestElement;
+    argument: PatternNode;
+    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/ReturnStatement.d.ts

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

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

@@ -0,0 +1,13 @@
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import MagicString from 'magic-string';
+import { ExpressionNode, NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+import { RenderOptions } from '../../utils/renderHelpers';
+export default class SequenceExpression extends NodeBase {
+    type: NodeType.SequenceExpression;
+    expressions: ExpressionNode[];
+    getValue(): any;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    includeInBundle(): boolean;
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,6 @@
+import { ExpressionNode } from './shared/Node';
+import { NodeType } from './NodeType';
+export default interface SpreadElement extends ExpressionNode {
+    type: NodeType.SpreadElement;
+    argument: ExpressionNode;
+}

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

@@ -0,0 +1,11 @@
+import { ExpressionNode, NodeBase, StatementNode } from './shared/Node';
+import { NodeType } from './NodeType';
+import { RenderOptions } from '../../utils/renderHelpers';
+import MagicString from 'magic-string';
+export default class SwitchCase extends NodeBase {
+    type: NodeType.SwitchCase;
+    test: ExpressionNode | null;
+    consequent: StatementNode[];
+    includeInBundle(): boolean;
+    render(code: MagicString, options: RenderOptions): void;
+}

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

@@ -0,0 +1,12 @@
+import SwitchCase from './SwitchCase';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import Scope from '../scopes/Scope';
+import { NodeType } from './NodeType';
+import { ExpressionNode, StatementBase } from './shared/Node';
+export default class SwitchStatement extends StatementBase {
+    type: NodeType.SwitchStatement;
+    discriminant: ExpressionNode;
+    cases: SwitchCase[];
+    hasEffects(options: ExecutionPathOptions): boolean;
+    initialiseScope(parentScope: Scope): void;
+}

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

@@ -0,0 +1,13 @@
+import TemplateLiteral from './TemplateLiteral';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeType } from './NodeType';
+import { ExpressionNode, NodeBase } from './shared/Node';
+export default class TaggedTemplateExpression extends NodeBase {
+    type: NodeType.TaggedTemplateExpression;
+    tag: ExpressionNode;
+    quasi: TemplateLiteral;
+    private _callOptions;
+    bindNode(): void;
+    hasEffects(options: ExecutionPathOptions): boolean;
+    initialiseNode(): void;
+}

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

@@ -0,0 +1,12 @@
+import { NodeBase } from './shared/Node';
+import ExecutionPathOptions from '../ExecutionPathOptions';
+import { NodeType } from './NodeType';
+export default class TemplateElement extends NodeBase {
+    type: NodeType.TemplateElement;
+    tail: boolean;
+    value: {
+        cooked: string;
+        raw: string;
+    };
+    hasEffects(_options: ExecutionPathOptions): boolean;
+}

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

@@ -0,0 +1,12 @@
+import TemplateElement from './TemplateElement';
+import MagicString from 'magic-string';
+import { ExpressionNode, Node, NodeBase } from './shared/Node';
+import { NodeType } from './NodeType';
+import { RenderOptions } from '../../utils/renderHelpers';
+export declare function isTemplateLiteral(node: Node): node is TemplateLiteral;
+export default class TemplateLiteral extends NodeBase {
+    type: NodeType.TemplateLiteral;
+    quasis: TemplateElement[];
+    expressions: ExpressionNode[];
+    render(code: MagicString, options: RenderOptions): void;
+}