jass 0.9.1

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

@@ -0,0 +1,185 @@
+import Node from '../Node.js';
+import checkConst from '../../utils/checkConst.js';
+import destructure from '../../utils/destructure.js';
+
+export default class AssignmentExpression extends Node {
+	initialise(transforms) {
+		if (this.left.type === 'Identifier') {
+			const declaration = this.findScope(false).findDeclaration(this.left.name);
+			// special case – https://gitlab.com/Rich-Harris/buble/issues/11
+			const statement = declaration && declaration.node.ancestor(3);
+			if (
+				statement &&
+				statement.type === 'ForStatement' &&
+				statement.body.contains(this)
+			) {
+				statement.reassigned[this.left.name] = true;
+			}
+		}
+
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		if (this.left.type === 'Identifier') {
+			// Do this check after everything has been initialized to find
+			// shadowing declarations after this expression
+			checkConst(this.left, this.findScope(false));
+		}
+
+		if (this.operator === '**=' && transforms.exponentiation) {
+			this.transpileExponentiation(code, transforms);
+		} else if (/Pattern/.test(this.left.type) && transforms.destructuring) {
+			this.transpileDestructuring(code, transforms);
+		}
+
+		super.transpile(code, transforms);
+	}
+
+	transpileDestructuring(code) {
+		const writeScope = this.findScope(true);
+		const lookupScope = this.findScope(false);
+		const assign = writeScope.createDeclaration('assign');
+		code.appendRight(this.left.end, `(${assign}`);
+
+		code.appendLeft(this.right.end, ', ');
+		const statementGenerators = [];
+		destructure(
+			code,
+			id => writeScope.createDeclaration(id),
+			node => {
+				const name = lookupScope.resolveName(node.name);
+				checkConst(node, lookupScope);
+				return name;
+			},
+			this.left,
+			assign,
+			true,
+			statementGenerators
+		);
+
+		let suffix = ', ';
+		statementGenerators.forEach((fn, j) => {
+			if (j === statementGenerators.length - 1) {
+				suffix = '';
+			}
+
+			fn(this.end, '', suffix);
+		});
+
+		if (this.unparenthesizedParent().type === 'ExpressionStatement') {
+			// no rvalue needed for expression statement
+			code.appendRight(this.end, `)`);
+		} else {
+			// destructuring is part of an expression - need an rvalue
+			code.appendRight(this.end, `, ${assign})`);
+		}
+	}
+
+	transpileExponentiation(code) {
+		const scope = this.findScope(false);
+
+		// first, the easy part – `**=` -> `=`
+		let charIndex = this.left.end;
+		while (code.original[charIndex] !== '*') charIndex += 1;
+		code.remove(charIndex, charIndex + 2);
+
+		// how we do the next part depends on a number of factors – whether
+		// this is a top-level statement, and whether we're updating a
+		// simple or complex reference
+		let base;
+
+		const left = this.left.unparenthesize();
+
+		if (left.type === 'Identifier') {
+			base = scope.resolveName(left.name);
+		} else if (left.type === 'MemberExpression') {
+			let object;
+			let needsObjectVar = false;
+			let property;
+			let needsPropertyVar = false;
+
+			const statement = this.findNearest(/(?:Statement|Declaration)$/);
+			const i0 = statement.getIndentation();
+
+			if (left.property.type === 'Identifier') {
+				property = left.computed
+					? scope.resolveName(left.property.name)
+					: left.property.name;
+			} else {
+				property = scope.createDeclaration('property');
+				needsPropertyVar = true;
+			}
+
+			if (left.object.type === 'Identifier') {
+				object = scope.resolveName(left.object.name);
+			} else {
+				object = scope.createDeclaration('object');
+				needsObjectVar = true;
+			}
+
+			if (left.start === statement.start) {
+				if (needsObjectVar && needsPropertyVar) {
+					code.prependRight(statement.start, `${object} = `);
+					code.overwrite(
+						left.object.end,
+						left.property.start,
+						`;\n${i0}${property} = `
+					);
+					code.overwrite(
+						left.property.end,
+						left.end,
+						`;\n${i0}${object}[${property}]`
+					);
+				} else if (needsObjectVar) {
+					code.prependRight(statement.start, `${object} = `);
+					code.appendLeft(left.object.end, `;\n${i0}`);
+					code.appendLeft(left.object.end, object);
+				} else if (needsPropertyVar) {
+					code.prependRight(left.property.start, `${property} = `);
+					code.appendLeft(left.property.end, `;\n${i0}`);
+					code.move(left.property.start, left.property.end, this.start);
+
+					code.appendLeft(left.object.end, `[${property}]`);
+					code.remove(left.object.end, left.property.start);
+					code.remove(left.property.end, left.end);
+				}
+			} else {
+				if (needsObjectVar && needsPropertyVar) {
+					code.prependRight(left.start, `( ${object} = `);
+					code.overwrite(
+						left.object.end,
+						left.property.start,
+						`, ${property} = `
+					);
+					code.overwrite(
+						left.property.end,
+						left.end,
+						`, ${object}[${property}]`
+					);
+				} else if (needsObjectVar) {
+					code.prependRight(left.start, `( ${object} = `);
+					code.appendLeft(left.object.end, `, ${object}`);
+				} else if (needsPropertyVar) {
+					code.prependRight(left.property.start, `( ${property} = `);
+					code.appendLeft(left.property.end, `, `);
+					code.move(left.property.start, left.property.end, left.start);
+
+					code.overwrite(left.object.end, left.property.start, `[${property}]`);
+					code.remove(left.property.end, left.end);
+				}
+
+				if (needsPropertyVar) {
+					code.appendLeft(this.end, ` )`);
+				}
+			}
+
+			base =
+				object +
+				(left.computed || needsPropertyVar ? `[${property}]` : `.${property}`);
+		}
+
+		code.prependRight(this.right.start, `Math.pow( ${base}, `);
+		code.appendLeft(this.right.end, ` )`);
+	}
+}

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

