jass 0.9.1

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

@@ -0,0 +1,54 @@
+import Node from '../Node.js';
+import isReference from '../../utils/isReference.js';
+import { loopStatement } from '../../utils/patterns.js';
+
+export default class Identifier extends Node {
+	findScope(functionScope) {
+		if (this.parent.params && ~this.parent.params.indexOf(this)) {
+			return this.parent.body.scope;
+		}
+
+		if (this.parent.type === 'FunctionExpression' && this === this.parent.id) {
+			return this.parent.body.scope;
+		}
+
+		return this.parent.findScope(functionScope);
+	}
+
+	initialise(transforms) {
+		if (isReference(this, this.parent)) {
+			if (
+				transforms.arrow &&
+				this.name === 'arguments' &&
+				!this.findScope(false).contains(this.name)
+			) {
+				const lexicalBoundary = this.findLexicalBoundary();
+				const arrowFunction = this.findNearest('ArrowFunctionExpression');
+				const loop = this.findNearest(loopStatement);
+
+				if (arrowFunction && arrowFunction.depth > lexicalBoundary.depth) {
+					this.alias = lexicalBoundary.getArgumentsAlias();
+				}
+
+				if (
+					loop &&
+					loop.body.contains(this) &&
+					loop.depth > lexicalBoundary.depth
+				) {
+					this.alias = lexicalBoundary.getArgumentsAlias();
+				}
+			}
+
+			this.findScope(false).addReference(this);
+		}
+	}
+
+	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/IfStatement.js

@@ -0,0 +1,29 @@
+import Node from '../Node.js';
+
+export default class IfStatement extends Node {
+	initialise(transforms) {
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		if (
+			this.consequent.type !== 'BlockStatement' ||
+			(this.consequent.type === 'BlockStatement' && this.consequent.synthetic)
+		) {
+			code.appendLeft(this.consequent.start, '{ ');
+			code.prependRight(this.consequent.end, ' }');
+		}
+
+		if (
+			this.alternate &&
+			this.alternate.type !== 'IfStatement' &&
+			(this.alternate.type !== 'BlockStatement' ||
+				(this.alternate.type === 'BlockStatement' && this.alternate.synthetic))
+		) {
+			code.appendLeft(this.alternate.start, '{ ');
+			code.prependRight(this.alternate.end, ' }');
+		}
+
+		super.transpile(code, transforms);
+	}
+}

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

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

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

@@ -0,0 +1,8 @@
+import Node from '../Node.js';
+
+export default class ImportDefaultSpecifier extends Node {
+	initialise(transforms) {
+		this.findScope(true).addDeclaration(this.local, 'import');
+		super.initialise(transforms);
+	}
+}

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

@@ -0,0 +1,8 @@
+import Node from '../Node.js';
+
+export default class ImportSpecifier extends Node {
+	initialise(transforms) {
+		this.findScope(true).addDeclaration(this.local, 'import');
+		super.initialise(transforms);
+	}
+}

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

@@ -0,0 +1,20 @@
+import Node from '../Node.js';
+
+const hasDashes = val => /-/.test(val);
+
+const formatKey = key => (hasDashes(key) ? `'${key}'` : key);
+
+const formatVal = val => (val ? '' : 'true');
+
+export default class JSXAttribute extends Node {
+	transpile(code, transforms) {
+		const { start, name } = this.name;
+
+		// Overwrite equals sign if value is present.
+		const end = this.value ? this.value.start : this.name.end;
+
+		code.overwrite(start, end, `${formatKey(name)}: ${formatVal(this.value)}`);
+
+		super.transpile(code, transforms);
+	}
+}

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

@@ -0,0 +1,27 @@
+import Node from '../Node.js';
+
+function containsNewLine(node) {
+	return (
+		node.type === 'JSXText' && !/\S/.test(node.value) && /\n/.test(node.value)
+	);
+}
+
+export default class JSXClosingElement extends Node {
+	transpile(code) {
+		let spaceBeforeParen = true;
+
+		const lastChild = this.parent.children[this.parent.children.length - 1];
+
+		// omit space before closing paren if
+		//   a) this is on a separate line, or
+		//   b) there are no children but there are attributes
+		if (
+			(lastChild && containsNewLine(lastChild)) ||
+			this.parent.openingElement.attributes.length
+		) {
+			spaceBeforeParen = false;
+		}
+
+		code.overwrite(this.start, this.end, spaceBeforeParen ? ' )' : ')');
+	}
+}

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

@@ -0,0 +1,22 @@
+import Node from '../Node.js';
+
+function containsNewLine(node) {
+	return (
+		node.type === 'JSXText' && !/\S/.test(node.value) && /\n/.test(node.value)
+	);
+}
+
+export default class JSXClosingFragment extends Node {
+	transpile(code) {
+		let spaceBeforeParen = true;
+
+		const lastChild = this.parent.children[this.parent.children.length - 1];
+
+		// omit space before closing paren if this is on a separate line
+		if (lastChild && containsNewLine(lastChild)) {
+			spaceBeforeParen = false;
+		}
+
+		code.overwrite(this.start, this.end, spaceBeforeParen ? ' )' : ')');
+	}
+}

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

@@ -0,0 +1,57 @@
+import Node from '../Node.js';
+
+function normalise(str, removeTrailingWhitespace) {
+
+	str = str.replace(/\u00a0/g, ' ');
+
+	if (removeTrailingWhitespace && /\n/.test(str)) {
+		str = str.replace(/\s+$/, '');
+	}
+
+	str = str
+		.replace(/^\n\r?\s+/, '') // remove leading newline + space
+		.replace(/\s*\n\r?\s*/gm, ' '); // replace newlines with spaces
+
+	// TODO prefer single quotes?
+	return JSON.stringify(str);
+}
+
+export default class JSXElement extends Node {
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+
+		const children = this.children.filter(child => {
+			if (child.type !== 'JSXText') return true;
+
+			// remove whitespace-only literals, unless on a single line
+			return /\S/.test(child.raw) || !/\n/.test(child.raw);
+		});
+
+		if (children.length) {
+			let c = this.openingElement.end;
+
+			let i;
+			for (i = 0; i < children.length; i += 1) {
+				const child = children[i];
+
+				if (
+					child.type === 'JSXExpressionContainer' &&
+					child.expression.type === 'JSXEmptyExpression'
+				) {
+					// empty block is a no op
+				} else {
+					const tail =
+						code.original[c] === '\n' && child.type !== 'JSXText' ? '' : ' ';
+					code.appendLeft(c, `,${tail}`);
+				}
+
+				if (child.type === 'JSXText') {
+					const str = normalise(child.value, i === children.length - 1);
+					code.overwrite(child.start, child.end, str);
+				}
+
+				c = child.end;
+			}
+		}
+	}
+}

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

