jass 0.9.1

data/vendor/node_modules/buble/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "buble",
+  "version": "0.19.3",
+  "description": "The blazing fast, batteries-included ES2015 compiler",
+  "main": "dist/buble.cjs.js",
+  "module": "dist/buble.es.js",
+  "browser": {
+    "dist/buble.cjs.js": "./dist/buble-browser.cjs.js",
+    "dist/buble.es.js": "./dist/buble-browser.es.js"
+  },
+  "unpkg": "dist/buble-browser-deps.umd.js",
+  "files": [
+    "bin",
+    "src",
+    "dist",
+    "register.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "test": "mocha test/test.js",
+    "pretest": "npm run build",
+    "prepublish": "npm test",
+    "lint": "eslint src"
+  },
+  "bin": {
+    "buble": "./bin/buble"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rich-Harris/buble.git"
+  },
+  "keywords": [
+    "javascript",
+    "transpilation",
+    "compilation",
+    "esnext",
+    "es2015",
+    "es2017",
+    "es6",
+    "es7"
+  ],
+  "author": "Rich Harris",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Rich-Harris/buble/issues"
+  },
+  "homepage": "https://github.com/Rich-Harris/buble#README",
+  "devDependencies": {
+    "console-group": "^0.3.3",
+    "eslint": "^4.17.0",
+    "glob": "^7.0.3",
+    "mocha": "^5.0.0",
+    "regexpu-core": "^4.1.3",
+    "rimraf": "^2.5.2",
+    "rollup": "^0.55.5",
+    "rollup-plugin-buble": "^0.19.1",
+    "rollup-plugin-commonjs": "^8.3.0",
+    "rollup-plugin-json": "^2.3.0",
+    "rollup-plugin-node-resolve": "^3.0.2",
+    "source-map": "^0.6.1",
+    "source-map-support": "^0.5.3"
+  },
+  "dependencies": {
+    "acorn": "^5.4.1",
+    "acorn-dynamic-import": "^3.0.0",
+    "acorn-jsx": "^4.1.1",
+    "chalk": "^2.3.1",
+    "magic-string": "^0.22.4",
+    "minimist": "^1.2.0",
+    "os-homedir": "^1.0.1",
+    "vlq": "^1.0.0"
+  }
+}

data/vendor/node_modules/buble/register.js

@@ -0,0 +1,90 @@
+var fs = require( 'fs' );
+var path = require( 'path' );
+var crypto = require( 'crypto' );
+var homedir = require( 'os-homedir' );
+var buble = require( './' );
+
+var original = require.extensions[ '.js' ];
+var nodeModulesPattern = path.sep === '/' ? /\/node_modules\// : /\\node_modules\\/;
+
+var nodeVersion = /(?:0\.)?\d+/.exec( process.version )[0];
+var versions = [ '0.10', '0.12', '4', '5', '6' ];
+
+if ( !~versions.indexOf( nodeVersion ) ) {
+	if ( +nodeVersion > 6 ) {
+		nodeVersion = '6';
+	} else {
+		throw new Error( 'Unsupported version (' + nodeVersion + '). Please raise an issue at https://github.com/Rich-Harris/buble/issues' );
+	}
+}
+
+var options = {
+	target: {
+		node: nodeVersion
+	}
+};
+
+function mkdirp ( dir ) {
+	var parent = path.dirname( dir );
+	if ( dir === parent ) return;
+	mkdirp( parent );
+
+	try {
+		fs.mkdirSync( dir );
+	} catch ( err ) {
+		if ( err.code !== 'EEXIST' ) throw err;
+	}
+}
+
+var home = homedir();
+if ( home ) {
+	var cachedir = path.join( home, '.buble-cache', String(nodeVersion) );
+	mkdirp( cachedir );
+	fs.writeFileSync( path.join( home, '.buble-cache/README.txt' ), 'These files enable a faster startup when using buble/register. You can safely delete this folder at any time. See https://buble.surge.sh/guide/ for more information.' );
+}
+
+var optionsStringified = JSON.stringify( options );
+
+require.extensions[ '.js' ] = function ( m, filename ) {
+	if ( nodeModulesPattern.test( filename ) ) return original( m, filename );
+
+	var source = fs.readFileSync( filename, 'utf-8' );
+	var hash = crypto.createHash( 'sha256' );
+	hash.update( buble.VERSION );
+	hash.update( optionsStringified );
+	hash.update( source );
+	var key = hash.digest( 'hex' ) + '.json';
+	var cachepath = path.join( cachedir, key );
+
+	var compiled;
+
+	if ( cachedir ) {
+		try {
+			compiled = JSON.parse( fs.readFileSync( cachepath, 'utf-8' ) );
+		} catch ( err ) {
+			// noop
+		}
+	}
+
+	if ( !compiled ) {
+		try {
+			compiled = buble.transform( source, options );
+
+			if ( cachedir ) {
+				fs.writeFileSync( cachepath, JSON.stringify( compiled ) );
+			}
+		} catch ( err ) {
+			if ( err.snippet ) {
+				console.log( 'Error compiling ' + filename + ':\n---' );
+				console.log( err.snippet );
+				console.log( err.message );
+				console.log( '' )
+				process.exit( 1 );
+			}
+
+			throw err;
+		}
+	}
+
+	m._compile( '"use strict";\n' + compiled.code, filename );
+};

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

