jass 0.9.1

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

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

data/vendor/node_modules/buble/src/program/wrap.js

@@ -0,0 +1,68 @@
+import types from './types/index.js';
+import BlockStatement from './BlockStatement.js';
+import Node from './Node.js';
+import keys from './keys.js';
+
+const statementsWithBlocks = {
+	IfStatement: 'consequent',
+	ForStatement: 'body',
+	ForInStatement: 'body',
+	ForOfStatement: 'body',
+	WhileStatement: 'body',
+	DoWhileStatement: 'body',
+	ArrowFunctionExpression: 'body'
+};
+
+export default function wrap(raw, parent) {
+	if (!raw) return;
+
+	if ('length' in raw) {
+		let i = raw.length;
+		while (i--) wrap(raw[i], parent);
+		return;
+	}
+
+	// with e.g. shorthand properties, key and value are
+	// the same node. We don't want to wrap an object twice
+	if (raw.__wrapped) return;
+	raw.__wrapped = true;
+
+	if (!keys[raw.type]) {
+		keys[raw.type] = Object.keys(raw).filter(
+			key => typeof raw[key] === 'object'
+		);
+	}
+
+	// special case – body-less if/for/while statements. TODO others?
+	const bodyType = statementsWithBlocks[raw.type];
+	if (bodyType && raw[bodyType].type !== 'BlockStatement') {
+		const expression = raw[bodyType];
+
+		// create a synthetic block statement, otherwise all hell
+		// breaks loose when it comes to block scoping
+		raw[bodyType] = {
+			start: expression.start,
+			end: expression.end,
+			type: 'BlockStatement',
+			body: [expression],
+			synthetic: true
+		};
+	}
+
+	raw.parent = parent;
+	raw.program = parent.program || parent;
+	raw.depth = parent.depth + 1;
+	raw.keys = keys[raw.type];
+	raw.indentation = undefined;
+
+	for (const key of keys[raw.type]) {
+		wrap(raw[key], raw);
+	}
+
+	raw.program.magicString.addSourcemapLocation(raw.start);
+	raw.program.magicString.addSourcemapLocation(raw.end);
+
+	const type =
+		(raw.type === 'BlockStatement' ? BlockStatement : types[raw.type]) || Node;
+	raw.__proto__ = type.prototype;
+}

data/vendor/node_modules/buble/src/support.js

@@ -0,0 +1,97 @@
+export const matrix = {
+	chrome: {
+		    48: 0b01001010100011001101,
+		    49: 0b01001111100111111111,
+		    50: 0b01011111100111111111,
+		    51: 0b01011111100111111111,
+		    52: 0b01111111100111111111,
+		    53: 0b01111111100111111111,
+		    54: 0b01111111100111111111,
+		    55: 0b01111111100111111111,
+		    56: 0b01111111100111111111,
+		    57: 0b01111111100111111111,
+		    58: 0b11111111100111111111,
+		    59: 0b11111111100111111111,
+		    60: 0b11111111100111111111,
+		    61: 0b11111111100111111111,
+		    62: 0b11111111100111111111,
+		    63: 0b11111111100111111111
+	},
+	firefox: {
+		    43: 0b01001111100011011101,
+		    44: 0b01001111100111011101,
+		    45: 0b01001111100111011111,
+		    46: 0b01011111100111011111,
+		    47: 0b01011111100111111111,
+		    48: 0b01011111100111111111,
+		    49: 0b01011110100111111111,
+		    50: 0b01011110100111111111,
+		    51: 0b01011110100111111111,
+		    52: 0b11111111100111111111,
+		    53: 0b11111111100111111111,
+		    54: 0b11111111100111111111,
+		    55: 0b11111111100111111111,
+		    56: 0b11111111100111111111,
+		    57: 0b11111111100111111111,
+		    58: 0b11111111100111111111
+	},
+	safari: {
+		     8: 0b01000000000000000100,
+		     9: 0b01001001100001101110,
+		    10: 0b11011111100111111111,
+		'10.1': 0b11111111100111111111,
+		    11: 0b11111111100111111111
+	},
+	ie: {
+		     8: 0b00000000000000000000,
+		     9: 0b01000000000000000000,
+		    10: 0b01000000000000000000,
+		    11: 0b01000000000100000000
+	},
+	edge: {
+		    12: 0b01001010100101001101,
+		    13: 0b01011110100111001111,
+		    14: 0b11111110100111111111,
+		    15: 0b11111110100111111111,
+		    16: 0b11111110100111111111
+	},
+	node: {
+		'0.10': 0b01000000000000000000,
+		'0.12': 0b01000000000001000000,
+		     4: 0b01001000100011001111,
+		     5: 0b01001000100011001111,
+		     6: 0b01011111100111111111,
+		     8: 0b11111111100111111111,
+		 '8.3': 0b11111111100111111111,
+		 '8.7': 0b11111111100111111111
+	}
+};
+
+export const features = [
+	'arrow',
+	'classes',
+	'computedProperty',
+	'conciseMethodProperty',
+	'defaultParameter',
+	'destructuring',
+	'forOf',
+	'generator',
+	'letConst',
+	'moduleExport',
+	'moduleImport',
+	'numericLiteral',
+	'parameterDestructuring',
+	'spreadRest',
+	'stickyRegExp',
+	'templateString',
+	'unicodeRegExp',
+
+	// ES2016
+	'exponentiation',
+
+	// additional transforms, not from
+	// https://featuretests.io
+	'reservedProperties',
+
+	'trailingFunctionCommas'
+];

