jass 0.9.1

data/vendor/node_modules/buble/src/program/types/ClassDeclaration.js

@@ -0,0 +1,79 @@
+import Node from '../Node.js';
+import deindent from '../../utils/deindent.js';
+
+export default class ClassDeclaration extends Node {
+	initialise(transforms) {
+		if (this.id) {
+			this.name = this.id.name;
+			this.findScope(true).addDeclaration(this.id, 'class');
+		} else {
+			this.name = this.findScope(true).createIdentifier("defaultExport");
+		}
+
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		if (transforms.classes) {
+			if (!this.superClass) deindent(this.body, code);
+
+			const superName =
+				this.superClass && (this.superClass.name || 'superclass');
+
+			const i0 = this.getIndentation();
+			const i1 = i0 + code.getIndentString();
+
+			// if this is an export default statement, we have to move the export to
+			// after the declaration, because `export default var Foo = ...` is illegal
+			const isExportDefaultDeclaration = this.parent.type === 'ExportDefaultDeclaration';
+
+			if (isExportDefaultDeclaration) {
+				code.remove(this.parent.start, this.start);
+			}
+
+			let c = this.start;
+			if (this.id) {
+				code.overwrite(c, this.id.start, 'var ');
+				c = this.id.end;
+			} else {
+				code.prependLeft(c, `var ${this.name}`);
+			}
+
+			if (this.superClass) {
+				if (this.superClass.end === this.body.start) {
+					code.remove(c, this.superClass.start);
+					code.appendLeft(c, ` = (function (${superName}) {\n${i1}`);
+				} else {
+					code.overwrite(c, this.superClass.start, ' = ');
+					code.overwrite(
+						this.superClass.end,
+						this.body.start,
+						`(function (${superName}) {\n${i1}`
+					);
+				}
+			} else {
+				if (c === this.body.start) {
+					code.appendLeft(c, ' = ');
+				} else {
+					code.overwrite(c, this.body.start, ' = ');
+				}
+			}
+
+			this.body.transpile(code, transforms, !!this.superClass, superName);
+
+			const syntheticDefaultExport =
+				isExportDefaultDeclaration
+					? `\n\n${i0}export default ${this.name};`
+					: '';
+			if (this.superClass) {
+				code.appendLeft(this.end, `\n\n${i1}return ${this.name};\n${i0}}(`);
+				code.move(this.superClass.start, this.superClass.end, this.end);
+				code.prependRight(this.end, `));${syntheticDefaultExport}`);
+			} else if (syntheticDefaultExport) {
+				code.prependRight(this.end, syntheticDefaultExport);
+			}
+		} else {
+			this.body.transpile(code, transforms, false, null);
+		}
+	}
+}

data/vendor/node_modules/buble/src/program/types/ClassExpression.js

@@ -0,0 +1,51 @@
+import Node from '../Node.js';
+
+export default class ClassExpression extends Node {
+	initialise(transforms) {
+		this.name = ( this.id
+			? this.id.name
+			: this.parent.type === 'VariableDeclarator'
+				? this.parent.id.name
+				: this.parent.type !== 'AssignmentExpression'
+					? null
+					: this.parent.left.type === 'Identifier'
+						? this.parent.left.name
+						: this.parent.left.type === 'MemberExpression'
+							? this.parent.left.property.name
+							: null ) || this.findScope(true).createIdentifier('anonymous');
+
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		if (transforms.classes) {
+			const superName =
+				this.superClass && (this.superClass.name || 'superclass');
+
+			const i0 = this.getIndentation();
+			const i1 = i0 + code.getIndentString();
+
+			if (this.superClass) {
+				code.remove(this.start, this.superClass.start);
+				code.remove(this.superClass.end, this.body.start);
+				code.appendLeft(this.start, `(function (${superName}) {\n${i1}`);
+			} else {
+				code.overwrite(this.start, this.body.start, `(function () {\n${i1}`);
+			}
+
+			this.body.transpile(code, transforms, true, superName);
+
+			const outro = `\n\n${i1}return ${this.name};\n${i0}}(`;
+
+			if (this.superClass) {
+				code.appendLeft(this.end, outro);
+				code.move(this.superClass.start, this.superClass.end, this.end);
+				code.prependRight(this.end, '))');
+			} else {
+				code.appendLeft(this.end, `\n\n${i1}return ${this.name};\n${i0}}())`);
+			}
+		} else {
+			this.body.transpile(code, transforms, false);
+		}
+	}
+}