@@ -0,0 +1,98 @@
+import * as acorn from 'acorn';
+import acornJsx from 'acorn-jsx/inject';
+import acornDynamicImport from 'acorn-dynamic-import/lib/inject';
+import Program from './program/Program.js';
+import { features, matrix } from './support.js';
+import getSnippet from './utils/getSnippet.js';
+
+const { parse } = [acornJsx, acornDynamicImport].reduce(
+	(final, plugin) => plugin(final),
+	acorn
+);
+
+const dangerousTransforms = ['dangerousTaggedTemplateString', 'dangerousForOf'];
+
+export function target(target) {
+	const targets = Object.keys(target);
+	let bitmask = targets.length
+		? 0b11111111111111111111
+		: 0b01000000000000000000;
+
+	Object.keys(target).forEach(environment => {
+		const versions = matrix[environment];
+		if (!versions)
+			throw new Error(
+				`Unknown environment '${environment}'. Please raise an issue at https://github.com/Rich-Harris/buble/issues`
+			);
+
+		const targetVersion = target[environment];
+		if (!(targetVersion in versions))
+			throw new Error(
+				`Support data exists for the following versions of ${environment}: ${Object.keys(
+					versions
+				).join(
+					', '
+				)}. Please raise an issue at https://github.com/Rich-Harris/buble/issues`
+			);
+		const support = versions[targetVersion];
+
+		bitmask &= support;
+	});
+
+	let transforms = Object.create(null);
+	features.forEach((name, i) => {
+		transforms[name] = !(bitmask & (1 << i));
+	});
+
+	dangerousTransforms.forEach(name => {
+		transforms[name] = false;
+	});
+
+	return transforms;
+}
+
+export function transform(source, options = {}) {
+	let ast;
+	let jsx = null;
+
+	try {
+		ast = parse(source, {
+			ecmaVersion: 9,
+			preserveParens: true,
+			sourceType: 'module',
+			onComment: (block, text) => {
+				if (!jsx) {
+					let match = /@jsx\s+([^\s]+)/.exec(text);
+					if (match) jsx = match[1];
+				}
+			},
+			plugins: {
+				jsx: true,
+				dynamicImport: true
+			}
+		});
+		options.jsx = jsx || options.jsx;
+	} catch (err) {
+		err.snippet = getSnippet(source, err.loc);
+		err.toString = () => `${err.name}: ${err.message}\n${err.snippet}`;
+		throw err;
+	}
+
+	let transforms = target(options.target || {});
+	Object.keys(options.transforms || {}).forEach(name => {
+		if (name === 'modules') {
+			if (!('moduleImport' in options.transforms))
+				transforms.moduleImport = options.transforms.modules;
+			if (!('moduleExport' in options.transforms))
+				transforms.moduleExport = options.transforms.modules;
+			return;
+		}
+
+		if (!(name in transforms)) throw new Error(`Unknown transform '${name}'`);
+		transforms[name] = options.transforms[name];
+	});
+
+	return new Program(source, ast, transforms, options).export(options);
+}
+
+export { version as VERSION } from '../package.json';

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