@@ -0,0 +1,12 @@
+import Node from '../Node.js';
+
+export default class BinaryExpression extends Node {
+	transpile(code, transforms) {
+		if (this.operator === '**' && transforms.exponentiation) {
+			code.prependRight(this.start, `Math.pow( `);
+			code.overwrite(this.left.end, this.right.start, `, `);
+			code.appendLeft(this.end, ` )`);
+		}
+		super.transpile(code, transforms);
+	}
+}

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

@@ -0,0 +1,26 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+import { loopStatement } from '../../utils/patterns.js';
+
+export default class BreakStatement extends Node {
+	initialise() {
+		const loop = this.findNearest(loopStatement);
+		const switchCase = this.findNearest('SwitchCase');
+
+		if (loop && (!switchCase || loop.depth > switchCase.depth)) {
+			loop.canBreak = true;
+			this.loop = loop;
+		}
+	}
+
+	transpile(code) {
+		if (this.loop && this.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 + 5, `return 'break'`);
+		}
+	}
+}

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

@@ -0,0 +1,104 @@
+import Node from '../Node.js';
+import spread, { isArguments } from '../../utils/spread.js';
+import removeTrailingComma from '../../utils/removeTrailingComma.js';
+
+export default class CallExpression extends Node {
+	initialise(transforms) {
+		if (transforms.spreadRest && this.arguments.length > 1) {
+			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();
+				}
+			}
+		}
+
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		if (transforms.spreadRest && this.arguments.length) {
+			let hasSpreadElements = false;
+			let context;
+
+			const firstArgument = this.arguments[0];
+
+			if (this.arguments.length === 1) {
+				if (firstArgument.type === 'SpreadElement') {
+					code.remove(firstArgument.start, firstArgument.argument.start);
+					hasSpreadElements = true;
+				}
+			} else {
+				hasSpreadElements = spread(
+					code,
+					this.arguments,
+					firstArgument.start,
+					this.argumentsArrayAlias
+				);
+			}
+
+			if (hasSpreadElements) {
+				// we need to handle super() and super.method() differently
+				// due to its instance
+				let _super = null;
+				if (this.callee.type === 'Super') {
+					_super = this.callee;
+				} else if (
+					this.callee.type === 'MemberExpression' &&
+					this.callee.object.type === 'Super'
+				) {
+					_super = this.callee.object;
+				}
+
+				if (!_super && this.callee.type === 'MemberExpression') {
+					if (this.callee.object.type === 'Identifier') {
+						context = this.callee.object.name;
+					} else {
+						context = this.findScope(true).createDeclaration('ref');
+						const callExpression = this.callee.object;
+						code.prependRight(callExpression.start, `(${context} = `);
+						code.appendLeft(callExpression.end, `)`);
+					}
+				} else {
+					context = 'void 0';
+				}
+
+				code.appendLeft(this.callee.end, '.apply');
+
+				if (_super) {
+					_super.noCall = true; // bit hacky...
+
+					if (this.arguments.length > 1) {
+						if (firstArgument.type !== 'SpreadElement') {
+							code.prependRight(firstArgument.start, `[ `);
+						}
+
+						code.appendLeft(
+							this.arguments[this.arguments.length - 1].end,
+							' )'
+						);
+					}
+				} else if (this.arguments.length === 1) {
+					code.prependRight(firstArgument.start, `${context}, `);
+				} else {
+					if (firstArgument.type === 'SpreadElement') {
+						code.appendLeft(firstArgument.start, `${context}, `);
+					} else {
+						code.appendLeft(firstArgument.start, `${context}, [ `);
+					}
+
+					code.appendLeft(this.arguments[this.arguments.length - 1].end, ' )');
+				}
+			}
+		}
+
+		if (transforms.trailingFunctionCommas && this.arguments.length) {
+			removeTrailingComma(code, this.arguments[this.arguments.length - 1].end);
+		}
+
+		super.transpile(code, transforms);
+	}
+}

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

