jass 0.9.1

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

@@ -0,0 +1,250 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+
+export default class ObjectExpression extends Node {
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+
+		let firstPropertyStart = this.start + 1;
+		let regularPropertyCount = 0;
+		let spreadPropertyCount = 0;
+		let computedPropertyCount = 0;
+		let firstSpreadProperty = null;
+		let firstComputedProperty = null;
+
+		for (let i = 0; i < this.properties.length; ++i) {
+			const prop = this.properties[i];
+			if (prop.type === 'SpreadElement') {
+				spreadPropertyCount += 1;
+				if (firstSpreadProperty === null) firstSpreadProperty = i;
+			} else if (prop.computed) {
+				computedPropertyCount += 1;
+				if (firstComputedProperty === null) firstComputedProperty = i;
+			} else if (prop.type === 'Property') {
+				regularPropertyCount += 1;
+			}
+		}
+
+		if (spreadPropertyCount) {
+			if (!this.program.options.objectAssign) {
+				throw new CompileError(
+					"Object spread operator requires specified objectAssign option with 'Object.assign' or polyfill helper.",
+					this
+				);
+			}
+			// enclose run of non-spread properties in curlies
+			let i = this.properties.length;
+			if (regularPropertyCount && !computedPropertyCount) {
+				while (i--) {
+					const prop = this.properties[i];
+
+					if (prop.type === 'Property' && !prop.computed) {
+						const lastProp = this.properties[i - 1];
+						const nextProp = this.properties[i + 1];
+
+						if (
+							!lastProp ||
+							lastProp.type !== 'Property' ||
+							lastProp.computed
+						) {
+							code.prependRight(prop.start, '{');
+						}
+
+						if (
+							!nextProp ||
+							nextProp.type !== 'Property' ||
+							nextProp.computed
+						) {
+							code.appendLeft(prop.end, '}');
+						}
+					}
+				}
+			}
+
+			// wrap the whole thing in Object.assign
+			firstPropertyStart = this.properties[0].start;
+			if (!computedPropertyCount) {
+				code.overwrite(
+					this.start,
+					firstPropertyStart,
+					`${this.program.options.objectAssign}({}, `
+				);
+				code.overwrite(
+					this.properties[this.properties.length - 1].end,
+					this.end,
+					')'
+				);
+			} else if (this.properties[0].type === 'SpreadElement') {
+				code.overwrite(
+					this.start,
+					firstPropertyStart,
+					`${this.program.options.objectAssign}({}, `
+				);
+				code.remove(this.end - 1, this.end);
+				code.appendRight(this.end, ')');
+			} else {
+				code.prependLeft(this.start, `${this.program.options.objectAssign}(`);
+				code.appendRight(this.end, ')');
+			}
+		}
+
+		if (computedPropertyCount && transforms.computedProperty) {
+			const i0 = this.getIndentation();
+
+			let isSimpleAssignment;
+			let name;
+
+			if (
+				this.parent.type === 'VariableDeclarator' &&
+				this.parent.parent.declarations.length === 1 &&
+				this.parent.id.type === 'Identifier'
+			) {
+				isSimpleAssignment = true;
+				name = this.parent.id.alias || this.parent.id.name; // TODO is this right?
+			} else if (
+				this.parent.type === 'AssignmentExpression' &&
+				this.parent.parent.type === 'ExpressionStatement' &&
+				this.parent.left.type === 'Identifier'
+			) {
+				isSimpleAssignment = true;
+				name = this.parent.left.alias || this.parent.left.name; // TODO is this right?
+			} else if (
+				this.parent.type === 'AssignmentPattern' &&
+				this.parent.left.type === 'Identifier'
+			) {
+				isSimpleAssignment = true;
+				name = this.parent.left.alias || this.parent.left.name; // TODO is this right?
+			}
+
+			if (spreadPropertyCount) isSimpleAssignment = false;
+
+			// handle block scoping
+			name = this.findScope(false).resolveName(name);
+
+			const start = firstPropertyStart;
+			const end = this.end;
+
+			if (isSimpleAssignment) {
+				// ???
+			} else {
+				if (
+					firstSpreadProperty === null ||
+					firstComputedProperty < firstSpreadProperty
+				) {
+					name = this.findScope(true).createDeclaration('obj');
+
+					code.prependRight(this.start, `( ${name} = `);
+				} else name = null; // We don't actually need this variable
+			}
+
+			const len = this.properties.length;
+			let lastComputedProp;
+			let sawNonComputedProperty = false;
+			let isFirst = true;
+
+			for (let i = 0; i < len; i += 1) {
+				const prop = this.properties[i];
+				let moveStart = i > 0 ? this.properties[i - 1].end : start;
+
+				if (
+					prop.type === 'Property' &&
+					(prop.computed || (lastComputedProp && !spreadPropertyCount))
+				) {
+					if (i === 0) moveStart = this.start + 1; // Trim leading whitespace
+					lastComputedProp = prop;
+
+					if (!name) {
+						name = this.findScope(true).createDeclaration('obj');
+
+						const propId = name + (prop.computed ? '' : '.');
+						code.appendRight(prop.start, `( ${name} = {}, ${propId}`);
+					} else {
+						const propId =
+							(isSimpleAssignment ? `;\n${i0}${name}` : `, ${name}`) +
+							(prop.key.type === 'Literal' || prop.computed ? '' : '.');
+
+						if (moveStart < prop.start) {
+							code.overwrite(moveStart, prop.start, propId);
+						} else {
+							code.prependRight(prop.start, propId);
+						}
+					}
+
+					let c = prop.key.end;
+					if (prop.computed) {
+						while (code.original[c] !== ']') c += 1;
+						c += 1;
+					}
+					if (prop.key.type === 'Literal' && !prop.computed) {
+						code.overwrite(
+							prop.start,
+							prop.key.end + 1,
+							'[' + code.slice(prop.start, prop.key.end) + '] = '
+						);
+					} else if (prop.shorthand || (prop.method && !prop.computed && transforms.conciseMethodProperty)) {
+						// Replace : with = if Property::transpile inserted the :
+						code.overwrite(
+							prop.key.start,
+							prop.key.end,
+							code.slice(prop.key.start, prop.key.end).replace(/:/, ' =')
+						);
+					} else {
+						if (prop.value.start > c) code.remove(c, prop.value.start);
+						code.prependLeft(c, ' = ');
+					}
+
+					// This duplicates behavior from Property::transpile which is disabled
+					// for computed properties or if conciseMethodProperty is false
+					if (prop.method && (prop.computed || !transforms.conciseMethodProperty)) {
+						if (prop.value.generator) code.remove(prop.start, prop.key.start);
+						code.prependRight(prop.value.start, `function${prop.value.generator ? '*' : ''} `);
+					}
+				} else if (prop.type === 'SpreadElement') {
+					if (name && i > 0) {
+						if (!lastComputedProp) {
+							lastComputedProp = this.properties[i - 1];
+						}
+						code.appendLeft(lastComputedProp.end, `, ${name} )`);
+
+						lastComputedProp = null;
+						name = null;
+					}
+				} else {
+					if (!isFirst && spreadPropertyCount) {
+						// We are in an Object.assign context, so we need to wrap regular properties
+						code.prependRight(prop.start, '{');
+						code.appendLeft(prop.end, '}');
+					}
+					sawNonComputedProperty = true;
+				}
+				if (isFirst && (prop.type === 'SpreadElement' || prop.computed)) {
+					let beginEnd = sawNonComputedProperty
+						? this.properties[this.properties.length - 1].end
+						: this.end - 1;
+					// Trim trailing comma because it can easily become a leading comma which is illegal
+					if (code.original[beginEnd] == ',') ++beginEnd;
+					const closing = code.slice(beginEnd, end);
+					code.prependLeft(moveStart, closing);
+					code.remove(beginEnd, end);
+					isFirst = false;
+				}
+
+				// Clean up some extranous whitespace
+				let c = prop.end;
+				if (i < len - 1 && !sawNonComputedProperty) {
+					while (code.original[c] !== ',') c += 1;
+				} else if (i == len - 1) c = this.end;
+				code.remove(prop.end, c);
+			}
+
+			// special case
+			if (computedPropertyCount === len) {
+				code.remove(this.properties[len - 1].end, this.end - 1);
+			}
+
+			if (!isSimpleAssignment && name) {
+				code.appendLeft(lastComputedProp.end, `, ${name} )`);
+			}
+		}
+	}
+}

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

