jass 0.9.1

data/vendor/node_modules/@types/estree/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "@types/estree",
+    "version": "0.0.38",
+    "description": "TypeScript definitions for ESTree AST specification",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "RReverser",
+            "url": "https://github.com/RReverser",
+            "githubUsername": "RReverser"
+        }
+    ],
+    "main": "",
+    "repository": {
+        "type": "git",
+        "url": "https://www.github.com/DefinitelyTyped/DefinitelyTyped.git"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "19879f4eaa24d649d1de20d95bf747d91637d037470d47442d96dad57ec9a424",
+    "typeScriptVersion": "2.0"
+}

data/vendor/node_modules/acorn-dynamic-import/lib/index.js

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _acorn = require('acorn');
+
+var acorn = _interopRequireWildcard(_acorn);
+
+var _inject = require('./inject');
+
+var _inject2 = _interopRequireDefault(_inject);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
+
+exports['default'] = (0, _inject2['default'])(acorn);

data/vendor/node_modules/acorn-dynamic-import/lib/inject.js

@@ -0,0 +1,72 @@
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports['default'] = injectDynamicImport;
+/* eslint-disable no-underscore-dangle */
+
+var DynamicImportKey = exports.DynamicImportKey = 'Import';
+
+function injectDynamicImport(acorn) {
+  var tt = acorn.tokTypes;
+
+  // NOTE: This allows `yield import()` to parse correctly.
+  tt._import.startsExpr = true;
+
+  function parseDynamicImport() {
+    var node = this.startNode();
+    this.next();
+    if (this.type !== tt.parenL) {
+      this.unexpected();
+    }
+    return this.finishNode(node, DynamicImportKey);
+  }
+
+  function peekNext() {
+    return this.input[this.pos];
+  }
+
+  // eslint-disable-next-line no-param-reassign
+  acorn.plugins.dynamicImport = function () {
+    function dynamicImportPlugin(instance) {
+      instance.extend('parseStatement', function (nextMethod) {
+        return function () {
+          function parseStatement() {
+            var node = this.startNode();
+            if (this.type === tt._import) {
+              var nextToken = peekNext.call(this);
+              if (nextToken === tt.parenL.label) {
+                var expr = this.parseExpression();
+                return this.parseExpressionStatement(node, expr);
+              }
+            }
+
+            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+
+            return nextMethod.apply(this, args);
+          }
+
+          return parseStatement;
+        }();
+      });
+
+      instance.extend('parseExprAtom', function (nextMethod) {
+        return function () {
+          function parseExprAtom(refDestructuringErrors) {
+            if (this.type === tt._import) {
+              return parseDynamicImport.call(this);
+            }
+            return nextMethod.call(this, refDestructuringErrors);
+          }
+
+          return parseExprAtom;
+        }();
+      });
+    }
+
+    return dynamicImportPlugin;
+  }();
+
+  return acorn;
+}

data/vendor/node_modules/acorn-dynamic-import/lib/walk.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.inject = inject;
+
+var _walk = require('acorn/dist/walk');
+
+var walk = _interopRequireWildcard(_walk);
+
+var _inject = require('./inject');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function inject(injectableWalk) {
+  return Object.assign({}, injectableWalk, {
+    base: Object.assign({}, injectableWalk.base, _defineProperty({}, _inject.DynamicImportKey, function () {}))
+  });
+}
+
+exports['default'] = inject(walk);

