jass 0.9.1

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

@@ -0,0 +1,7 @@
+import Node from '../Node.js';
+
+export default class TemplateElement extends Node {
+	initialise() {
+		this.program.indentExclusionElements.push(this);
+	}
+}

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

@@ -0,0 +1,80 @@
+import Node from '../Node.js';
+
+export default class TemplateLiteral extends Node {
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+
+		if (
+			transforms.templateString &&
+			this.parent.type !== 'TaggedTemplateExpression'
+		) {
+			let ordered = this.expressions
+				.concat(this.quasis)
+				.sort((a, b) => a.start - b.start || a.end - b.end)
+				.filter((node, i) => {
+					// include all expressions
+					if (node.type !== 'TemplateElement') return true;
+
+					// include all non-empty strings
+					if (node.value.raw) return true;
+
+					// exclude all empty strings not at the head
+					return !i;
+				});
+
+			// special case – we may be able to skip the first element,
+			// if it's the empty string, but only if the second and
+			// third elements aren't both expressions (since they maybe
+			// be numeric, and `1 + 2 + '3' === '33'`)
+			if (ordered.length >= 3) {
+				const [first, , third] = ordered;
+				if (
+					first.type === 'TemplateElement' &&
+					first.value.raw === '' &&
+					third.type === 'TemplateElement'
+				) {
+					ordered.shift();
+				}
+			}
+
+			const parenthesise =
+				(this.quasis.length !== 1 || this.expressions.length !== 0) &&
+				this.parent.type !== 'TemplateLiteral' &&
+				this.parent.type !== 'AssignmentExpression' &&
+				this.parent.type !== 'AssignmentPattern' &&
+				this.parent.type !== 'VariableDeclarator' &&
+				(this.parent.type !== 'BinaryExpression' ||
+					this.parent.operator !== '+');
+
+			if (parenthesise) code.appendRight(this.start, '(');
+
+			let lastIndex = this.start;
+
+			ordered.forEach((node, i) => {
+				let prefix = i === 0 ? (parenthesise ? '(' : '') : ' + ';
+
+				if (node.type === 'TemplateElement') {
+					code.overwrite(
+						lastIndex,
+						node.end,
+						prefix + JSON.stringify(node.value.cooked)
+					);
+				} else {
+					const parenthesise = node.type !== 'Identifier'; // TODO other cases where it's safe
+
+					if (parenthesise) prefix += '(';
+
+					code.remove(lastIndex, node.start);
+
+					if (prefix) code.prependRight(node.start, prefix);
+					if (parenthesise) code.appendLeft(node.end, ')');
+				}
+
+				lastIndex = node.end;
+			});
+
+			if (parenthesise) code.appendLeft(lastIndex, ')');
+			code.overwrite(lastIndex, this.end, "", { contentOnly: true } );
+		}
+	}
+}

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

@@ -0,0 +1,31 @@
+import Node from '../Node.js';
+import { loopStatement } from '../../utils/patterns.js';
+
+export default class ThisExpression extends Node {
+	initialise(transforms) {
+		if (transforms.arrow) {
+			const lexicalBoundary = this.findLexicalBoundary();
+			const arrowFunction = this.findNearest('ArrowFunctionExpression');
+			const loop = this.findNearest(loopStatement);
+
+			if (
+				(arrowFunction && arrowFunction.depth > lexicalBoundary.depth) ||
+				(loop &&
+					loop.body.contains(this) &&
+					loop.depth > lexicalBoundary.depth) ||
+				(loop && loop.right && loop.right.contains(this))
+			) {
+				this.alias = lexicalBoundary.getThisAlias();
+			}
+		}
+	}
+
+	transpile(code) {
+		if (this.alias) {
+			code.overwrite(this.start, this.end, this.alias, {
+				storeName: true,
+				contentOnly: true
+			});
+		}
+	}
+}

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

