jass 0.9.1

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

@@ -0,0 +1,112 @@
+// used for debugging, without the noise created by
+// circular references
+function toJSON(node) {
+	var obj = {};
+
+	Object.keys(node).forEach(key => {
+		if (
+			key === 'parent' ||
+			key === 'program' ||
+			key === 'keys' ||
+			key === '__wrapped'
+		)
+			return;
+
+		if (Array.isArray(node[key])) {
+			obj[key] = node[key].map(toJSON);
+		} else if (node[key] && node[key].toJSON) {
+			obj[key] = node[key].toJSON();
+		} else {
+			obj[key] = node[key];
+		}
+	});
+
+	return obj;
+}
+
+export default class Node {
+	ancestor(level) {
+		let node = this;
+		while (level--) {
+			node = node.parent;
+			if (!node) return null;
+		}
+
+		return node;
+	}
+
+	contains(node) {
+		while (node) {
+			if (node === this) return true;
+			node = node.parent;
+		}
+
+		return false;
+	}
+
+	findLexicalBoundary() {
+		return this.parent.findLexicalBoundary();
+	}
+
+	findNearest(type) {
+		if (typeof type === 'string') type = new RegExp(`^${type}$`);
+		if (type.test(this.type)) return this;
+		return this.parent.findNearest(type);
+	}
+
+	unparenthesizedParent() {
+		let node = this.parent;
+		while (node && node.type === 'ParenthesizedExpression') {
+			node = node.parent;
+		}
+		return node;
+	}
+
+	unparenthesize() {
+		let node = this;
+		while (node.type === 'ParenthesizedExpression') {
+			node = node.expression;
+		}
+		return node;
+	}
+
+	findScope(functionScope) {
+		return this.parent.findScope(functionScope);
+	}
+
+	getIndentation() {
+		return this.parent.getIndentation();
+	}
+
+	initialise(transforms) {
+		for (var key of this.keys) {
+			const value = this[key];
+
+			if (Array.isArray(value)) {
+				value.forEach(node => node && node.initialise(transforms));
+			} else if (value && typeof value === 'object') {
+				value.initialise(transforms);
+			}
+		}
+	}
+
+	toJSON() {
+		return toJSON(this);
+	}
+
+	toString() {
+		return this.program.magicString.original.slice(this.start, this.end);
+	}
+
+	transpile(code, transforms) {
+		for (const key of this.keys) {
+			const value = this[key];
+
+			if (Array.isArray(value)) {
+				value.forEach(node => node && node.transpile(code, transforms));
+			} else if (value && typeof value === 'object') {
+				value.transpile(code, transforms);
+			}
+		}
+	}
+}

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

@@ -0,0 +1,74 @@
+import MagicString from 'magic-string';
+import BlockStatement from './BlockStatement.js';
+import wrap from './wrap.js';
+
+export default function Program(source, ast, transforms, options) {
+	this.type = 'Root';
+
+	// options
+	this.jsx = options.jsx || 'React.createElement';
+	this.options = options;
+
+	this.source = source;
+	this.magicString = new MagicString(source);
+
+	this.ast = ast;
+	this.depth = 0;
+
+	wrap((this.body = ast), this);
+	this.body.__proto__ = BlockStatement.prototype;
+
+	this.templateLiteralQuasis = Object.create(null);
+	for (let i = 0; i < this.body.body.length; ++i) {
+		if (!this.body.body[i].directive) {
+			this.prependAt = this.body.body[i].start;
+			break;
+		}
+	}
+	this.objectWithoutPropertiesHelper = null;
+
+	this.indentExclusionElements = [];
+	this.body.initialise(transforms);
+
+	this.indentExclusions = Object.create(null);
+	for (const node of this.indentExclusionElements) {
+		for (let i = node.start; i < node.end; i += 1) {
+			this.indentExclusions[i] = true;
+		}
+	}
+
+	this.body.transpile(this.magicString, transforms);
+}
+
+Program.prototype = {
+	export(options = {}) {
+		return {
+			code: this.magicString.toString(),
+			map: this.magicString.generateMap({
+				file: options.file,
+				source: options.source,
+				includeContent: options.includeContent !== false
+			})
+		};
+	},
+
+	findNearest() {
+		return null;
+	},
+
+	findScope() {
+		return null;
+	},
+
+	getObjectWithoutPropertiesHelper(code) {
+		if (!this.objectWithoutPropertiesHelper) {
+			this.objectWithoutPropertiesHelper = this.body.scope.createIdentifier('objectWithoutProperties');
+			code.prependLeft(this.prependAt, `function ${this.objectWithoutPropertiesHelper} (obj, exclude) { ` +
+				`var target = {}; for (var k in obj) ` +
+				`if (Object.prototype.hasOwnProperty.call(obj, k) && exclude.indexOf(k) === -1) ` +
+				`target[k] = obj[k]; return target; }\n`
+			);
+		}
+		return this.objectWithoutPropertiesHelper;
+	}
+};

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