@@ -0,0 +1,10 @@
+import Node from '../Node.js';
+
+export default class JSXExpressionContainer extends Node {
+	transpile(code, transforms) {
+		code.remove(this.start, this.expression.start);
+		code.remove(this.expression.end, this.end);
+
+		super.transpile(code, transforms);
+	}
+}

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

@@ -0,0 +1,4 @@
+import JSXElement from './JSXElement.js';
+
+export default class JSXFragment extends JSXElement {
+}

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

@@ -0,0 +1,93 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+
+export default class JSXOpeningElement extends Node {
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+
+		code.overwrite(this.start, this.name.start, `${this.program.jsx}( `);
+
+		const html =
+			this.name.type === 'JSXIdentifier' &&
+			this.name.name[0] === this.name.name[0].toLowerCase();
+		if (html) code.prependRight(this.name.start, `'`);
+
+		const len = this.attributes.length;
+		let c = this.name.end;
+
+		if (len) {
+			let i;
+
+			let hasSpread = false;
+			for (i = 0; i < len; i += 1) {
+				if (this.attributes[i].type === 'JSXSpreadAttribute') {
+					hasSpread = true;
+					break;
+				}
+			}
+
+			c = this.attributes[0].end;
+
+			for (i = 0; i < len; i += 1) {
+				const attr = this.attributes[i];
+
+				if (i > 0) {
+					if (attr.start === c) code.prependRight(c, ', ');
+					else code.overwrite(c, attr.start, ', ');
+				}
+
+				if (hasSpread && attr.type !== 'JSXSpreadAttribute') {
+					const lastAttr = this.attributes[i - 1];
+					const nextAttr = this.attributes[i + 1];
+
+					if (!lastAttr || lastAttr.type === 'JSXSpreadAttribute') {
+						code.prependRight(attr.start, '{ ');
+					}
+
+					if (!nextAttr || nextAttr.type === 'JSXSpreadAttribute') {
+						code.appendLeft(attr.end, ' }');
+					}
+				}
+
+				c = attr.end;
+			}
+
+			let after;
+			let before;
+			if (hasSpread) {
+				if (len === 1) {
+					before = html ? `',` : ',';
+				} else {
+					if (!this.program.options.objectAssign) {
+						throw new CompileError(
+							"Mixed JSX attributes ending in spread requires specified objectAssign option with 'Object.assign' or polyfill helper.",
+							this
+						);
+					}
+					before = html
+						? `', ${this.program.options.objectAssign}({},`
+						: `, ${this.program.options.objectAssign}({},`;
+					after = ')';
+				}
+			} else {
+				before = html ? `', {` : ', {';
+				after = ' }';
+			}
+
+			code.prependRight(this.name.end, before);
+
+			if (after) {
+				code.appendLeft(this.attributes[len - 1].end, after);
+			}
+		} else {
+			code.appendLeft(this.name.end, html ? `', null` : `, null`);
+			c = this.name.end;
+		}
+
+		if (this.selfClosing) {
+			code.overwrite(c, this.end, this.attributes.length ? `)` : ` )`);
+		} else {
+			code.remove(c, this.end);
+		}
+	}
+}

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