@@ -0,0 +1,32 @@
+import Node from '../Node.js';
+import checkConst from '../../utils/checkConst.js';
+
+export default class UpdateExpression extends Node {
+	initialise(transforms) {
+		if (this.argument.type === 'Identifier') {
+			const declaration = this.findScope(false).findDeclaration(
+				this.argument.name
+			);
+			// special case – https://gitlab.com/Rich-Harris/buble/issues/150
+			const statement = declaration && declaration.node.ancestor(3);
+			if (
+				statement &&
+				statement.type === 'ForStatement' &&
+				statement.body.contains(this)
+			) {
+				statement.reassigned[this.argument.name] = true;
+			}
+		}
+
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		if (this.argument.type === 'Identifier') {
+			// Do this check after everything has been initialized to find
+			// shadowing declarations after this expression
+			checkConst(this.argument, this.findScope(false));
+		}
+		super.transpile(code, transforms);
+	}
+}

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

@@ -0,0 +1,101 @@
+import Node from '../Node.js';
+import destructure from '../../utils/destructure.js';
+import { loopStatement } from '../../utils/patterns.js';
+
+export default class VariableDeclaration extends Node {
+	initialise(transforms) {
+		this.scope = this.findScope(this.kind === 'var');
+		this.declarations.forEach(declarator => declarator.initialise(transforms));
+	}
+
+	transpile(code, transforms) {
+		const i0 = this.getIndentation();
+		let kind = this.kind;
+
+		if (transforms.letConst && kind !== 'var') {
+			kind = 'var';
+			code.overwrite(this.start, this.start + this.kind.length, kind, {
+				storeName: true
+			});
+		}
+
+		if (transforms.destructuring && this.parent.type !== 'ForOfStatement' && this.parent.type !== 'ForInStatement') {
+			let c = this.start;
+			let lastDeclaratorIsPattern;
+
+			this.declarations.forEach((declarator, i) => {
+				declarator.transpile(code, transforms);
+
+				if (declarator.id.type === 'Identifier') {
+					if (i > 0 && this.declarations[i - 1].id.type !== 'Identifier') {
+						code.overwrite(c, declarator.id.start, `var `);
+					}
+				} else {
+					const inline = loopStatement.test(this.parent.type);
+
+					if (i === 0) {
+						code.remove(c, declarator.id.start);
+					} else {
+						code.overwrite(c, declarator.id.start, `;\n${i0}`);
+					}
+
+					const simple =
+						declarator.init.type === 'Identifier' && !declarator.init.rewritten;
+
+					const name = simple
+						? (declarator.init.alias || declarator.init.name)
+						: declarator.findScope(true).createIdentifier('ref');
+
+					c = declarator.start;
+
+					let statementGenerators = [];
+
+					if (simple) {
+						code.remove(declarator.id.end, declarator.end);
+					} else {
+						statementGenerators.push((start, prefix, suffix) => {
+							code.prependRight(declarator.id.end, `var ${name}`);
+							code.appendLeft(declarator.init.end, `${suffix}`);
+							code.move(declarator.id.end, declarator.end, start);
+						});
+					}
+
+					const scope = declarator.findScope(false);
+					destructure(
+						code,
+						id => scope.createIdentifier(id),
+						({ name }) => scope.resolveName(name),
+						declarator.id,
+						name,
+						inline,
+						statementGenerators
+					);
+
+					let prefix = inline ? 'var ' : '';
+					let suffix = inline ? `, ` : `;\n${i0}`;
+					statementGenerators.forEach((fn, j) => {
+						if (
+							i === this.declarations.length - 1 &&
+							j === statementGenerators.length - 1
+						) {
+							suffix = inline ? '' : ';';
+						}
+
+						fn(declarator.start, j === 0 ? prefix : '', suffix);
+					});
+				}
+
+				c = declarator.end;
+				lastDeclaratorIsPattern = declarator.id.type !== 'Identifier';
+			});
+
+			if (lastDeclaratorIsPattern && this.end > c) {
+				code.overwrite(c, this.end, '', { contentOnly: true });
+			}
+		} else {
+			this.declarations.forEach(declarator => {
+				declarator.transpile(code, transforms);
+			});
+		}
+	}
+}

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