data/vendor/node_modules/buble/src/utils/CompileError.js

@@ -0,0 +1,30 @@
+import locate from './locate.js';
+import getSnippet from './getSnippet.js';
+
+export default class CompileError extends Error {
+	constructor(message, node) {
+		super(message);
+
+		this.name = 'CompileError';
+		if (!node) {
+			return;
+		}
+
+		const source = node.program.magicString.original;
+		const loc = locate(source, node.start);
+
+		this.message = message + ` (${loc.line}:${loc.column})`;
+
+		this.stack = new Error().stack.replace(
+			new RegExp(`.+new ${this.name}.+\\n`, 'm'),
+			''
+		);
+
+		this.loc = loc;
+		this.snippet = getSnippet(source, loc, node.end - node.start);
+	}
+
+	toString() {
+		return `${this.name}: ${this.message}\n${this.snippet}`;
+	}
+}

data/vendor/node_modules/buble/src/utils/array.js

@@ -0,0 +1,11 @@
+export function findIndex(array, fn) {
+	for (let i = 0; i < array.length; i += 1) {
+		if (fn(array[i], i)) return i;
+	}
+
+	return -1;
+}
+
+export function find(array, fn) {
+	return array[findIndex(array, fn)];
+}

data/vendor/node_modules/buble/src/utils/checkConst.js

@@ -0,0 +1,8 @@
+import CompileError from './CompileError.js';
+
+export default function checkConst(identifier, scope) {
+	const declaration = scope.findDeclaration(identifier.name);
+	if (declaration && declaration.kind === 'const') {
+		throw new CompileError(`${identifier.name} is read-only`, identifier);
+	}
+}

data/vendor/node_modules/buble/src/utils/deindent.js

@@ -0,0 +1,30 @@
+// TODO this function is slightly flawed – it works on the original string,
+// not its current edited state.
+// That's not a problem for the way that it's currently used, but it could
+// be in future...
+export default function deindent(node, code) {
+	const start = node.start;
+	const end = node.end;
+
+	const indentStr = code.getIndentString();
+	const indentStrLen = indentStr.length;
+	const indentStart = start - indentStrLen;
+
+	if (
+		!node.program.indentExclusions[indentStart] &&
+		code.original.slice(indentStart, start) === indentStr
+	) {
+		code.remove(indentStart, start);
+	}
+
+	const pattern = new RegExp(indentStr + '\\S', 'g');
+	const slice = code.original.slice(start, end);
+	let match;
+
+	while ((match = pattern.exec(slice))) {
+		const removeStart = start + match.index;
+		if (!node.program.indentExclusions[removeStart]) {
+			code.remove(removeStart, removeStart + indentStrLen);
+		}
+	}
+}

data/vendor/node_modules/buble/src/utils/destructure.js