@@ -0,0 +1,7 @@
+import Node from '../Node.js';
+
+export default class JSXOpeningFragment extends Node {
+	transpile(code, transforms) {
+		code.overwrite(this.start, this.end, `${this.program.jsx}( React.Fragment, null`);
+	}
+}

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

@@ -0,0 +1,10 @@
+import Node from '../Node.js';
+
+export default class JSXSpreadAttribute extends Node {
+	transpile(code, transforms) {
+		code.remove(this.start, this.argument.start);
+		code.remove(this.argument.end, this.end);
+
+		super.transpile(code, transforms);
+	}
+}

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

@@ -0,0 +1,43 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+import rewritePattern from 'regexpu-core';
+
+export default class Literal extends Node {
+	initialise() {
+		if (typeof this.value === 'string') {
+			this.program.indentExclusionElements.push(this);
+		}
+	}
+
+	transpile(code, transforms) {
+		if (transforms.numericLiteral) {
+			const leading = this.raw.slice(0, 2);
+			if (leading === '0b' || leading === '0o') {
+				code.overwrite(this.start, this.end, String(this.value), {
+					storeName: true,
+					contentOnly: true
+				});
+			}
+		}
+
+		if (this.regex) {
+			const { pattern, flags } = this.regex;
+
+			if (transforms.stickyRegExp && /y/.test(flags))
+				throw new CompileError(
+					'Regular expression sticky flag is not supported',
+					this
+				);
+			if (transforms.unicodeRegExp && /u/.test(flags)) {
+				code.overwrite(
+					this.start,
+					this.end,
+					`/${rewritePattern(pattern, flags)}/${flags.replace('u', '')}`,
+					{
+						contentOnly: true
+					}
+				);
+			}
+		}
+	}
+}

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

@@ -0,0 +1,13 @@
+import Node from '../Node.js';
+import reserved from '../../utils/reserved.js';
+
+export default class MemberExpression extends Node {
+	transpile(code, transforms) {
+		if (transforms.reservedProperties && reserved[this.property.name]) {
+			code.overwrite(this.object.end, this.property.start, `['`);
+			code.appendLeft(this.property.end, `']`);
+		}
+
+		super.transpile(code, transforms);
+	}
+}

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

@@ -0,0 +1,55 @@
+import Node from '../Node.js';
+import spread, { isArguments } from '../../utils/spread.js';
+import removeTrailingComma from '../../utils/removeTrailingComma.js';
+
+export default class NewExpression extends Node {
+	initialise(transforms) {
+		if (transforms.spreadRest && this.arguments.length) {
+			const lexicalBoundary = this.findLexicalBoundary();
+
+			let i = this.arguments.length;
+			while (i--) {
+				const arg = this.arguments[i];
+				if (arg.type === 'SpreadElement' && isArguments(arg.argument)) {
+					this.argumentsArrayAlias = lexicalBoundary.getArgumentsArrayAlias();
+					break;
+				}
+			}
+		}
+
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+
+		if (transforms.spreadRest && this.arguments.length) {
+			const firstArgument = this.arguments[0];
+			const isNew = true;
+			let hasSpreadElements = spread(
+				code,
+				this.arguments,
+				firstArgument.start,
+				this.argumentsArrayAlias,
+				isNew
+			);
+
+			if (hasSpreadElements) {
+				code.prependRight(
+					this.start + 'new'.length,
+					' (Function.prototype.bind.apply('
+				);
+				code.overwrite(
+					this.callee.end,
+					firstArgument.start,
+					', [ null ].concat( '
+				);
+				code.appendLeft(this.end, ' ))');
+			}
+		}
+
+		if (this.arguments.length) {
+			removeTrailingComma(code, this.arguments[this.arguments.length - 1].end);
+		}
+	}
+}