@@ -0,0 +1,52 @@
+import Node from '../Node.js';
+import reserved from '../../utils/reserved.js';
+
+export default class Property extends Node {
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+
+		if (
+			transforms.conciseMethodProperty &&
+			!this.computed &&
+			this.parent.type !== 'ObjectPattern'
+		) {
+			if (this.shorthand) {
+				code.prependRight(this.start, `${this.key.name}: `);
+			} else if (this.method) {
+				let name = '';
+				if (this.program.options.namedFunctionExpressions !== false) {
+					if (
+						this.key.type === 'Literal' &&
+						typeof this.key.value === 'number'
+					) {
+						name = '';
+					} else if (this.key.type === 'Identifier') {
+						if (
+							reserved[this.key.name] ||
+							!/^[a-z_$][a-z0-9_$]*$/i.test(this.key.name) ||
+							this.value.body.scope.references[this.key.name]
+						) {
+							name = this.findScope(true).createIdentifier(this.key.name);
+						} else {
+							name = this.key.name;
+						}
+					} else {
+						name = this.findScope(true).createIdentifier(this.key.value);
+					}
+					name = ' ' + name;
+				}
+
+				if (this.value.generator) code.remove(this.start, this.key.start);
+				code.appendLeft(
+					this.key.end,
+					`: function${this.value.generator ? '*' : ''}${name}`
+				);
+			}
+		}
+
+		if (transforms.reservedProperties && reserved[this.key.name]) {
+			code.prependRight(this.key.start, `'`);
+			code.appendLeft(this.key.end, `'`);
+		}
+	}
+}

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

