jass 0.9.1

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

@@ -0,0 +1,30 @@
+function pad(num, len) {
+	let result = String(num);
+	return result + repeat(' ', len - result.length);
+}
+
+function repeat(str, times) {
+	let result = '';
+	while (times--) result += str;
+	return result;
+}
+
+export default function getSnippet(source, loc, length = 1) {
+	const first = Math.max(loc.line - 5, 0);
+	const last = loc.line;
+
+	const numDigits = String(last).length;
+
+	const lines = source.split('\n').slice(first, last);
+
+	const lastLine = lines[lines.length - 1];
+	const offset = lastLine.slice(0, loc.column).replace(/\t/g, '  ').length;
+
+	let snippet = lines
+		.map((line, i) => `${pad(i + first + 1, numDigits)} : ${line.replace(/\t/g, '  ')}`)
+		.join('\n');
+
+	snippet += '\n' + repeat(' ', numDigits + 3 + offset) + repeat('^', length);
+
+	return snippet;
+}

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

@@ -0,0 +1,41 @@
+export default function isReference(node, parent) {
+	if (node.type === 'MemberExpression') {
+		return !node.computed && isReference(node.object, node);
+	}
+
+	if (node.type === 'Identifier') {
+		// the only time we could have an identifier node without a parent is
+		// if it's the entire body of a function without a block statement –
+		// i.e. an arrow function expression like `a => a`
+		if (!parent) return true;
+
+		if (/(Function|Class)Expression/.test(parent.type)) return false;
+
+		if (parent.type === 'VariableDeclarator') return node === parent.init;
+
+		// TODO is this right?
+		if (
+			parent.type === 'MemberExpression' ||
+			parent.type === 'MethodDefinition'
+		) {
+			return parent.computed || node === parent.object;
+		}
+
+		if (parent.type === 'ArrayPattern') return false;
+
+		// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+		if (parent.type === 'Property') {
+			if (parent.parent.type === 'ObjectPattern') return false;
+			return parent.computed || node === parent.value;
+		}
+
+		// disregard the `bar` in `class Foo { bar () {...} }`
+		if (parent.type === 'MethodDefinition') return false;
+
+		// disregard the `bar` in `export { foo as bar }`
+		if (parent.type === 'ExportSpecifier' && node !== parent.local)
+			return false;
+
+		return true;
+	}
+}

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

@@ -0,0 +1,20 @@
+export default function locate(source, index) {
+	var lines = source.split('\n');
+	var len = lines.length;
+
+	var lineStart = 0;
+	var i;
+
+	for (i = 0; i < len; i += 1) {
+		var line = lines[i];
+		var lineEnd = lineStart + line.length + 1; // +1 for newline
+
+		if (lineEnd > index) {
+			return { line: i + 1, column: index - lineStart, char: i };
+		}
+
+		lineStart = lineEnd;
+	}
+
+	throw new Error('Could not determine location of character');
+}

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

@@ -0,0 +1 @@
+export const loopStatement = /(?:For(?:In|Of)?|While)Statement/;

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

@@ -0,0 +1,13 @@
+export default function removeTrailingComma(code, c) {
+	while (code.original[c] !== ')') {
+		if (code.original[c] === ',') {
+			code.remove(c, c + 1);
+			return;
+		}
+
+		if (code.original[c] === '/') {
+			c = code.original.indexOf(code.original[c + 1] === '/' ? '\n' : '*/', c) + 1;
+		}
+		c += 1;
+	}
+}

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

@@ -0,0 +1,6 @@
+let reserved = Object.create(null);
+'do if in for let new try var case else enum eval null this true void with await break catch class const false super throw while yield delete export import public return static switch typeof default extends finally package private continue debugger function arguments interface protected implements instanceof'
+	.split(' ')
+	.forEach(word => (reserved[word] = true));
+
+export default reserved;

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