@@ -0,0 +1,116 @@
+import extractNames from './extractNames.js';
+import reserved from '../utils/reserved.js';
+
+export default function Scope(options) {
+	options = options || {};
+
+	this.parent = options.parent;
+	this.isBlockScope = !!options.block;
+	this.createDeclarationCallback = options.declare;
+
+	let scope = this;
+	while (scope.isBlockScope) scope = scope.parent;
+	this.functionScope = scope;
+
+	this.identifiers = [];
+	this.declarations = Object.create(null);
+	this.references = Object.create(null);
+	this.blockScopedDeclarations = this.isBlockScope ? null : Object.create(null);
+	this.aliases = Object.create(null);
+}
+
+Scope.prototype = {
+	addDeclaration(node, kind) {
+		for (const identifier of extractNames(node)) {
+			const name = identifier.name;
+
+			const declaration = { name, node: identifier, kind, instances: [] };
+			this.declarations[name] = declaration;
+
+			if (this.isBlockScope) {
+				if (!this.functionScope.blockScopedDeclarations[name])
+					this.functionScope.blockScopedDeclarations[name] = [];
+				this.functionScope.blockScopedDeclarations[name].push(declaration);
+			}
+		}
+	},
+
+	addReference(identifier) {
+		if (this.consolidated) {
+			this.consolidateReference(identifier);
+		} else {
+			this.identifiers.push(identifier);
+		}
+	},
+
+	consolidate() {
+		for (let i = 0; i < this.identifiers.length; i += 1) {
+			// we might push to the array during consolidation, so don't cache length
+			const identifier = this.identifiers[i];
+			this.consolidateReference(identifier);
+		}
+
+		this.consolidated = true; // TODO understand why this is necessary... seems bad
+	},
+
+	consolidateReference(identifier) {
+		const declaration = this.declarations[identifier.name];
+		if (declaration) {
+			declaration.instances.push(identifier);
+		} else {
+			this.references[identifier.name] = true;
+			if (this.parent) this.parent.addReference(identifier);
+		}
+	},
+
+	contains(name) {
+		return (
+			this.declarations[name] ||
+			(this.parent ? this.parent.contains(name) : false)
+		);
+	},
+
+	createIdentifier(base) {
+		if (typeof base === 'number') base = base.toString();
+
+		base = base
+			.replace(/\s/g, '')
+			.replace(/\[([^\]]+)\]/g, '_$1')
+			.replace(/[^a-zA-Z0-9_$]/g, '_')
+			.replace(/_{2,}/, '_');
+
+		let name = base;
+		let counter = 1;
+
+		while (
+			this.declarations[name] ||
+			this.references[name] ||
+			this.aliases[name] ||
+			name in reserved
+		) {
+			name = `${base}$${counter++}`;
+		}
+
+		this.aliases[name] = true;
+		return name;
+	},
+
+	createDeclaration(base) {
+		const id = this.createIdentifier(base);
+		this.createDeclarationCallback(id);
+		return id;
+	},
+
+	findDeclaration(name) {
+		return (
+			this.declarations[name] ||
+			(this.parent && this.parent.findDeclaration(name))
+		);
+	},
+
+	// Sometimes, block scope declarations change name during transpilation
+	resolveName(name) {
+		const declaration = this.findDeclaration(name);
+		return declaration ? declaration.name : name;
+	}
+};

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