@@ -0,0 +1,377 @@
+import CompileError from '../utils/CompileError.js';
+import { findIndex } from './array.js';
+
+const handlers = {
+	Identifier: destructureIdentifier,
+	AssignmentPattern: destructureAssignmentPattern,
+	ArrayPattern: destructureArrayPattern,
+	ObjectPattern: destructureObjectPattern
+};
+
+export default function destructure(
+	code,
+	createIdentifier,
+	resolveName,
+	node,
+	ref,
+	inline,
+	statementGenerators
+) {
+	handlers[node.type](code, createIdentifier, resolveName, node, ref, inline, statementGenerators);
+}
+
+function destructureIdentifier(
+	code,
+	createIdentifier,
+	resolveName,
+	node,
+	ref,
+	inline,
+	statementGenerators
+) {
+	statementGenerators.push((start, prefix, suffix) => {
+		code.overwrite(node.start, node.end, (inline ? prefix : `${prefix}var `) + resolveName(node) + ` = ${ref}${suffix}`);
+		code.move(node.start, node.end, start);
+	});
+}
+
+function destructureMemberExpression(
+	code,
+	createIdentifier,
+	resolveName,
+	node,
+	ref,
+	inline,
+	statementGenerators
+) {
+	statementGenerators.push((start, prefix, suffix) => {
+		code.prependRight(node.start, inline ? prefix : `${prefix}var `);
+		code.appendLeft(node.end, ` = ${ref}${suffix}`);
+		code.move(node.start, node.end, start);
+	});
+}
+
+function destructureAssignmentPattern(
+	code,
+	createIdentifier,
+	resolveName,
+	node,
+	ref,
+	inline,
+	statementGenerators
+) {
+	const isIdentifier = node.left.type === 'Identifier';
+	const name = isIdentifier ? node.left.name : ref;
+
+	if (!inline) {
+		statementGenerators.push((start, prefix, suffix) => {
+			code.prependRight(
+				node.left.end,
+				`${prefix}if ( ${name} === void 0 ) ${name}`
+			);
+			code.move(node.left.end, node.right.end, start);
+			code.appendLeft(node.right.end, suffix);
+		});
+	}
+
+	if (!isIdentifier) {
+		destructure(code, createIdentifier, resolveName, node.left, ref, inline, statementGenerators);
+	}
+}
+
+function destructureArrayPattern(
+	code,
+	createIdentifier,
+	resolveName,
+	node,
+	ref,
+	inline,
+	statementGenerators
+) {
+	let c = node.start;
+
+	node.elements.forEach((element, i) => {
+		if (!element) return;
+
+		if (element.type === 'RestElement') {
+			handleProperty(
+				code,
+				createIdentifier,
+				resolveName,
+				c,
+				element.argument,
+				`${ref}.slice(${i})`,
+				inline,
+				statementGenerators
+			);
+		} else {
+			handleProperty(
+				code,
+				createIdentifier,
+				resolveName,
+				c,
+				element,
+				`${ref}[${i}]`,
+				inline,
+				statementGenerators
+			);
+		}
+		c = element.end;
+	});
+
+	code.remove(c, node.end);
+}
+
+function destructureObjectPattern(
+	code,
+	createIdentifier,
+	resolveName,
+	node,
+	ref,
+	inline,
+	statementGenerators
+) {
+	let c = node.start;
+
+	const nonRestKeys = [];
+	node.properties.forEach(prop => {
+		let value;
+		let content;
+		if (prop.type === 'Property') {
+			const isComputedKey = prop.computed || prop.key.type !== 'Identifier';
+			const key = isComputedKey
+				? code.slice(prop.key.start, prop.key.end)
+				: prop.key.name;
+			value = isComputedKey ? `${ref}[${key}]` : `${ref}.${key}`;
+			content = prop.value;
+			nonRestKeys.push(isComputedKey ? key : '"' + key + '"');
+		} else if (prop.type === 'RestElement') {
+			content = prop.argument;
+			value = createIdentifier('rest');
+			statementGenerators.push((start, prefix, suffix) => {
+				const helper = prop.program.getObjectWithoutPropertiesHelper(code);
+				code.overwrite(
+					prop.start,
+					(c = prop.argument.start),
+					(inline ? prefix : `${prefix}var `) + `${value} = ${helper}( ${ref}, [${nonRestKeys.join(', ')}] )${suffix}`
+				);
+				code.move(prop.start, c, start);
+			});
+		} else {
+			throw new CompileError(
+				this,
+				`Unexpected node of type ${prop.type} in object pattern`
+			);
+		}
+		handleProperty(code, createIdentifier, resolveName, c, content, value, inline, statementGenerators);
+		c = prop.end;
+	});
+
+	code.remove(c, node.end);
+}
+
+function handleProperty(
+	code,
+	createIdentifier,
+	resolveName,
+	c,
+	node,
+	value,
+	inline,
+	statementGenerators
+) {
+	switch (node.type) {
+		case 'Identifier': {
+			code.remove(c, node.start);
+			destructureIdentifier(
+				code,
+				createIdentifier,
+				resolveName,
+				node,
+				value,
+				inline,
+				statementGenerators
+			);
+			break;
+		}
+
+		case 'MemberExpression':
+			code.remove(c, node.start);
+			destructureMemberExpression(
+				code,
+				createIdentifier,
+				resolveName,
+				node,
+				value,
+				true,
+				statementGenerators
+			);
+			break;
+
+		case 'AssignmentPattern': {
+			let name;
+
+			const isIdentifier = node.left.type === 'Identifier';
+
+			if (isIdentifier) {
+				name = resolveName(node.left);
+			} else {
+				name = createIdentifier(value);
+			}
+
+			statementGenerators.push((start, prefix, suffix) => {
+				if (inline) {
+					code.prependRight(
+						node.right.start,
+						`${name} = ${value}, ${name} = ${name} === void 0 ? `
+					);
+					code.appendLeft(node.right.end, ` : ${name}${suffix}`);
+				} else {
+					code.prependRight(
+						node.right.start,
+						`${prefix}var ${name} = ${value}; if ( ${name} === void 0 ) ${name} = `
+					);
+					code.appendLeft(node.right.end, suffix);
+				}
+
+				code.move(node.right.start, node.right.end, start);
+			});
+
+			if (isIdentifier) {
+				code.remove(c, node.right.start);
+			} else {
+				code.remove(c, node.left.start);
+				code.remove(node.left.end, node.right.start);
+				handleProperty(
+					code,
+					createIdentifier,
+					resolveName,
+					c,
+					node.left,
+					name,
+					inline,
+					statementGenerators
+				);
+			}
+
+			break;
+		}
+
+		case 'ObjectPattern': {
+			code.remove(c, (c = node.start));
+
+			let ref = value;
+			if (node.properties.length > 1) {
+				ref = createIdentifier(value);
+
+				statementGenerators.push((start, prefix, suffix) => {
+					// this feels a tiny bit hacky, but we can't do a
+					// straightforward appendLeft and keep correct order...
+					code.prependRight(node.start, (inline ? '' : `${prefix}var `) + `${ref} = `);
+					code.overwrite(node.start, (c = node.start + 1), value);
+					code.appendLeft(c, suffix);
+
+					code.overwrite(
+						node.start,
+						(c = node.start + 1),
+						(inline ? '' : `${prefix}var `) + `${ref} = ${value}${suffix}`
+					);
+					code.move(node.start, c, start);
+				});
+			}
+
+			destructureObjectPattern(
+				code,
+				createIdentifier,
+				resolveName,
+				node,
+				ref,
+				inline,
+				statementGenerators
+			);
+
+			break;
+		}
+
+		case 'ArrayPattern': {
+			code.remove(c, (c = node.start));
+
+			if (node.elements.filter(Boolean).length > 1) {
+				const ref = createIdentifier(value);
+
+				statementGenerators.push((start, prefix, suffix) => {
+					code.prependRight(node.start, (inline ? '' : `${prefix}var `) + `${ref} = `);
+					code.overwrite(node.start, (c = node.start + 1), value, {
+						contentOnly: true
+					});
+					code.appendLeft(c, suffix);
+
+					code.move(node.start, c, start);
+				});
+
+				node.elements.forEach((element, i) => {
+					if (!element) return;
+
+					if (element.type === 'RestElement') {
+						handleProperty(
+							code,
+							createIdentifier,
+							resolveName,
+							c,
+							element.argument,
+							`${ref}.slice(${i})`,
+							inline,
+							statementGenerators
+						);
+					} else {
+						handleProperty(
+							code,
+							createIdentifier,
+							resolveName,
+							c,
+							element,
+							`${ref}[${i}]`,
+							inline,
+							statementGenerators
+						);
+					}
+					c = element.end;
+				});
+			} else {
+				const index = findIndex(node.elements, Boolean);
+				const element = node.elements[index];
+				if (element.type === 'RestElement') {
+					handleProperty(
+						code,
+						createIdentifier,
+						resolveName,
+						c,
+						element.argument,
+						`${value}.slice(${index})`,
+						inline,
+						statementGenerators
+					);
+				} else {
+					handleProperty(
+						code,
+						createIdentifier,
+						resolveName,
+						c,
+						element,
+						`${value}[${index}]`,
+						inline,
+						statementGenerators
+					);
+				}
+				c = element.end;
+			}
+
+			code.remove(c, node.end);
+			break;
+		}
+
+		default: {
+			throw new Error(`Unexpected node type in destructuring (${node.type})`);
+		}
+	}
+}