@@ -0,0 +1,70 @@
+export function isArguments(node) {
+	return node.type === 'Identifier' && node.name === 'arguments';
+}
+
+export default function spread(
+	code,
+	elements,
+	start,
+	argumentsArrayAlias,
+	isNew
+) {
+	let i = elements.length;
+	let firstSpreadIndex = -1;
+
+	while (i--) {
+		const element = elements[i];
+		if (element && element.type === 'SpreadElement') {
+			if (isArguments(element.argument)) {
+				code.overwrite(
+					element.argument.start,
+					element.argument.end,
+					argumentsArrayAlias
+				);
+			}
+
+			firstSpreadIndex = i;
+		}
+	}
+
+	if (firstSpreadIndex === -1) return false; // false indicates no spread elements
+
+	if (isNew) {
+		for (i = 0; i < elements.length; i += 1) {
+			let element = elements[i];
+			if (element.type === 'SpreadElement') {
+				code.remove(element.start, element.argument.start);
+			} else {
+				code.prependRight(element.start, '[');
+				code.prependRight(element.end, ']');
+			}
+		}
+
+		return true; // true indicates some spread elements
+	}
+
+	let element = elements[firstSpreadIndex];
+	const previousElement = elements[firstSpreadIndex - 1];
+
+	if (!previousElement) {
+		code.remove(start, element.start);
+		code.overwrite(element.end, elements[1].start, '.concat( ');
+	} else {
+		code.overwrite(previousElement.end, element.start, ' ].concat( ');
+	}
+
+	for (i = firstSpreadIndex; i < elements.length; i += 1) {
+		element = elements[i];
+
+		if (element) {
+			if (element.type === 'SpreadElement') {
+				code.remove(element.start, element.argument.start);
+			} else {
+				code.appendLeft(element.start, '[');
+				code.appendLeft(element.end, ']');
+			}
+		}
+	}
+
+	return true; // true indicates some spread elements
+}

data/vendor/node_modules/builtin-modules/builtin-modules.json

@@ -0,0 +1,39 @@
+[
+	"assert",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"dns",
+	"domain",
+	"events",
+	"fs",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"module",
+	"net",
+	"os",
+	"path",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"repl",
+	"stream",
+	"string_decoder",
+	"timers",
+	"tls",
+	"tty",
+	"url",
+	"util",
+	"v8",
+	"vm",
+	"zlib"
+]

data/vendor/node_modules/builtin-modules/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const blacklist = [
+	'freelist',
+	'sys'
+];
+
+module.exports = Object.keys(process.binding('natives'))
+	.filter(x => !/^_|^internal|\//.test(x) && blacklist.indexOf(x) === -1)
+	.sort();

data/vendor/node_modules/builtin-modules/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "builtin-modules",
+	"version": "2.0.0",
+	"description": "List of the Node.js builtin modules",
+	"license": "MIT",
+	"repository": "sindresorhus/builtin-modules",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=4"
+	},
+	"scripts": {
+		"test": "xo && ava",
+		"make": "node make.js"
+	},
+	"files": [
+		"index.js",
+		"static.js",
+		"builtin-modules.json"
+	],
+	"keywords": [
+		"builtin",
+		"built-in",
+		"builtins",
+		"node",
+		"modules",
+		"core",
+		"bundled",
+		"list",
+		"array",
+		"names"
+	],
+	"devDependencies": {
+		"ava": "*",
+		"xo": "*"
+	}
+}

data/vendor/node_modules/builtin-modules/static.js

@@ -0,0 +1,2 @@
+'use strict';
+module.exports = require('./builtin-modules');

data/vendor/node_modules/chalk/index.js