data/vendor/node_modules/buble/src/program/types/ContinueStatement.js

@@ -0,0 +1,17 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+import { loopStatement } from '../../utils/patterns.js';
+
+export default class ContinueStatement extends Node {
+	transpile(code) {
+		const loop = this.findNearest(loopStatement);
+		if (loop.shouldRewriteAsFunction) {
+			if (this.label)
+				throw new CompileError(
+					'Labels are not currently supported in a loop with locally-scoped variables',
+					this
+				);
+			code.overwrite(this.start, this.start + 8, 'return');
+		}
+	}
+}

data/vendor/node_modules/buble/src/program/types/ExportDefaultDeclaration.js

@@ -0,0 +1,10 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+
+export default class ExportDefaultDeclaration extends Node {
+	initialise(transforms) {
+		if (transforms.moduleExport)
+			throw new CompileError('export is not supported', this);
+		super.initialise(transforms);
+	}
+}

data/vendor/node_modules/buble/src/program/types/ExportNamedDeclaration.js

@@ -0,0 +1,10 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+
+export default class ExportNamedDeclaration extends Node {
+	initialise(transforms) {
+		if (transforms.moduleExport)
+			throw new CompileError('export is not supported', this);
+		super.initialise(transforms);
+	}
+}

data/vendor/node_modules/buble/src/program/types/ForInStatement.js

@@ -0,0 +1,76 @@
+import LoopStatement from './shared/LoopStatement.js';
+import destructure from '../../utils/destructure.js';
+import extractNames from '../extractNames.js';
+
+export default class ForInStatement extends LoopStatement {
+	findScope(functionScope) {
+		return functionScope || !this.createdScope
+			? this.parent.findScope(functionScope)
+			: this.body.scope;
+	}
+
+	transpile(code, transforms) {
+		const hasDeclaration = this.left.type === 'VariableDeclaration';
+
+		if (this.shouldRewriteAsFunction) {
+			// which variables are declared in the init statement?
+			const names =
+				hasDeclaration
+					? [].concat.apply(
+							[],
+							this.left.declarations.map(declarator =>
+								extractNames(declarator.id)
+							)
+						)
+					: [];
+
+			this.args = names.map(
+				name => (name in this.aliases ? this.aliases[name].outer : name)
+			);
+			this.params = names.map(
+				name => (name in this.aliases ? this.aliases[name].inner : name)
+			);
+		}
+
+		super.transpile(code, transforms);
+
+		const maybePattern = hasDeclaration ? this.left.declarations[0].id : this.left;
+		if (maybePattern.type !== 'Identifier') {
+			this.destructurePattern(code, maybePattern, hasDeclaration);
+		}
+	}
+
+	destructurePattern(code, pattern, isDeclaration) {
+		const scope = this.findScope(true);
+		const i0 = this.getIndentation();
+		const i1 = i0 + code.getIndentString();
+
+		const ref = scope.createIdentifier('ref');
+
+		const bodyStart = this.body.body.length ? this.body.body[0].start : this.body.start + 1;
+
+		code.move(pattern.start, pattern.end, bodyStart);
+
+		code.prependRight(pattern.end, isDeclaration ? ref : `var ${ref}`);
+
+		let statementGenerators = [];
+		destructure(
+			code,
+			id => scope.createIdentifier(id),
+			({ name }) => scope.resolveName(name),
+			pattern,
+			ref,
+			false,
+			statementGenerators
+		);
+
+		let suffix = `;\n${i1}`;
+		statementGenerators.forEach((fn, i) => {
+			if (i === statementGenerators.length - 1) {
+				suffix = `;\n\n${i1}`;
+			}
+
+			fn(bodyStart, '', suffix);
+		});
+	}
+}