data/vendor/node_modules/acorn-dynamic-import/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "acorn-dynamic-import",
+  "description": "Support dynamic imports in acorn",
+  "main": "lib/index.js",
+  "homepage": "https://github.com/kesne/acorn-dynamic-import",
+  "author": "Jordan Gensler <jordangens@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kesne/acorn-dynamic-import"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "babel src --out-dir lib",
+    "test": "npm run lint && npm run tests-only",
+    "lint": "eslint .",
+    "tests-only": "mocha",
+    "prepublish": "in-publish && safe-publish-latest && npm run build || not-in-publish",
+    "check-changelog": "expr $(git status --porcelain 2>/dev/null| grep \"^\\s*M.*CHANGELOG.md\" | wc -l) >/dev/null || (echo 'Please edit CHANGELOG.md' && exit 1)",
+    "check-only-changelog-changed": "(expr $(git status --porcelain 2>/dev/null| grep -v \"CHANGELOG.md\" | wc -l) >/dev/null && echo 'Only CHANGELOG.md may have uncommitted changes' && exit 1) || exit 0",
+    "version:major": "npm --no-git-tag-version version major",
+    "version:minor": "npm --no-git-tag-version version minor",
+    "version:patch": "npm --no-git-tag-version version patch",
+    "postversion": "git commit package.json CHANGELOG.md -m \"v$npm_package_version\" && npm run tag && git push && git push --tags",
+    "preversion": "npm run test && npm run check-changelog && npm run check-only-changelog-changed",
+    "tag": "git tag v$npm_package_version"
+  },
+  "dependencies": {
+    "acorn": "^5.0.0"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.18.0",
+    "babel-eslint": "^7.1.1",
+    "babel-preset-airbnb": "^2.1.1",
+    "babel-register": "^6.18.0",
+    "chai": "^3.0.0",
+    "eslint": "^3.10.2",
+    "eslint-config-airbnb-base": "^10.0.1",
+    "eslint-plugin-import": "^2.2.0",
+    "in-publish": "^2.0.0",
+    "mocha": "^2.2.5",
+    "rimraf": "^2.5.4",
+    "safe-publish-latest": "^1.1.1"
+  },
+  "version": "3.0.0"
+}

data/vendor/node_modules/acorn-dynamic-import/src/index.js

@@ -0,0 +1,4 @@
+import * as acorn from 'acorn';
+import inject from './inject';
+
+export default inject(acorn);

data/vendor/node_modules/acorn-dynamic-import/src/inject.js

@@ -0,0 +1,52 @@
+/* eslint-disable no-underscore-dangle */
+
+export const DynamicImportKey = 'Import';
+
+export default function injectDynamicImport(acorn) {
+  const tt = acorn.tokTypes;
+
+  // NOTE: This allows `yield import()` to parse correctly.
+  tt._import.startsExpr = true;
+
+  function parseDynamicImport() {
+    const node = this.startNode();
+    this.next();
+    if (this.type !== tt.parenL) {
+      this.unexpected();
+    }
+    return this.finishNode(node, DynamicImportKey);
+  }
+
+  function peekNext() {
+    return this.input[this.pos];
+  }
+
+  // eslint-disable-next-line no-param-reassign
+  acorn.plugins.dynamicImport = function dynamicImportPlugin(instance) {
+    instance.extend('parseStatement', nextMethod => (
+      function parseStatement(...args) {
+        const node = this.startNode();
+        if (this.type === tt._import) {
+          const nextToken = peekNext.call(this);
+          if (nextToken === tt.parenL.label) {
+            const expr = this.parseExpression();
+            return this.parseExpressionStatement(node, expr);
+          }
+        }
+
+        return nextMethod.apply(this, args);
+      }
+    ));
+
+    instance.extend('parseExprAtom', nextMethod => (
+      function parseExprAtom(refDestructuringErrors) {
+        if (this.type === tt._import) {
+          return parseDynamicImport.call(this);
+        }
+        return nextMethod.call(this, refDestructuringErrors);
+      }
+    ));
+  };
+
+  return acorn;
+}

data/vendor/node_modules/acorn-dynamic-import/src/walk.js

@@ -0,0 +1,12 @@
+import * as walk from 'acorn/dist/walk';
+import { DynamicImportKey } from './inject';
+
+export function inject(injectableWalk) {
+  return Object.assign({}, injectableWalk, {
+    base: Object.assign({}, injectableWalk.base, {
+      [DynamicImportKey]() {},
+    }),
+  });
+}
+
+export default inject(walk);

data/vendor/node_modules/acorn-es7-plugin/acorn-es7-plugin.js

@@ -0,0 +1,17 @@
+module.exports = function(acorn) {
+    switch (parseInt(acorn.version)) {
+    case 2:
+    case 3:
+        acorn.plugins.asyncawait = require('./acorn-v3') ;
+        break ;
+    case 4:
+        acorn.plugins.asyncawait = require('./acorn-v4') ;
+        break ;
+    case 5:
+        acorn.plugins.asyncawait = require('./acorn-v4') ;
+        break ;
+    default:
+        throw new Error("acorn-es7-plugin requires Acorn v2, 3, 4 or 5") ;
+    }
+    return acorn
+}