@@ -0,0 +1,228 @@
+'use strict';
+const escapeStringRegexp = require('escape-string-regexp');
+const ansiStyles = require('ansi-styles');
+const stdoutColor = require('supports-color').stdout;
+
+const template = require('./templates.js');
+
+const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+
+// `color-convert` models to exclude from the Chalk API due to conflicts and such
+const skipModels = new Set(['gray']);
+
+const styles = Object.create(null);
+
+function applyOptions(obj, options) {
+	options = options || {};
+
+	// Detect level if not set manually
+	const scLevel = stdoutColor ? stdoutColor.level : 0;
+	obj.level = options.level === undefined ? scLevel : options.level;
+	obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
+}
+
+function Chalk(options) {
+	// We check for this.template here since calling `chalk.constructor()`
+	// by itself will have a `this` of a previously constructed chalk object
+	if (!this || !(this instanceof Chalk) || this.template) {
+		const chalk = {};
+		applyOptions(chalk, options);
+
+		chalk.template = function () {
+			const args = [].slice.call(arguments);
+			return chalkTag.apply(null, [chalk.template].concat(args));
+		};
+
+		Object.setPrototypeOf(chalk, Chalk.prototype);
+		Object.setPrototypeOf(chalk.template, chalk);
+
+		chalk.template.constructor = Chalk;
+
+		return chalk.template;
+	}
+
+	applyOptions(this, options);
+}
+
+// Use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+	ansiStyles.blue.open = '\u001B[94m';
+}
+
+for (const key of Object.keys(ansiStyles)) {
+	ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+
+	styles[key] = {
+		get() {
+			const codes = ansiStyles[key];
+			return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+		}
+	};
+}
+
+styles.visible = {
+	get() {
+		return build.call(this, this._styles || [], true, 'visible');
+	}
+};
+
+ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
+for (const model of Object.keys(ansiStyles.color.ansi)) {
+	if (skipModels.has(model)) {
+		continue;
+	}
+
+	styles[model] = {
+		get() {
+			const level = this.level;
+			return function () {
+				const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
+				const codes = {
+					open,
+					close: ansiStyles.color.close,
+					closeRe: ansiStyles.color.closeRe
+				};
+				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+			};
+		}
+	};
+}
+
+ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
+for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
+	if (skipModels.has(model)) {
+		continue;
+	}
+
+	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = {
+		get() {
+			const level = this.level;
+			return function () {
+				const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
+				const codes = {
+					open,
+					close: ansiStyles.bgColor.close,
+					closeRe: ansiStyles.bgColor.closeRe
+				};
+				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+			};
+		}
+	};
+}
+
+const proto = Object.defineProperties(() => {}, styles);
+
+function build(_styles, _empty, key) {
+	const builder = function () {
+		return applyStyle.apply(builder, arguments);
+	};
+
+	builder._styles = _styles;
+	builder._empty = _empty;
+
+	const self = this;
+
+	Object.defineProperty(builder, 'level', {
+		enumerable: true,
+		get() {
+			return self.level;
+		},
+		set(level) {
+			self.level = level;
+		}
+	});
+
+	Object.defineProperty(builder, 'enabled', {
+		enumerable: true,
+		get() {
+			return self.enabled;
+		},
+		set(enabled) {
+			self.enabled = enabled;
+		}
+	});
+
+	// See below for fix regarding invisible grey/dim combination on Windows
+	builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
+
+	// `__proto__` is used because we must return a function, but there is
+	// no way to create a function with a different prototype
+	builder.__proto__ = proto; // eslint-disable-line no-proto
+
+	return builder;
+}
+
+function applyStyle() {
+	// Support varags, but simply cast to string in case there's only one arg
+	const args = arguments;
+	const argsLen = args.length;
+	let str = String(arguments[0]);
+
+	if (argsLen === 0) {
+		return '';
+	}
+
+	if (argsLen > 1) {
+		// Don't slice `arguments`, it prevents V8 optimizations
+		for (let a = 1; a < argsLen; a++) {
+			str += ' ' + args[a];
+		}
+	}
+
+	if (!this.enabled || this.level <= 0 || !str) {
+		return this._empty ? '' : str;
+	}
+
+	// Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
+	// see https://github.com/chalk/chalk/issues/58
+	// If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
+	const originalDim = ansiStyles.dim.open;
+	if (isSimpleWindowsTerm && this.hasGrey) {
+		ansiStyles.dim.open = '';
+	}
+
+	for (const code of this._styles.slice().reverse()) {
+		// Replace any instances already present with a re-opening code
+		// otherwise only the part of the string until said closing code
+		// will be colored, and the rest will simply be 'plain'.
+		str = code.open + str.replace(code.closeRe, code.open) + code.close;
+
+		// Close the styling before a linebreak and reopen
+		// after next line to fix a bleed issue on macOS
+		// https://github.com/chalk/chalk/pull/92
+		str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+	}
+
+	// Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
+	ansiStyles.dim.open = originalDim;
+
+	return str;
+}
+
+function chalkTag(chalk, strings) {
+	if (!Array.isArray(strings)) {
+		// If chalk() was called by itself or with a string,
+		// return the string itself as a string.
+		return [].slice.call(arguments, 1).join(' ');
+	}
+
+	const args = [].slice.call(arguments, 2);
+	const parts = [strings.raw[0]];
+
+	for (let i = 1; i < strings.length; i++) {
+		parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+		parts.push(String(strings.raw[i]));
+	}
+
+	return template(chalk, parts.join(''));
+}
+
+Object.defineProperties(Chalk.prototype, styles);
+
+module.exports = Chalk(); // eslint-disable-line new-cap
+module.exports.supportsColor = stdoutColor;
+module.exports.default = module.exports; // For TypeScript