@@ -0,0 +1,35 @@
+export default function extractNames(node) {
+	const names = [];
+	extractors[node.type](names, node);
+	return names;
+}
+
+const extractors = {
+	Identifier(names, node) {
+		names.push(node);
+	},
+
+	ObjectPattern(names, node) {
+		for (const prop of node.properties) {
+			extractors[prop.type](names, prop);
+		}
+	},
+
+	Property(names, node) {
+		extractors[node.value.type](names, node.value);
+	},
+
+	ArrayPattern(names, node) {
+		for (const element of node.elements) {
+			if (element) extractors[element.type](names, element);
+		}
+	},
+
+	RestElement(names, node) {
+		extractors[node.argument.type](names, node.argument);
+	},
+
+	AssignmentPattern(names, node) {
+		extractors[node.left.type](names, node.left);
+	}
+};

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

@@ -0,0 +1,4 @@
+export default {
+	Program: ['body'],
+	Literal: []
+};

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

@@ -0,0 +1,70 @@
+import Node from '../Node.js';
+import spread, { isArguments } from '../../utils/spread.js';
+
+export default class ArrayExpression extends Node {
+	initialise(transforms) {
+		if (transforms.spreadRest && this.elements.length) {
+			const lexicalBoundary = this.findLexicalBoundary();
+
+			let i = this.elements.length;
+			while (i--) {
+				const element = this.elements[i];
+				if (
+					element &&
+					element.type === 'SpreadElement' &&
+					isArguments(element.argument)
+				) {
+					this.argumentsArrayAlias = lexicalBoundary.getArgumentsArrayAlias();
+				}
+			}
+		}
+
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		super.transpile(code, transforms);
+
+		if (transforms.spreadRest) {
+			// erase trailing comma after last array element if not an array hole
+			if (this.elements.length) {
+				let lastElement = this.elements[this.elements.length - 1];
+				if (
+					lastElement &&
+					/\s*,/.test(code.original.slice(lastElement.end, this.end))
+				) {
+					code.overwrite(lastElement.end, this.end - 1, ' ');
+				}
+			}
+
+			if (this.elements.length === 1) {
+				const element = this.elements[0];
+
+				if (element && element.type === 'SpreadElement') {
+					// special case – [ ...arguments ]
+					if (isArguments(element.argument)) {
+						code.overwrite(
+							this.start,
+							this.end,
+							`[].concat( ${this.argumentsArrayAlias} )`
+						); // TODO if this is the only use of argsArray, don't bother concating
+					} else {
+						code.overwrite(this.start, element.argument.start, '[].concat( ');
+						code.overwrite(element.end, this.end, ' )');
+					}
+				}
+			} else {
+				const hasSpreadElements = spread(
+					code,
+					this.elements,
+					this.start,
+					this.argumentsArrayAlias
+				);
+
+				if (hasSpreadElements) {
+					code.overwrite(this.end - 1, this.end, ')');
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,52 @@
+import Node from '../Node.js';
+import removeTrailingComma from '../../utils/removeTrailingComma.js';
+
+export default class ArrowFunctionExpression extends Node {
+	initialise(transforms) {
+		this.body.createScope();
+		super.initialise(transforms);
+	}
+
+	transpile(code, transforms) {
+		const naked = this.params.length === 1 && this.start === this.params[0].start;
+
+		if (transforms.arrow || this.needsArguments(transforms)) {
+			// remove arrow
+			let charIndex = this.body.start;
+			while (code.original[charIndex] !== '=') {
+				charIndex -= 1;
+			}
+			code.remove(charIndex, this.body.start);
+
+			super.transpile(code, transforms);
+
+			// wrap naked parameter
+			if (naked) {
+				code.prependRight(this.params[0].start, '(');
+				code.appendLeft(this.params[0].end, ')');
+			}
+
+			// add function
+			if (this.parent && this.parent.type === 'ExpressionStatement') {
+				// standalone expression statement
+				code.prependRight(this.start, '!function');
+			} else {
+				code.prependRight(this.start, 'function ');
+			}
+		} else {
+			super.transpile(code, transforms);
+		}
+
+		if (transforms.trailingFunctionCommas && this.params.length && !naked) {
+			removeTrailingComma(code, this.params[this.params.length - 1].end);
+		}
+	}
+
+	// Returns whether any transforms that will happen use `arguments`
+	needsArguments(transforms) {
+		return (
+			transforms.spreadRest &&
+			this.params.filter(param => param.type === 'RestElement').length > 0
+		);
+	}
+}