@@ -0,0 +1,237 @@
+import Node from '../Node.js';
+import { findIndex } from '../../utils/array.js';
+import reserved from '../../utils/reserved.js';
+
+// TODO this code is pretty wild, tidy it up
+export default class ClassBody extends Node {
+	transpile(code, transforms, inFunctionExpression, superName) {
+		if (transforms.classes) {
+			const name = this.parent.name;
+
+			const indentStr = code.getIndentString();
+			const i0 =
+				this.getIndentation() + (inFunctionExpression ? indentStr : '');
+			const i1 = i0 + indentStr;
+
+			const constructorIndex = findIndex(
+				this.body,
+				node => node.kind === 'constructor'
+			);
+			const constructor = this.body[constructorIndex];
+
+			let introBlock = '';
+			let outroBlock = '';
+
+			if (this.body.length) {
+				code.remove(this.start, this.body[0].start);
+				code.remove(this.body[this.body.length - 1].end, this.end);
+			} else {
+				code.remove(this.start, this.end);
+			}
+
+			if (constructor) {
+				constructor.value.body.isConstructorBody = true;
+
+				const previousMethod = this.body[constructorIndex - 1];
+				const nextMethod = this.body[constructorIndex + 1];
+
+				// ensure constructor is first
+				if (constructorIndex > 0) {
+					code.remove(previousMethod.end, constructor.start);
+					code.move(
+						constructor.start,
+						nextMethod ? nextMethod.start : this.end - 1,
+						this.body[0].start
+					);
+				}
+
+				if (!inFunctionExpression) code.appendLeft(constructor.end, ';');
+			}
+
+			let namedFunctions =
+				this.program.options.namedFunctionExpressions !== false;
+			let namedConstructor =
+				namedFunctions ||
+				this.parent.superClass ||
+				this.parent.type !== 'ClassDeclaration';
+			if (this.parent.superClass) {
+				let inheritanceBlock = `if ( ${superName} ) ${name}.__proto__ = ${
+					superName
+				};\n${i0}${name}.prototype = Object.create( ${superName} && ${
+					superName
+				}.prototype );\n${i0}${name}.prototype.constructor = ${name};`;
+
+				if (constructor) {
+					introBlock += `\n\n${i0}` + inheritanceBlock;
+				} else {
+					const fn =
+						`function ${name} () {` +
+						(superName
+							? `\n${i1}${superName}.apply(this, arguments);\n${i0}}`
+							: `}`) +
+						(inFunctionExpression ? '' : ';') +
+						(this.body.length ? `\n\n${i0}` : '');
+
+					inheritanceBlock = fn + inheritanceBlock;
+					introBlock += inheritanceBlock + `\n\n${i0}`;
+				}
+			} else if (!constructor) {
+				let fn = 'function ' + (namedConstructor ? name + ' ' : '') + '() {}';
+				if (this.parent.type === 'ClassDeclaration') fn += ';';
+				if (this.body.length) fn += `\n\n${i0}`;
+
+				introBlock += fn;
+			}
+
+			const scope = this.findScope(false);
+
+			let prototypeGettersAndSetters = [];
+			let staticGettersAndSetters = [];
+			let prototypeAccessors;
+			let staticAccessors;
+
+			this.body.forEach((method, i) => {
+				if (method.kind === 'constructor') {
+					let constructorName = namedConstructor ? ' ' + name : '';
+					code.overwrite(
+						method.key.start,
+						method.key.end,
+						`function${constructorName}`
+					);
+					return;
+				}
+
+				if (method.static) {
+					const len = code.original[method.start + 6] == ' ' ? 7 : 6;
+					code.remove(method.start, method.start + len);
+				}
+
+				const isAccessor = method.kind !== 'method';
+				let lhs;
+
+				let methodName = method.key.name;
+				if (
+					reserved[methodName] ||
+					method.value.body.scope.references[methodName]
+				) {
+					methodName = scope.createIdentifier(methodName);
+				}
+
+				// when method name is a string or a number let's pretend it's a computed method
+
+				let fake_computed = false;
+				if (!method.computed && method.key.type === 'Literal') {
+					fake_computed = true;
+					method.computed = true;
+				}
+
+				if (isAccessor) {
+					if (method.computed) {
+						throw new Error(
+							'Computed accessor properties are not currently supported'
+						);
+					}
+
+					code.remove(method.start, method.key.start);
+
+					if (method.static) {
+						if (!~staticGettersAndSetters.indexOf(method.key.name))
+							staticGettersAndSetters.push(method.key.name);
+						if (!staticAccessors)
+							staticAccessors = scope.createIdentifier('staticAccessors');
+
+						lhs = `${staticAccessors}`;
+					} else {
+						if (!~prototypeGettersAndSetters.indexOf(method.key.name))
+							prototypeGettersAndSetters.push(method.key.name);
+						if (!prototypeAccessors)
+							prototypeAccessors = scope.createIdentifier('prototypeAccessors');
+
+						lhs = `${prototypeAccessors}`;
+					}
+				} else {
+					lhs = method.static ? `${name}` : `${name}.prototype`;
+				}
+
+				if (!method.computed) lhs += '.';
+
+				const insertNewlines =
+					(constructorIndex > 0 && i === constructorIndex + 1) ||
+					(i === 0 && constructorIndex === this.body.length - 1);
+
+				if (insertNewlines) lhs = `\n\n${i0}${lhs}`;
+
+				let c = method.key.end;
+				if (method.computed) {
+					if (fake_computed) {
+						code.prependRight(method.key.start, '[');
+						code.appendLeft(method.key.end, ']');
+					} else {
+						while (code.original[c] !== ']') c += 1;
+						c += 1;
+					}
+				}
+
+				const funcName =
+					method.computed || isAccessor || !namedFunctions
+						? ''
+						: `${methodName} `;
+				const rhs =
+					(isAccessor ? `.${method.kind}` : '') +
+					` = function` +
+					(method.value.generator ? '* ' : ' ') +
+					funcName;
+				code.remove(c, method.value.start);
+				code.prependRight(method.value.start, rhs);
+				code.appendLeft(method.end, ';');
+
+				if (method.value.generator) code.remove(method.start, method.key.start);
+
+				code.prependRight(method.start, lhs);
+			});
+
+			if (prototypeGettersAndSetters.length || staticGettersAndSetters.length) {
+				let intro = [];
+				let outro = [];
+
+				if (prototypeGettersAndSetters.length) {
+					intro.push(
+						`var ${prototypeAccessors} = { ${prototypeGettersAndSetters
+							.map(name => `${name}: { configurable: true }`)
+							.join(',')} };`
+					);
+					outro.push(
+						`Object.defineProperties( ${name}.prototype, ${
+							prototypeAccessors
+						} );`
+					);
+				}
+
+				if (staticGettersAndSetters.length) {
+					intro.push(
+						`var ${staticAccessors} = { ${staticGettersAndSetters
+							.map(name => `${name}: { configurable: true }`)
+							.join(',')} };`
+					);
+					outro.push(`Object.defineProperties( ${name}, ${staticAccessors} );`);
+				}
+
+				if (constructor) introBlock += `\n\n${i0}`;
+				introBlock += intro.join(`\n${i0}`);
+				if (!constructor) introBlock += `\n\n${i0}`;
+
+				outroBlock += `\n\n${i0}` + outro.join(`\n${i0}`);
+			}
+
+			if (constructor) {
+				code.appendLeft(constructor.end, introBlock);
+			} else {
+				code.prependRight(this.start, introBlock);
+			}
+
+			code.appendLeft(this.end, outroBlock);
+		}
+
+		super.transpile(code, transforms);
+	}
+}