@@ -0,0 +1,43 @@
+import Node from '../Node.js';
+
+export default class VariableDeclarator extends Node {
+	initialise(transforms) {
+		let kind = this.parent.kind;
+		if (kind === 'let' && this.parent.parent.type === 'ForStatement') {
+			kind = 'for.let'; // special case...
+		}
+
+		this.parent.scope.addDeclaration(this.id, kind);
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		if (!this.init && transforms.letConst && this.parent.kind !== 'var') {
+			let inLoop = this.findNearest(
+				/Function|^For(In|Of)?Statement|^(?:Do)?WhileStatement/
+			);
+			if (
+				inLoop &&
+				!/Function/.test(inLoop.type) &&
+				!this.isLeftDeclaratorOfLoop()
+			) {
+				code.appendLeft(this.id.end, ' = (void 0)');
+			}
+		}
+
+		if (this.id) this.id.transpile(code, transforms);
+		if (this.init) this.init.transpile(code, transforms);
+	}
+
+	isLeftDeclaratorOfLoop() {
+		return (
+			this.parent &&
+			this.parent.type === 'VariableDeclaration' &&
+			this.parent.parent &&
+			(this.parent.parent.type === 'ForInStatement' ||
+				this.parent.parent.type === 'ForOfStatement') &&
+			this.parent.parent.left &&
+			this.parent.parent.left.declarations[0] === this
+		);
+	}
+}

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

@@ -0,0 +1,98 @@
+import ArrayExpression from './ArrayExpression.js';
+import ArrowFunctionExpression from './ArrowFunctionExpression.js';
+import AssignmentExpression from './AssignmentExpression.js';
+import BinaryExpression from './BinaryExpression.js';
+import BreakStatement from './BreakStatement.js';
+import CallExpression from './CallExpression.js';
+import ClassBody from './ClassBody.js';
+import ClassDeclaration from './ClassDeclaration.js';
+import ClassExpression from './ClassExpression.js';
+import ContinueStatement from './ContinueStatement.js';
+import ExportDefaultDeclaration from './ExportDefaultDeclaration.js';
+import ExportNamedDeclaration from './ExportNamedDeclaration.js';
+import ForStatement from './ForStatement.js';
+import ForInStatement from './ForInStatement.js';
+import ForOfStatement from './ForOfStatement.js';
+import FunctionDeclaration from './FunctionDeclaration.js';
+import FunctionExpression from './FunctionExpression.js';
+import Identifier from './Identifier.js';
+import IfStatement from './IfStatement.js';
+import ImportDeclaration from './ImportDeclaration.js';
+import ImportDefaultSpecifier from './ImportDefaultSpecifier.js';
+import ImportSpecifier from './ImportSpecifier.js';
+import JSXAttribute from './JSXAttribute.js';
+import JSXClosingElement from './JSXClosingElement.js';
+import JSXClosingFragment from './JSXClosingFragment.js';
+import JSXElement from './JSXElement.js';
+import JSXExpressionContainer from './JSXExpressionContainer.js';
+import JSXFragment from './JSXFragment.js';
+import JSXOpeningElement from './JSXOpeningElement.js';
+import JSXOpeningFragment from './JSXOpeningFragment.js';
+import JSXSpreadAttribute from './JSXSpreadAttribute.js';
+import Literal from './Literal.js';
+import LoopStatement from './shared/LoopStatement.js';
+import MemberExpression from './MemberExpression.js';
+import NewExpression from './NewExpression.js';
+import ObjectExpression from './ObjectExpression.js';
+import Property from './Property.js';
+import ReturnStatement from './ReturnStatement.js';
+import SpreadElement from './SpreadElement.js';
+import Super from './Super.js';
+import TaggedTemplateExpression from './TaggedTemplateExpression.js';
+import TemplateElement from './TemplateElement.js';
+import TemplateLiteral from './TemplateLiteral.js';
+import ThisExpression from './ThisExpression.js';
+import UpdateExpression from './UpdateExpression.js';
+import VariableDeclaration from './VariableDeclaration.js';
+import VariableDeclarator from './VariableDeclarator.js';
+
+export default {
+	ArrayExpression,
+	ArrowFunctionExpression,
+	AssignmentExpression,
+	BinaryExpression,
+	BreakStatement,
+	CallExpression,
+	ClassBody,
+	ClassDeclaration,
+	ClassExpression,
+	ContinueStatement,
+	DoWhileStatement: LoopStatement,
+	ExportNamedDeclaration,
+	ExportDefaultDeclaration,
+	ForStatement,
+	ForInStatement,
+	ForOfStatement,
+	FunctionDeclaration,
+	FunctionExpression,
+	Identifier,
+	IfStatement,
+	ImportDeclaration,
+	ImportDefaultSpecifier,
+	ImportSpecifier,
+	JSXAttribute,
+	JSXClosingElement,
+	JSXClosingFragment,
+	JSXElement,
+	JSXExpressionContainer,
+	JSXFragment,
+	JSXOpeningElement,
+	JSXOpeningFragment,
+	JSXSpreadAttribute,
+	Literal,
+	MemberExpression,
+	NewExpression,
+	ObjectExpression,
+	Property,
+	ReturnStatement,
+	SpreadElement,
+	Super,
+	TaggedTemplateExpression,
+	TemplateElement,
+	TemplateLiteral,
+	ThisExpression,
+	UpdateExpression,
+	VariableDeclaration,
+	VariableDeclarator,
+	WhileStatement: LoopStatement
+};