data/vendor/node_modules/buble/src/program/types/ForOfStatement.js

@@ -0,0 +1,89 @@
+import LoopStatement from './shared/LoopStatement.js';
+import CompileError from '../../utils/CompileError.js';
+import destructure from '../../utils/destructure.js';
+
+export default class ForOfStatement extends LoopStatement {
+	initialise(transforms) {
+		if (transforms.forOf && !transforms.dangerousForOf)
+			throw new CompileError(
+				"for...of statements are not supported. Use `transforms: { forOf: false }` to skip transformation and disable this error, or `transforms: { dangerousForOf: true }` if you know what you're doing",
+				this
+			);
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+		if (!transforms.dangerousForOf) return;
+
+		// edge case (#80)
+		if (!this.body.body[0]) {
+			if (
+				this.left.type === 'VariableDeclaration' &&
+				this.left.kind === 'var'
+			) {
+				code.remove(this.start, this.left.start);
+				code.appendLeft(this.left.end, ';');
+				code.remove(this.left.end, this.end);
+			} else {
+				code.remove(this.start, this.end);
+			}
+
+			return;
+		}
+
+		const scope = this.findScope(true);
+		const i0 = this.getIndentation();
+		const i1 = i0 + code.getIndentString();
+
+		const key = scope.createIdentifier('i');
+		const list = scope.createIdentifier('list');
+
+		if (this.body.synthetic) {
+			code.prependRight(this.left.start, `{\n${i1}`);
+			code.appendLeft(this.body.body[0].end, `\n${i0}}`);
+		}
+
+		const bodyStart = this.body.body[0].start;
+
+		code.remove(this.left.end, this.right.start);
+		code.move(this.left.start, this.left.end, bodyStart);
+
+		code.prependRight(this.right.start, `var ${key} = 0, ${list} = `);
+		code.appendLeft(this.right.end, `; ${key} < ${list}.length; ${key} += 1`);
+
+		const isDeclaration = this.left.type === 'VariableDeclaration';
+		const maybeDestructuring = isDeclaration ? this.left.declarations[0].id : this.left;
+		if (maybeDestructuring.type !== 'Identifier') {
+			let statementGenerators = [];
+			const ref = scope.createIdentifier('ref');
+			destructure(
+				code,
+				id => scope.createIdentifier(id),
+				({ name }) => scope.resolveName(name),
+				maybeDestructuring,
+				ref,
+				!isDeclaration,
+				statementGenerators
+			);
+
+			let suffix = `;\n${i1}`;
+			statementGenerators.forEach((fn, i) => {
+				if (i === statementGenerators.length - 1) {
+					suffix = `;\n\n${i1}`;
+				}
+
+				fn(bodyStart, '', suffix);
+			});
+
+			if (isDeclaration) {
+				code.appendLeft(this.left.start + this.left.kind.length + 1, ref);
+				code.appendLeft(this.left.end, ` = ${list}[${key}];\n${i1}`);
+			} else {
+				code.appendLeft(this.left.end, `var ${ref} = ${list}[${key}];\n${i1}`);
+			}
+		} else {
+			code.appendLeft(this.left.end, ` = ${list}[${key}];\n\n${i1}`);
+		}
+	}
+}

data/vendor/node_modules/buble/src/program/types/ForStatement.js