@@ -0,0 +1,373 @@
+import Node from './Node.js';
+import Scope from './Scope.js';
+import destructure from '../utils/destructure.js';
+
+function isUseStrict(node) {
+	if (!node) return false;
+	if (node.type !== 'ExpressionStatement') return false;
+	if (node.expression.type !== 'Literal') return false;
+	return node.expression.value === 'use strict';
+}
+
+export default class BlockStatement extends Node {
+	createScope() {
+		this.parentIsFunction = /Function/.test(this.parent.type);
+		this.isFunctionBlock = this.parentIsFunction || this.parent.type === 'Root';
+		this.scope = new Scope({
+			block: !this.isFunctionBlock,
+			parent: this.parent.findScope(false),
+			declare: id => this.createdDeclarations.push(id)
+		});
+
+		if (this.parentIsFunction) {
+			this.parent.params.forEach(node => {
+				this.scope.addDeclaration(node, 'param');
+			});
+		}
+	}
+
+	initialise(transforms) {
+		this.thisAlias = null;
+		this.argumentsAlias = null;
+		this.defaultParameters = [];
+		this.createdDeclarations = [];
+
+		// normally the scope gets created here, during initialisation,
+		// but in some cases (e.g. `for` statements), we need to create
+		// the scope early, as it pertains to both the init block and
+		// the body of the statement
+		if (!this.scope) this.createScope();
+
+		this.body.forEach(node => node.initialise(transforms));
+
+		this.scope.consolidate();
+	}
+
+	findLexicalBoundary() {
+		if (this.type === 'Program') return this;
+		if (/^Function/.test(this.parent.type)) return this;
+
+		return this.parent.findLexicalBoundary();
+	}
+
+	findScope(functionScope) {
+		if (functionScope && !this.isFunctionBlock)
+			return this.parent.findScope(functionScope);
+		return this.scope;
+	}
+
+	getArgumentsAlias() {
+		if (!this.argumentsAlias) {
+			this.argumentsAlias = this.scope.createIdentifier('arguments');
+		}
+
+		return this.argumentsAlias;
+	}
+
+	getArgumentsArrayAlias() {
+		if (!this.argumentsArrayAlias) {
+			this.argumentsArrayAlias = this.scope.createIdentifier('argsArray');
+		}
+
+		return this.argumentsArrayAlias;
+	}
+
+	getThisAlias() {
+		if (!this.thisAlias) {
+			this.thisAlias = this.scope.createIdentifier('this');
+		}
+
+		return this.thisAlias;
+	}
+
+	getIndentation() {
+		if (this.indentation === undefined) {
+			const source = this.program.magicString.original;
+
+			const useOuter = this.synthetic || !this.body.length;
+			let c = useOuter ? this.start : this.body[0].start;
+
+			while (c && source[c] !== '\n') c -= 1;
+
+			this.indentation = '';
+
+			// eslint-disable-next-line no-constant-condition
+			while (true) {
+				c += 1;
+				const char = source[c];
+
+				if (char !== ' ' && char !== '\t') break;
+
+				this.indentation += char;
+			}
+
+			const indentString = this.program.magicString.getIndentString();
+
+			// account for dedented class constructors
+			let parent = this.parent;
+			while (parent) {
+				if (parent.kind === 'constructor' && !parent.parent.parent.superClass) {
+					this.indentation = this.indentation.replace(indentString, '');
+				}
+
+				parent = parent.parent;
+			}
+
+			if (useOuter) this.indentation += indentString;
+		}
+
+		return this.indentation;
+	}
+
+	transpile(code, transforms) {
+		const indentation = this.getIndentation();
+
+		let introStatementGenerators = [];
+
+		if (this.argumentsAlias) {
+			introStatementGenerators.push((start, prefix, suffix) => {
+				const assignment = `${prefix}var ${this.argumentsAlias} = arguments${
+					suffix
+				}`;
+				code.appendLeft(start, assignment);
+			});
+		}
+
+		if (this.thisAlias) {
+			introStatementGenerators.push((start, prefix, suffix) => {
+				const assignment = `${prefix}var ${this.thisAlias} = this${suffix}`;
+				code.appendLeft(start, assignment);
+			});
+		}
+
+		if (this.argumentsArrayAlias) {
+			introStatementGenerators.push((start, prefix, suffix) => {
+				const i = this.scope.createIdentifier('i');
+				const assignment = `${prefix}var ${i} = arguments.length, ${
+					this.argumentsArrayAlias
+				} = Array(${i});\n${indentation}while ( ${i}-- ) ${
+					this.argumentsArrayAlias
+				}[${i}] = arguments[${i}]${suffix}`;
+				code.appendLeft(start, assignment);
+			});
+		}
+
+		if (/Function/.test(this.parent.type)) {
+			this.transpileParameters(
+				this.parent.params,
+				code,
+				transforms,
+				indentation,
+				introStatementGenerators
+			);
+		} else if ('CatchClause' === this.parent.type) {
+			this.transpileParameters(
+				[this.parent.param],
+				code,
+				transforms,
+				indentation,
+				introStatementGenerators
+			);
+		}
+
+		if (transforms.letConst && this.isFunctionBlock) {
+			this.transpileBlockScopedIdentifiers(code);
+		}
+
+		super.transpile(code, transforms);
+
+		if (this.createdDeclarations.length) {
+			introStatementGenerators.push((start, prefix, suffix) => {
+				const assignment = `${prefix}var ${this.createdDeclarations.join(', ')}${suffix}`;
+				code.appendLeft(start, assignment);
+			});
+		}
+
+		if (this.synthetic) {
+			if (this.parent.type === 'ArrowFunctionExpression') {
+				const expr = this.body[0];
+
+				if (introStatementGenerators.length) {
+					code
+						.appendLeft(this.start, `{`)
+						.prependRight(this.end, `${this.parent.getIndentation()}}`);
+
+					code.prependRight(expr.start, `\n${indentation}return `);
+					code.appendLeft(expr.end, `;\n`);
+				} else if (transforms.arrow) {
+					code.prependRight(expr.start, `{ return `);
+					code.appendLeft(expr.end, `; }`);
+				}
+			} else if (introStatementGenerators.length) {
+				code.prependRight(this.start, `{`).appendLeft(this.end, `}`);
+			}
+		}
+
+		let start;
+		if (isUseStrict(this.body[0])) {
+			start = this.body[0].end;
+		} else if (this.synthetic || this.parent.type === 'Root') {
+			start = this.start;
+		} else {
+			start = this.start + 1;
+		}
+
+		let prefix = `\n${indentation}`;
+		let suffix = ';';
+		introStatementGenerators.forEach((fn, i) => {
+			if (i === introStatementGenerators.length - 1) suffix = `;\n`;
+			fn(start, prefix, suffix);
+		});
+	}
+
+	transpileParameters(params, code, transforms, indentation, introStatementGenerators) {
+		params.forEach(param => {
+			if (
+				param.type === 'AssignmentPattern' &&
+				param.left.type === 'Identifier'
+			) {
+				if (transforms.defaultParameter) {
+					introStatementGenerators.push((start, prefix, suffix) => {
+						const lhs = `${prefix}if ( ${param.left.name} === void 0 ) ${
+							param.left.name
+						}`;
+
+						code
+							.prependRight(param.left.end, lhs)
+							.move(param.left.end, param.right.end, start)
+							.appendLeft(param.right.end, suffix);
+					});
+				}
+			} else if (param.type === 'RestElement') {
+				if (transforms.spreadRest) {
+					introStatementGenerators.push((start, prefix, suffix) => {
+						const penultimateParam = params[params.length - 2];
+
+						if (penultimateParam) {
+							code.remove(
+								penultimateParam ? penultimateParam.end : param.start,
+								param.end
+							);
+						} else {
+							let start = param.start,
+								end = param.end; // TODO https://gitlab.com/Rich-Harris/buble/issues/8
+
+							while (/\s/.test(code.original[start - 1])) start -= 1;
+							while (/\s/.test(code.original[end])) end += 1;
+
+							code.remove(start, end);
+						}
+
+						const name = param.argument.name;
+						const len = this.scope.createIdentifier('len');
+						const count = params.length - 1;
+
+						if (count) {
+							code.prependRight(
+								start,
+								`${prefix}var ${name} = [], ${len} = arguments.length - ${
+									count
+								};\n${indentation}while ( ${len}-- > 0 ) ${name}[ ${
+									len
+								} ] = arguments[ ${len} + ${count} ]${suffix}`
+							);
+						} else {
+							code.prependRight(
+								start,
+								`${prefix}var ${name} = [], ${len} = arguments.length;\n${
+									indentation
+								}while ( ${len}-- ) ${name}[ ${len} ] = arguments[ ${len} ]${
+									suffix
+								}`
+							);
+						}
+					});
+				}
+			} else if (param.type !== 'Identifier') {
+				if (transforms.parameterDestructuring) {
+					const ref = this.scope.createIdentifier('ref');
+					destructure(
+						code,
+						id => this.scope.createIdentifier(id),
+						({ name }) => this.scope.resolveName(name),
+						param,
+						ref,
+						false,
+						introStatementGenerators
+					);
+					code.prependRight(param.start, ref);
+				}
+			}
+		});
+	}
+
+	transpileBlockScopedIdentifiers(code) {
+		Object.keys(this.scope.blockScopedDeclarations).forEach(name => {
+			const declarations = this.scope.blockScopedDeclarations[name];
+
+			for (let declaration of declarations) {
+				let cont = false; // TODO implement proper continue...
+
+				if (declaration.kind === 'for.let') {
+					// special case
+					const forStatement = declaration.node.findNearest('ForStatement');
+
+					if (forStatement.shouldRewriteAsFunction) {
+						const outerAlias = this.scope.createIdentifier(name);
+						const innerAlias = forStatement.reassigned[name]
+							? this.scope.createIdentifier(name)
+							: name;
+
+						declaration.name = outerAlias;
+						code.overwrite(
+							declaration.node.start,
+							declaration.node.end,
+							outerAlias,
+							{ storeName: true }
+						);
+
+						forStatement.aliases[name] = {
+							outer: outerAlias,
+							inner: innerAlias
+						};
+
+						for (const identifier of declaration.instances) {
+							const alias = forStatement.body.contains(identifier)
+								? innerAlias
+								: outerAlias;
+
+							if (name !== alias) {
+								code.overwrite(identifier.start, identifier.end, alias, {
+									storeName: true
+								});
+							}
+						}
+
+						cont = true;
+					}
+				}
+
+				if (!cont) {
+					const alias = this.scope.createIdentifier(name);
+
+					if (name !== alias) {
+						declaration.name = alias;
+						code.overwrite(
+							declaration.node.start,
+							declaration.node.end,
+							alias,
+							{ storeName: true }
+						);
+
+						for (const identifier of declaration.instances) {
+							identifier.rewritten = true;
+							code.overwrite(identifier.start, identifier.end, alias, {
+								storeName: true
+							});
+						}
+					}
+				}
+			}
+		});
+	}
+}