@@ -0,0 +1,32 @@
+import Node from '../Node.js';
+import { loopStatement } from '../../utils/patterns.js';
+
+export default class ReturnStatement extends Node {
+	initialise(transforms) {
+		this.loop = this.findNearest(loopStatement);
+		this.nearestFunction = this.findNearest(/Function/);
+
+		if (
+			this.loop &&
+			(!this.nearestFunction || this.loop.depth > this.nearestFunction.depth)
+		) {
+			this.loop.canReturn = true;
+			this.shouldWrap = true;
+		}
+
+		if (this.argument) this.argument.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		const shouldWrap =
+			this.shouldWrap && this.loop && this.loop.shouldRewriteAsFunction;
+
+		if (this.argument) {
+			if (shouldWrap) code.prependRight(this.argument.start, `{ v: `);
+			this.argument.transpile(code, transforms);
+			if (shouldWrap) code.appendLeft(this.argument.end, ` }`);
+		} else if (shouldWrap) {
+			code.appendLeft(this.start + 6, ' {}');
+		}
+	}
+}

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

@@ -0,0 +1,12 @@
+import Node from '../Node.js';
+
+export default class SpreadElement extends Node {
+	transpile(code, transforms) {
+		if (this.parent.type == 'ObjectExpression') {
+			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/Super.js

@@ -0,0 +1,88 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+import { loopStatement } from '../../utils/patterns.js';
+
+export default class Super extends Node {
+	initialise(transforms) {
+		if (transforms.classes) {
+			this.method = this.findNearest('MethodDefinition');
+			if (!this.method)
+				throw new CompileError('use of super outside class method', this);
+
+			const parentClass = this.findNearest('ClassBody').parent;
+			this.superClassName =
+				parentClass.superClass && (parentClass.superClass.name || 'superclass');
+
+			if (!this.superClassName)
+				throw new CompileError('super used in base class', this);
+
+			this.isCalled =
+				this.parent.type === 'CallExpression' && this === this.parent.callee;
+
+			if (this.method.kind !== 'constructor' && this.isCalled) {
+				throw new CompileError(
+					'super() not allowed outside class constructor',
+					this
+				);
+			}
+
+			this.isMember = this.parent.type === 'MemberExpression';
+
+			if (!this.isCalled && !this.isMember) {
+				throw new CompileError(
+					'Unexpected use of `super` (expected `super(...)` or `super.*`)',
+					this
+				);
+			}
+		}
+
+		if (transforms.arrow) {
+			const lexicalBoundary = this.findLexicalBoundary();
+			const arrowFunction = this.findNearest('ArrowFunctionExpression');
+			const loop = this.findNearest(loopStatement);
+
+			if (arrowFunction && arrowFunction.depth > lexicalBoundary.depth) {
+				this.thisAlias = lexicalBoundary.getThisAlias();
+			}
+
+			if (
+				loop &&
+				loop.body.contains(this) &&
+				loop.depth > lexicalBoundary.depth
+			) {
+				this.thisAlias = lexicalBoundary.getThisAlias();
+			}
+		}
+	}
+
+	transpile(code, transforms) {
+		if (transforms.classes) {
+			const expression =
+				this.isCalled || this.method.static
+					? this.superClassName
+					: `${this.superClassName}.prototype`;
+
+			code.overwrite(this.start, this.end, expression, {
+				storeName: true,
+				contentOnly: true
+			});
+
+			const callExpression = this.isCalled ? this.parent : this.parent.parent;
+
+			if (callExpression && callExpression.type === 'CallExpression') {
+				if (!this.noCall) {
+					// special case – `super( ...args )`
+					code.appendLeft(callExpression.callee.end, '.call');
+				}
+
+				const thisAlias = this.thisAlias || 'this';
+
+				if (callExpression.arguments.length) {
+					code.appendLeft(callExpression.arguments[0].start, `${thisAlias}, `);
+				} else {
+					code.appendLeft(callExpression.end - 1, `${thisAlias}`);
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,63 @@
+import Node from '../Node.js';
+import CompileError from '../../utils/CompileError.js';
+
+export default class TaggedTemplateExpression extends Node {
+	initialise(transforms) {
+		if (
+			transforms.templateString &&
+			!transforms.dangerousTaggedTemplateString
+		) {
+			throw new CompileError(
+				"Tagged template strings are not supported. Use `transforms: { templateString: false }` to skip transformation and disable this error, or `transforms: { dangerousTaggedTemplateString: true }` if you know what you're doing",
+				this
+			);
+		}
+
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		if (transforms.templateString && transforms.dangerousTaggedTemplateString) {
+			const ordered = this.quasi.expressions
+				.concat(this.quasi.quasis)
+				.sort((a, b) => a.start - b.start);
+
+			const program = this.program;
+			const rootScope = program.body.scope;
+
+			// insert strings at start
+			const templateStrings = this.quasi.quasis.map(quasi =>
+				JSON.stringify(quasi.value.cooked)
+			).join(', ');
+
+			let templateObject = this.program.templateLiteralQuasis[templateStrings];
+			if (!templateObject) {
+				templateObject = rootScope.createIdentifier('templateObject');
+				code.prependRight(this.program.prependAt, `var ${templateObject} = Object.freeze([${templateStrings}]);\n`);
+
+				this.program.templateLiteralQuasis[templateStrings] = templateObject;
+			}
+
+			code.overwrite(
+				this.tag.end,
+				ordered[0].start,
+				`(${templateObject}`
+			);
+
+			let lastIndex = ordered[0].start;
+			ordered.forEach(node => {
+				if (node.type === 'TemplateElement') {
+					code.remove(lastIndex, node.end);
+				} else {
+					code.overwrite(lastIndex, node.start, ', ');
+				}
+
+				lastIndex = node.end;
+			});
+
+			code.overwrite(lastIndex, this.end, ')');
+		}
+
+		super.transpile(code, transforms);
+	}
+}