@@ -0,0 +1,54 @@
+import LoopStatement from './shared/LoopStatement.js';
+import extractNames from '../extractNames.js';
+
+export default class ForStatement extends LoopStatement {
+	findScope(functionScope) {
+		return functionScope || !this.createdScope
+			? this.parent.findScope(functionScope)
+			: this.body.scope;
+	}
+
+	transpile(code, transforms) {
+		const i1 = this.getIndentation() + code.getIndentString();
+
+		if (this.shouldRewriteAsFunction) {
+			// which variables are declared in the init statement?
+			const names =
+				this.init.type === 'VariableDeclaration'
+					? [].concat.apply(
+							[],
+							this.init.declarations.map(declarator =>
+								extractNames(declarator.id)
+							)
+						)
+					: [];
+
+			const aliases = this.aliases;
+
+			this.args = names.map(
+				name => (name in this.aliases ? this.aliases[name].outer : name)
+			);
+			this.params = names.map(
+				name => (name in this.aliases ? this.aliases[name].inner : name)
+			);
+
+			const updates = Object.keys(this.reassigned).map(
+				name => `${aliases[name].outer} = ${aliases[name].inner};`
+			);
+
+			if (updates.length) {
+				if (this.body.synthetic) {
+					code.appendLeft(this.body.body[0].end, `; ${updates.join(` `)}`);
+				} else {
+					const lastStatement = this.body.body[this.body.body.length - 1];
+					code.appendLeft(
+						lastStatement.end,
+						`\n\n${i1}${updates.join(`\n${i1}`)}`
+					);
+				}
+			}
+		}
+
+		super.transpile(code, transforms);
+	}
+}

data/vendor/node_modules/buble/src/program/types/FunctionDeclaration.js

@@ -0,0 +1,25 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+import removeTrailingComma from '../../utils/removeTrailingComma.js';
+
+export default class FunctionDeclaration extends Node {
+	initialise(transforms) {
+		if (this.generator && transforms.generator) {
+			throw new CompileError('Generators are not supported', this);
+		}
+
+		this.body.createScope();
+
+		if (this.id) {
+			this.findScope(true).addDeclaration(this.id, 'function');
+		}
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+		if (transforms.trailingFunctionCommas && this.params.length) {
+			removeTrailingComma(code, this.params[this.params.length - 1].end);
+		}
+	}
+}

data/vendor/node_modules/buble/src/program/types/FunctionExpression.js

@@ -0,0 +1,74 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+import removeTrailingComma from '../../utils/removeTrailingComma.js';
+
+export default class FunctionExpression extends Node {
+	initialise(transforms) {
+		if (this.generator && transforms.generator) {
+			throw new CompileError('Generators are not supported', this);
+		}
+
+		this.body.createScope();
+
+		if (this.id) {
+			// function expression IDs belong to the child scope...
+			this.body.scope.addDeclaration(this.id, 'function');
+		}
+
+		super.initialise(transforms);
+
+		const parent = this.parent;
+		let methodName;
+
+		if (
+			transforms.conciseMethodProperty &&
+			parent.type === 'Property' &&
+			parent.kind === 'init' &&
+			parent.method &&
+			parent.key.type === 'Identifier'
+		) {
+			// object literal concise method
+			methodName = parent.key.name;
+		} else if (
+			transforms.classes &&
+			parent.type === 'MethodDefinition' &&
+			parent.kind === 'method' &&
+			parent.key.type === 'Identifier'
+		) {
+			// method definition in a class
+			methodName = parent.key.name;
+		} else if (this.id && this.id.type === 'Identifier') {
+			// naked function expression
+			methodName = this.id.alias || this.id.name;
+		}
+
+		if (methodName) {
+			for (const param of this.params) {
+				if (param.type === 'Identifier' && methodName === param.name) {
+					// workaround for Safari 9/WebKit bug:
+					// https://gitlab.com/Rich-Harris/buble/issues/154
+					// change parameter name when same as method name
+
+					const scope = this.body.scope;
+					const declaration = scope.declarations[methodName];
+
+					const alias = scope.createIdentifier(methodName);
+					param.alias = alias;
+
+					for (const identifier of declaration.instances) {
+						identifier.alias = alias;
+					}
+
+					break;
+				}
+			}
+		}
+	}
+
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+		if (transforms.trailingFunctionCommas && this.params.length) {
+			removeTrailingComma(code, this.params[this.params.length - 1].end);
+		}
+	}
+}