data/vendor/node_modules/acorn-es7-plugin/acorn-v3.js

@@ -0,0 +1,333 @@
+var NotAsync = {} ;
+var asyncExit = /^async[\t ]+(return|throw)/ ;
+var asyncFunction = /^async[\t ]+function/ ;
+var atomOrPropertyOrLabel = /^\s*[():;]/ ;
+var removeComments = /([^\n])\/\*(\*(?!\/)|[^\n*])*\*\/([^\n])/g ;
+var matchAsyncGet = /\s*(get|set)\s*\(/ ;
+
+function hasLineTerminatorBeforeNext(st, since) {
+    return st.lineStart >= since;
+}
+
+function test(regex,st,noComment) {
+    var src = st.input.slice(st.start) ;
+    if (noComment) {
+        src = src.replace(removeComments,"$1 $3") ;
+  }
+    return regex.test(src);
+}
+
+/* Create a new parser derived from the specified parser, so that in the
+ * event of an error we can back out and try again */
+function subParse(parser, pos, extensions,parens) {
+    var p = new parser.constructor(parser.options, parser.input, pos);
+    if (extensions)
+        for (var k in extensions)
+            p[k] = extensions[k] ;
+
+    var src = parser ;
+    var dest = p ;
+    ['inFunction','inAsyncFunction','inAsync','inGenerator','inModule'].forEach(function(k){
+        if (k in src)
+            dest[k] = src[k] ;
+    }) ;
+    if (parens)
+        p.options.preserveParens = true ;
+    p.nextToken();
+    return p;
+}
+
+//TODO: Implement option noAsyncGetters
+
+function asyncAwaitPlugin (parser,options){
+    var es7check = function(){} ;
+
+    parser.extend("initialContext",function(base){
+        return function(){
+            if (this.options.ecmaVersion < 7) {
+                es7check = function(node) {
+                    parser.raise(node.start,"async/await keywords only available when ecmaVersion>=7") ;
+                } ;
+            }
+            this.reservedWords = new RegExp(this.reservedWords.toString().replace(/await|async/g,"").replace("|/","/").replace("/|","/").replace("||","|")) ;
+            this.reservedWordsStrict = new RegExp(this.reservedWordsStrict.toString().replace(/await|async/g,"").replace("|/","/").replace("/|","/").replace("||","|")) ;
+            this.reservedWordsStrictBind = new RegExp(this.reservedWordsStrictBind.toString().replace(/await|async/g,"").replace("|/","/").replace("/|","/").replace("||","|")) ;
+            this.inAsyncFunction = options.inAsyncFunction ;
+            if (options.awaitAnywhere && options.inAsyncFunction)
+                parser.raise(node.start,"The options awaitAnywhere and inAsyncFunction are mutually exclusive") ;
+
+            return base.apply(this,arguments);
+        }
+    }) ;
+
+    parser.extend("shouldParseExportStatement",function(base){
+        return function(){
+            if (this.type.label==='name' && this.value==='async' && test(asyncFunction,this)) {
+                return true ;
+            }
+            return base.apply(this,arguments) ;
+        }
+    }) ;
+
+    parser.extend("parseStatement",function(base){
+        return function (declaration, topLevel) {
+            var start = this.start;
+            var startLoc = this.startLoc;
+            if (this.type.label==='name') {
+                if (test(asyncFunction,this,true)) {
+                    var wasAsync = this.inAsyncFunction ;
+                    try {
+                        this.inAsyncFunction = true ;
+                        this.next() ;
+                        var r = this.parseStatement(declaration, topLevel) ;
+                        r.async = true ;
+                        r.start = start;
+                        r.loc && (r.loc.start = startLoc);
+                        r.range && (r.range[0] = start);
+                        return r ;
+                    } finally {
+                        this.inAsyncFunction = wasAsync ;
+                    }
+                } else if ((typeof options==="object" && options.asyncExits) && test(asyncExit,this)) {
+                    // NON-STANDARD EXTENSION iff. options.asyncExits is set, the
+                    // extensions 'async return <expr>?' and 'async throw <expr>?'
+                    // are enabled. In each case they are the standard ESTree nodes
+                    // with the flag 'async:true'
+                    this.next() ;
+                    var r = this.parseStatement(declaration, topLevel) ;
+                    r.async = true ;
+                    r.start = start;
+                    r.loc && (r.loc.start = startLoc);
+                    r.range && (r.range[0] = start);
+                   return r ;
+                }
+            }
+            return base.apply(this,arguments);
+        }
+    }) ;
+
+  parser.extend("parseIdent",function(base){
+        return function(liberal){
+                var id = base.apply(this,arguments);
+                if (this.inAsyncFunction && id.name==='await') {
+                    if (arguments.length===0) {
+                        this.raise(id.start,"'await' is reserved within async functions") ;
+                    }
+                }
+                return id ;
+        }
+    }) ;
+
+  parser.extend("parseExprAtom",function(base){
+        return function(refShorthandDefaultPos){
+            var start = this.start ;
+            var startLoc = this.startLoc;
+            var rhs,r = base.apply(this,arguments);
+            if (r.type==='Identifier') {
+                if (r.name==='async' && !hasLineTerminatorBeforeNext(this, r.end)) {
+                    // Is this really an async function?
+                    var isAsync = this.inAsyncFunction ;
+                    try {
+                        this.inAsyncFunction = true ;
+                        var pp = this ;
+                        var inBody = false ;
+
+                        var parseHooks = {
+                            parseFunctionBody:function(node,isArrowFunction){
+                                try {
+                                    var wasInBody = inBody ;
+                                    inBody = true ;
+                                    return pp.parseFunctionBody.apply(this,arguments) ;
+                                } finally {
+                                    inBody = wasInBody ;
+                                }
+                            },
+                            raise:function(){
+                                try {
+                                    return pp.raise.apply(this,arguments) ;
+                                } catch(ex) {
+                                    throw inBody?ex:NotAsync ;
+                                }
+                            }
+                        } ;
+
+                        rhs = subParse(this,this.start,parseHooks,true).parseExpression() ;
+                        if (rhs.type==='SequenceExpression')
+                            rhs = rhs.expressions[0] ;
+                        if (rhs.type === 'CallExpression')
+                            rhs = rhs.callee ;
+                        if (rhs.type==='FunctionExpression' || rhs.type==='FunctionDeclaration' || rhs.type==='ArrowFunctionExpression') {
+                            // Because we don't know if the top level parser supprts preserveParens, we have to re-parse
+                            // without it set
+                            rhs = subParse(this,this.start,parseHooks).parseExpression() ;
+                            if (rhs.type==='SequenceExpression')
+                                rhs = rhs.expressions[0] ;
+                            if (rhs.type === 'CallExpression')
+                                rhs = rhs.callee ;
+                            
+                            rhs.async = true ;
+                            rhs.start = start;
+                            rhs.loc && (rhs.loc.start = startLoc);
+                            rhs.range && (rhs.range[0] = start);
+                            this.pos = rhs.end;
+                            this.end = rhs.end ;
+                            this.endLoc = rhs.endLoc ;
+                            this.next();
+                            es7check(rhs) ;
+                            return rhs ;
+                        }
+                    } catch (ex) {
+                        if (ex!==NotAsync)
+                            throw ex ;
+                    }
+                    finally {
+                        this.inAsyncFunction = isAsync ;
+                    }
+                }
+                else if (r.name==='await') {
+                    var n = this.startNodeAt(r.start, r.loc && r.loc.start);
+                    if (this.inAsyncFunction) {
+                        rhs = this.parseExprSubscripts() ;
+                        n.operator = 'await' ;
+                        n.argument = rhs ;
+                        n = this.finishNodeAt(n,'AwaitExpression', rhs.end, rhs.loc && rhs.loc.end) ;
+                        es7check(n) ;
+                        return n ;
+                    }
+                    // NON-STANDARD EXTENSION iff. options.awaitAnywhere is true,
+                    // an 'AwaitExpression' is allowed anywhere the token 'await'
+                    // could not be an identifier with the name 'await'.
+
+                    // Look-ahead to see if this is really a property or label called async or await
+                    if (this.input.slice(r.end).match(atomOrPropertyOrLabel)) {
+                        if (!options.awaitAnywhere && this.options.sourceType === 'module')
+                            return this.raise(r.start,"'await' is reserved within modules") ;
+                        return r ; // This is a valid property name or label
+                    }
+
+                    if (typeof options==="object" && options.awaitAnywhere) {
+                        start = this.start ;
+                        rhs = subParse(this,start-4).parseExprSubscripts() ;
+                        if (rhs.end<=start) {
+                            rhs = subParse(this,start).parseExprSubscripts() ;
+                            n.operator = 'await' ;
+                            n.argument = rhs ;
+                            n = this.finishNodeAt(n,'AwaitExpression', rhs.end, rhs.loc && rhs.loc.end) ;
+                            this.pos = rhs.end;
+                            this.end = rhs.end ;
+                            this.endLoc = rhs.endLoc ;
+                            this.next();
+                            es7check(n) ;
+                            return n ;
+                        }
+                    }
+
+                    if (!options.awaitAnywhere && this.options.sourceType === 'module')
+                        return this.raise(r.start,"'await' is reserved within modules") ;
+                }
+            }
+            return r ;
+        }
+    }) ;
+
+    parser.extend('finishNodeAt',function(base){
+            return function(node,type,pos,loc) {
+                if (node.__asyncValue) {
+                    delete node.__asyncValue ;
+                    node.value.async = true ;
+                }
+                return base.apply(this,arguments) ;
+            }
+    }) ;
+
+    parser.extend('finishNode',function(base){
+            return function(node,type) {
+                if (node.__asyncValue) {
+                    delete node.__asyncValue ;
+                    node.value.async = true ;
+                }
+                return base.apply(this,arguments) ;
+            }
+    }) ;
+
+    var allowedPropSpecifiers = {
+        get:true,
+        set:true,
+        async:true
+    };
+    
+    parser.extend("parsePropertyName",function(base){
+        return function (prop) {
+            var prevName = prop.key && prop.key.name ;
+            var key = base.apply(this,arguments) ;
+            if (key.type === "Identifier" && (key.name === "async") && !hasLineTerminatorBeforeNext(this, key.end)) {
+                // Look-ahead to see if this is really a property or label called async or await
+                if (!this.input.slice(key.end).match(atomOrPropertyOrLabel)){
+                    // Cheese - eliminate the cases 'async get(){}' and async set(){}'
+                    if (matchAsyncGet.test(this.input.slice(key.end))) {
+                        key = base.apply(this,arguments) ;
+                        prop.__asyncValue = true ;
+                    } else {
+                        es7check(prop) ;
+                        if (prop.kind === 'set') 
+                            this.raise(key.start,"'set <member>(value)' cannot be be async") ;
+                        
+                        key = base.apply(this,arguments) ;
+                        if (key.type==='Identifier') {
+                            if (key.name==='set')
+                                this.raise(key.start,"'set <member>(value)' cannot be be async") ;
+                        }
+                        prop.__asyncValue = true ;
+                    }
+                }
+            }
+            return key;
+        };
+    }) ;
+
+    parser.extend("parseClassMethod",function(base){
+        return function (classBody, method, isGenerator) {
+            var wasAsync ;
+            if (method.__asyncValue) {
+                if (method.kind==='constructor')
+                    this.raise(method.start,"class constructor() cannot be be async") ;
+                wasAsync = this.inAsyncFunction ;
+                this.inAsyncFunction = true ;
+            }
+            var r = base.apply(this,arguments) ;
+            this.inAsyncFunction = wasAsync ;
+            return r ;
+        }
+    }) ;
+
+    parser.extend("parseMethod",function(base){
+        return function (isGenerator) {
+            var wasAsync ;
+            if (this.__currentProperty && this.__currentProperty.__asyncValue) {
+                wasAsync = this.inAsyncFunction ;
+                this.inAsyncFunction = true ;
+            }
+            var r = base.apply(this,arguments) ;
+            this.inAsyncFunction = wasAsync ;
+            return r ;
+        }
+    }) ;
+
+    parser.extend("parsePropertyValue",function(base){
+        return function (prop, isPattern, isGenerator, startPos, startLoc, refDestructuringErrors) {
+            var prevProp = this.__currentProperty ; 
+            this.__currentProperty = prop ;
+            var wasAsync ;
+            if (prop.__asyncValue) {
+                wasAsync = this.inAsyncFunction ;
+                this.inAsyncFunction = true ;
+            }
+            var r = base.apply(this,arguments) ;
+            this.inAsyncFunction = wasAsync ;
+            this.__currentProperty = prevProp ;
+            return r ;
+        }
+    }) ;
+}
+
+module.exports = asyncAwaitPlugin ;