data/vendor/node_modules/buble/src/program/types/shared/LoopStatement.js

@@ -0,0 +1,105 @@
+import Node from '../../Node.js';
+
+export default class LoopStatement extends Node {
+	findScope(functionScope) {
+		return functionScope || !this.createdScope
+			? this.parent.findScope(functionScope)
+			: this.body.scope;
+	}
+
+	initialise(transforms) {
+		this.body.createScope();
+		this.createdScope = true;
+
+		// this is populated as and when reassignments occur
+		this.reassigned = Object.create(null);
+		this.aliases = Object.create(null);
+
+		super.initialise(transforms);
+
+		if (transforms.letConst) {
+			// see if any block-scoped declarations are referenced
+			// inside function expressions
+			const names = Object.keys(this.body.scope.declarations);
+
+			let i = names.length;
+			while (i--) {
+				const name = names[i];
+				const declaration = this.body.scope.declarations[name];
+
+				let j = declaration.instances.length;
+				while (j--) {
+					const instance = declaration.instances[j];
+					const nearestFunctionExpression = instance.findNearest(/Function/);
+
+					if (
+						nearestFunctionExpression &&
+						nearestFunctionExpression.depth > this.depth
+					) {
+						this.shouldRewriteAsFunction = true;
+						break;
+					}
+				}
+
+				if (this.shouldRewriteAsFunction) break;
+			}
+		}
+	}
+
+	transpile(code, transforms) {
+		const needsBlock =
+			this.type != 'ForOfStatement' &&
+			(this.body.type !== 'BlockStatement' ||
+				(this.body.type === 'BlockStatement' && this.body.synthetic));
+
+		if (this.shouldRewriteAsFunction) {
+			const i0 = this.getIndentation();
+			const i1 = i0 + code.getIndentString();
+
+			const argString = this.args ? ` ${this.args.join(', ')} ` : '';
+			const paramString = this.params ? ` ${this.params.join(', ')} ` : '';
+
+			const functionScope = this.findScope(true);
+			const loop = functionScope.createIdentifier('loop');
+
+			const before =
+				`var ${loop} = function (${paramString}) ` +
+				(this.body.synthetic ? `{\n${i0}${code.getIndentString()}` : '');
+			const after = (this.body.synthetic ? `\n${i0}}` : '') + `;\n\n${i0}`;
+
+			code.prependRight(this.body.start, before);
+			code.appendLeft(this.body.end, after);
+			code.move(this.start, this.body.start, this.body.end);
+
+			if (this.canBreak || this.canReturn) {
+				const returned = functionScope.createIdentifier('returned');
+
+				let insert = `{\n${i1}var ${returned} = ${loop}(${argString});\n`;
+				if (this.canBreak)
+					insert += `\n${i1}if ( ${returned} === 'break' ) break;`;
+				if (this.canReturn)
+					insert += `\n${i1}if ( ${returned} ) return ${returned}.v;`;
+				insert += `\n${i0}}`;
+
+				code.prependRight(this.body.end, insert);
+			} else {
+				const callExpression = `${loop}(${argString});`;
+
+				if (this.type === 'DoWhileStatement') {
+					code.overwrite(
+						this.start,
+						this.body.start,
+						`do {\n${i1}${callExpression}\n${i0}}`
+					);
+				} else {
+					code.prependRight(this.body.end, callExpression);
+				}
+			}
+		} else if (needsBlock) {
+			code.appendLeft(this.body.start, '{ ');
+			code.prependRight(this.body.end, ' }');
+		}
+
+		super.transpile(code, transforms);
+	}
+}