jass 0.9.1 → 0.9.3

data/vendor/node_modules/is-reference/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/math-random/browser.js

@@ -0,0 +1,17 @@
+module.exports = (function (global) {
+  var uint32 = 'Uint32Array' in global
+  var crypto = global.crypto || global.msCrypto
+  var rando = crypto && typeof crypto.getRandomValues === 'function'
+  var good = uint32 && crypto && rando
+  if (!good) return Math.random
+
+  var arr = new Uint32Array(1)
+  var max = Math.pow(2, 32)
+  function random () {
+    crypto.getRandomValues(arr)
+    return arr[0] / max
+  }
+
+  random.cryptographic = true
+  return random
+})(typeof self !== 'undefined' ? self : window)

data/vendor/node_modules/math-random/node.js

@@ -0,0 +1,13 @@
+var crypto = require('crypto')
+var max = Math.pow(2, 32)
+
+module.exports = random
+module.exports.cryptographic = true
+
+function random () {
+  var buf = crypto
+    .randomBytes(4)
+    .toString('hex')
+
+  return parseInt(buf, 16) / max
+}

data/vendor/node_modules/math-random/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "math-random",
+  "version": "1.0.1",
+  "description": "a drop-in replacement for Math.random that uses cryptographically secure random number generation, where available",
+  "main": "node.js",
+  "browser": "browser.js",
+  "scripts": {
+    "test": "tape test.js"
+  },
+  "devDependencies": {
+    "array-unique": "~0.2.1",
+    "tape": "~4.2.2"
+  },
+  "testling": {
+    "files": "test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:michaelrhodes/math-random"
+  },
+  "keywords": [
+    "Math.random",
+    "crypto.getRandomValues"
+  ],
+  "author": "Michael Rhodes",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/michaelrhodes/math-random/issues"
+  },
+  "homepage": "https://github.com/michaelrhodes/math-random"
+}

data/vendor/node_modules/math-random/test.js

@@ -0,0 +1,26 @@
+var test = require('tape')
+var unique = require('array-unique')
+var random = require('./')
+
+test('it works', function (assert) {
+  var number, l = 1000, cache = []
+
+  for (var i = 0; i < l; i++) {
+    number = random()
+    if (number <= 0) {
+      assert.fail('a random number was less than or equal to zero')
+      assert.end()
+      return
+    }
+    if (number >= 1) {
+      assert.fail('a random number was greater than or equal to one')
+      assert.end()
+      return
+    }
+    cache.push(number)
+  }
+
+  assert.pass('all ' + l + ' random numbers were greater than zero and less than one')
+  assert.equal(cache.length, unique(cache).length, 'all ' + l + ' random numbers were unique')
+  assert.end()
+})

data/vendor/node_modules/nodent-compiler/compiler.js

@@ -1,6 +1,72 @@
-var parser = require('./lib/parser') ;
-var treeSurgeon = require('./lib/arboriculture') ;
-var outputCode = require('./lib/output') ;
+'use strict';
+
+var acorn = require("acorn");
+var treeSurgeon = require('nodent-transform') ;
+var outputCode = require('./output') ;
+
+var alreadyInstalledPlugin = false ;
+
+function acornParse(code,config) {
+    var comments = [] ;
+    var options = {
+        ecmaVersion:9,
+        allowHashBang:true,
+        allowReturnOutsideFunction:true,
+        allowImportExportEverywhere:true,
+        locations:true,
+        onComment:comments
+    } ;
+
+    if (config)
+        for (var k in config)
+            if (k !== 'noNodentExtensions' && k != 'onParserInstallation')
+                options[k] = config[k] ;
+
+    if (!(config && config.noNodentExtensions) || parseInt(acorn.version) < 4) {
+        if (!alreadyInstalledPlugin) {
+            if (parseInt(acorn.version) < 4)
+                console.warn("Nodent: Warning - noNodentExtensions option requires acorn >=v4.x. Extensions installed.") ;
+            require('acorn-es7-plugin')(acorn) ;
+            if (config && config.onParserInstallation) config.onParserInstallation(acorn) ;
+            alreadyInstalledPlugin = true ;
+        }
+        options.plugins = options.plugins || {} ;
+        options.plugins.asyncawait = {asyncExits:true, awaitAnywhere:true} ;
+    }
+
+    var ast = acorn.parse(code,options) ;
+
+    // attach comments to the most tightly containing node
+    treeSurgeon.treeWalker(ast,function(node,descend,path){
+        descend() ;
+        while (comments.length && node.loc &&
+            (node.loc.start.line >= comments[0].loc.start.line && node.loc.end.line>=comments[0].loc.end.line)) {
+            node.$comments = node.$comments||[] ;
+            node.$comments.push(comments.shift()) ;
+        }
+    }) ;
+    return ast ;
+}
+
+function parse(code) {
+	return acornParse(code, {
+      noNodentExtensions:true, // The partial parser only ever parses vanilla JS
+      locations:false,
+      ranges:false,
+      onComment:null
+    }) ;
+}	
+
+function printNode(n) {
+    if (!n) return '' ;
+    if (Array.isArray(n))
+        return n.map(printNode).join("|\n");
+    try {
+        return outputCode(n) ; //+"\t//@"+Object.keys(n).filter(function(k){ return k[0]==='$'}).map(function(k){ return k+":"+n[k] });
+    } catch (ex) {
+        return ex.message + ": " + (n && n.type);
+    }
+} ;
 
 /* Utils */
 function copyObj(a){
@@ -18,7 +84,11 @@ function btoa(str) {
     if (str instanceof Buffer) {
         buffer = str;
     } else {
-        buffer = new Buffer(str.toString(), 'binary');
+    		if (Buffer.from) {
+    	        buffer = Buffer.from(str.toString(), 'binary');
+    		} else {
+    	        buffer = new Buffer(str.toString(), 'binary');
+    		}
     }
 
     return buffer.toString('base64');
@@ -40,7 +110,11 @@ function compile(code,origFilename,__sourceMapping,opts) {
     }
 
     var pr = this.parse(code,origFilename,null,opts);
-    this.asynchronize(pr,null,opts,this.log || noLogger) ;
+    this.transform(pr,opts,{
+		parse: parse,						// Parse a JS fragment into an AST
+		printNode: printNode,				// Print a node as JS source
+		logger:this.logger || noLogger		// Log a warning
+    }) ;
     this.prettyPrint(pr,opts) ;
     return pr ;
 }
@@ -100,9 +174,9 @@ function parseCode(code,origFilename,__sourceMapping,opts) {
 
     var r = { origCode:code.toString(), filename:origFilename } ;
     try {
-        r.ast = parser.parse(r.origCode, opts && opts.parser) ;
+        r.ast = acornParse(r.origCode, opts && opts.parser) ;
         if (opts.babelTree) {
-            parser.treeWalker(r.ast,function(node,descend,path){
+        		treeSurgeon.treeWalker(r.ast,function(node,descend,path){
                 if (node.type==='Literal')
                     path[0].replace(treeSurgeon.babelLiteralNode(node.value)) ;
                 else if (node.type==='Property') {
@@ -135,14 +209,43 @@ NodentCompiler.prototype.isThenable = function(x) { return x && x instanceof Obj
 NodentCompiler.prototype.compile =  compile ;
 // Exported ; but not to be used lightly!
 NodentCompiler.prototype.parse = parseCode ;
-NodentCompiler.prototype.asynchronize =  treeSurgeon.asynchronize ;
-NodentCompiler.prototype.printNode =  treeSurgeon.printNode ;
 NodentCompiler.prototype.prettyPrint =  prettyPrint ;
 NodentCompiler.prototype.getDefaultCompileOptions = undefined ;
+NodentCompiler.prototype.transform = treeSurgeon.transform ;
+// asynchronize and printNode were previuosly defined in arboriculture, but they are
+// are now (>3.2.0) pulled up into compiler so arboriculture.transform can be called from other 
+// hosts such as babel 7
+NodentCompiler.prototype.asynchronize = function asynchronize(pr, __sourceMapping, opts, logger) {
+    try {
+        var tree = treeSurgeon.transform(pr, opts, {
+	    		parse: parse,						// Parse a JS fragment into an AST
+	    		printNode: printNode,				// Print a node as JS source
+	    		logger:logger						// Log a warning
+        }) ;
+        if (opts.babelTree) {
+        	tree.ast = treeSurgeon.treeWalker(tree.ast, function(node,descend,path){
+        		if (node.type === 'Literal')
+        			path[0].replace(treeSurgeon.babelLiteralNode(node.value)) ;
+        		else 
+        			descend() ;
+        	}) ;
+        }
+        return tree ;
+    } catch (ex) {
+        if (ex instanceof SyntaxError) {
+            var l = pr.origCode.substr(ex.pos - ex.loc.column);
+            l = l.split("\n")[0];
+            ex.message += " (nodent)\n" + l + "\n" + l.replace(/[\S ]/g, "-").substring(0, ex.loc.column) + "^";
+            ex.stack = "";
+        }
+        throw ex;
+    }
+} ;
+NodentCompiler.prototype.printNode = printNode ;
 
 Object.defineProperty(NodentCompiler.prototype,"Promise",{
     get:function (){
-        initOpts.log("Warning: nodent.Promise is deprecated. Use nodent.Thenable instead");
+        console.warn("Warning: nodent.Promise is deprecated. Use nodent.Thenable instead");
         return Thenable;
     },
     enumerable:false,
@@ -159,12 +262,13 @@ NodentCompiler.initialCodeGenOpts = {
     sourcemap:true,
     engine:false,
     parser:{sourceType:'script'},
+    generatedSymbolPrefix:"$",
     $return:"$return",
     $error:"$error",
     $arguments:"$args",
+    $Promise:"Promise",
     $asyncspawn:"$asyncspawn",
     $asyncbind:"$asyncbind",
-    generatedSymbolPrefix:"$",
     $makeThenable:'$makeThenable'
 };
 

data/vendor/node_modules/nodent-compiler/package.json

@@ -1,15 +1,19 @@
 {
   "name": "nodent-compiler",
-  "version": "3.1.7",
+  "version": "3.2.9",
   "description": "NoDent - Asynchronous Javascript language extensions",
   "main": "compiler.js",
   "scripts": {
-    "test": "node tests/basic.js # Please install 'nodent' and test the compiler fully from there."
+    "test": "node tests tests/semantics/*"
   },
   "dependencies": {
     "acorn": ">=2.5.2",
-    "acorn-es7-plugin": ">=1.1.6",
-    "source-map": "^0.5.6"
+    "acorn-es7-plugin": "^1.1.7",
+    "nodent-transform": "^3.2.9",
+    "source-map": "^0.5.7"
+  },
+  "devDependencies": {
+    "nodent-runtime": "^3.2.1"
   },
   "repository": {
     "type": "git",

data/vendor/node_modules/{nodent-compiler/lib → nodent-transform}/arboriculture.js

@@ -1,22 +1,8 @@
 'use strict';
-
 /* We manipulate (abstract syntax) trees */
-var parser = require('./parser');
-var outputCode = require('./output');
 /** Helpers **/
-/*global.printNode = */function printNode(n) {
-    if (!n) return '' ;
-    if (Array.isArray(n))
-        return n.map(printNode).join("|\n");
-    try {
-        return outputCode(n) ; //+"\t//@"+Object.keys(n).filter(function(k){ return k[0]==='$'}).map(function(k){ return k+":"+n[k] });
-    } catch (ex) {
-        return ex.message + ": " + (n && n.type);
-    }
-}
-
 function cloneNode(n) {
-    if (Array.isArray(n))
+    if (Array.isArray(n)) 
         return n.map(function (n) {
         return cloneNode(n);
     });
@@ -29,40 +15,76 @@ function cloneNode(n) {
 
 /* Bit of a hack: without having to search for references to this
  * node, force it to be some replacement node */
-var locationInfo = { start:true, end: true, loc: true, range: true } ;
+var locationInfo = {
+    start: true,
+    end: true,
+    loc: true,
+    range: true
+};
 function coerce(node, replace) {
-    if (node===replace) return ;
+    if (node === replace) 
+        return;
     node.__proto__ = Object.getPrototypeOf(replace);
     Object.keys(node).forEach(function (k) {
-        if (!(k in locationInfo))
+        if (!(k in locationInfo)) 
             delete node[k];
     });
     Object.keys(replace).forEach(function (k) {
-        if (!(k in node))
+        if (!(k in node)) 
             node[k] = replace[k];
     });
 }
 
-function Nothing(){}
+function Nothing() {}
 
 var examinations = {
-        getScope: function(){ return  this.node.type === 'FunctionDeclaration' || this.node.type === 'FunctionExpression' || this.node.type === 'Function' || this.node.type === 'ObjectMethod' || this.node.type === 'ClassMethod' || (this.node.type === 'ArrowFunctionExpression' && this.node.body.type === 'BlockStatement') ? this.node.body.body : this.node.type === 'Program' ? this.node.body : null},
-        isScope: function(){ return  this.node.type === 'FunctionDeclaration' || this.node.type === 'FunctionExpression' || this.node.type === 'Function' || this.node.type === 'Program' || this.node.type === 'ObjectMethod' || this.node.type === 'ClassMethod' || (this.node.type === 'ArrowFunctionExpression' && this.node.body.type === 'BlockStatement')},
-        isFunction: function(){ return  this.node.type === 'FunctionDeclaration' || this.node.type === 'FunctionExpression' || this.node.type === 'Function' || this.node.type === 'ObjectMethod' || this.node.type === 'ClassMethod' || this.node.type === 'ArrowFunctionExpression'},
-        isClass: function(){ return  this.node.type === 'ClassDeclaration' || this.node.type === 'ClassExpression'},
-        isBlockStatement: function(){ return this.node.type==='ClassBody' ||  this.node.type === 'Program' || this.node.type === 'BlockStatement' ? this.node.body : this.node.type === 'SwitchCase' ? this.node.consequent : false},
-        isExpressionStatement: function(){ return  this.node.type === 'ExpressionStatement'},
-        isLiteral: function(){ return  this.node.type === 'Literal' || this.node.type === 'BooleanLiteral' || this.node.type === 'RegExpLiteral' || this.node.type === 'NumericLiteral' || this.node.type === 'StringLiteral' || this.node.type === 'NullLiteral'},
-        isDirective: function(){ return  this.node.type === 'ExpressionStatement' && (this.node.expression.type === 'StringLiteral' || this.node.expression.type === 'Literal' && typeof this.node.expression.value === 'string')},
-        isUnaryExpression: function(){ return  this.node.type === 'UnaryExpression'},
-        isAwait: function(){ return  this.node.type === 'AwaitExpression' && !this.node.$hidden},
-        isAsync: function(){ return  this.node.async },
-        isStatement: function(){ return  this.node.type.match(/[a-zA-Z]+Declaration/) !== null || this.node.type.match(/[a-zA-Z]+Statement/) !== null},
-        isExpression: function(){ return  this.node.type.match(/[a-zA-Z]+Expression/) !== null},
-        isLoop: function(){ return  this.node.type === 'ForStatement' || this.node.type === 'WhileStatement' || this.node.type === 'DoWhileStatement'}, //   Other loops?
-        isJump: function(){ return  this.node.type === 'ReturnStatement' || this.node.type === 'ThrowStatement' || this.node.type === 'BreakStatement' || this.node.type === 'ContinueStatement'},
-        isES6: function(){
-          switch (this.node.type) {
+    getScope: function () {
+        return this.node.type === 'FunctionDeclaration' || this.node.type === 'FunctionExpression' || this.node.type === 'Function' || this.node.type === 'ObjectMethod' || this.node.type === 'ClassMethod' || this.node.type === 'ArrowFunctionExpression' && this.node.body.type === 'BlockStatement' ? this.node.body.body : this.node.type === 'Program' ? this.node.body : null;
+    },
+    isScope: function () {
+        return this.node.type === 'FunctionDeclaration' || this.node.type === 'FunctionExpression' || this.node.type === 'Function' || this.node.type === 'Program' || this.node.type === 'ObjectMethod' || this.node.type === 'ClassMethod' || this.node.type === 'ArrowFunctionExpression' && this.node.body.type === 'BlockStatement';
+    },
+    isFunction: function () {
+        return this.node.type === 'FunctionDeclaration' || this.node.type === 'FunctionExpression' || this.node.type === 'Function' || this.node.type === 'ObjectMethod' || this.node.type === 'ClassMethod' || this.node.type === 'ArrowFunctionExpression';
+    },
+    isClass: function () {
+        return this.node.type === 'ClassDeclaration' || this.node.type === 'ClassExpression';
+    },
+    isBlockStatement: function () {
+        return this.node.type === 'ClassBody' || this.node.type === 'Program' || this.node.type === 'BlockStatement' ? this.node.body : this.node.type === 'SwitchCase' ? this.node.consequent : false;
+    },
+    isExpressionStatement: function () {
+        return this.node.type === 'ExpressionStatement';
+    },
+    isLiteral: function () {
+        return this.node.type === 'Literal' || this.node.type === 'BooleanLiteral' || this.node.type === 'RegExpLiteral' || this.node.type === 'NumericLiteral' || this.node.type === 'StringLiteral' || this.node.type === 'NullLiteral';
+    },
+    isDirective: function () {
+        return this.node.type === 'ExpressionStatement' && (this.node.expression.type === 'StringLiteral' || this.node.expression.type === 'Literal' && typeof this.node.expression.value === 'string');
+    },
+    isUnaryExpression: function () {
+        return this.node.type === 'UnaryExpression';
+    },
+    isAwait: function () {
+        return this.node.type === 'AwaitExpression' && !this.node.$hidden;
+    },
+    isAsync: function () {
+        return this.node.async;
+    },
+    isStatement: function () {
+        return this.node.type.match(/[a-zA-Z]+Declaration/) !== null || this.node.type.match(/[a-zA-Z]+Statement/) !== null;
+    },
+    isExpression: function () {
+        return this.node.type.match(/[a-zA-Z]+Expression/) !== null;
+    },
+    isLoop: function () { //    Other loops?
+        return this.node.type === 'ForStatement' || this.node.type === 'WhileStatement' || this.node.type === 'DoWhileStatement';
+    },
+    isJump: function () {
+        return this.node.type === 'ReturnStatement' || this.node.type === 'ThrowStatement' || this.node.type === 'BreakStatement' || this.node.type === 'ContinueStatement';
+    },
+    isES6: function () {
+        switch (this.node.type) {
             case 'ExportNamedDeclaration':
             case 'ExportSpecifier':
             case 'ExportDefaultDeclaration':
@@ -81,111 +103,36 @@ var examinations = {
             case 'TemplateLiteral':
             case 'ClassDeclaration':
             case 'ClassExpression':
-              return true ;
-
+                return true;
             case 'VariableDeclaration':
-              return this.node.kind && this.node.kind !== 'var' ;
-
+                return this.node.kind && this.node.kind === 'let';
             case 'FunctionDeclaration':
             case 'FunctionExpression':
-              return !!this.node.generator;
+                return !(!this.node.generator);
         }
-      }
+    }
 };
-
-var NodeExaminer = {} ;
-Object.keys(examinations).forEach(function(k){
-    Object.defineProperty(NodeExaminer,k,{
-        get:examinations[k]
-    }) ;
-}) ;
-
+var NodeExaminer = {};
+Object.keys(examinations).forEach(function (k) {
+    Object.defineProperty(NodeExaminer, k, {
+        get: examinations[k]
+    });
+});
 function examine(node) {
-    if (!node)
+    if (!node) 
         return {};
-    NodeExaminer.node = node ;
-    return NodeExaminer ;
-}
-
-/*
- * descendOn = true                     Enter scopes within scopes
- * descendOn = false/undefined/null     Do not enter scopes within scopes
- * descendOn = function                 Descend when function(node) is true
- */
-function contains(ast, fn, descendOn) {
-    if (!ast)
-        return null;
-    if (fn && typeof fn === 'object') {
-        var keys = Object.keys(fn);
-        return contains(ast, function (node) {
-            return keys.every(function (k) {
-                return node[k] == fn[k];
-            });
-        });
-    }
-    var n, found = {};
-    if (Array.isArray(ast)) {
-        for (var i = 0;i < ast.length; i++)
-            if (n = contains(ast[i], fn))
-                return n;
-        return null;
-    }
-
-    var subScopes = descendOn ;
-    if (typeof descendOn !== "function") {
-        if (descendOn) {
-            subScopes = function(n) { return true } ;
-        } else {
-            subScopes = function(n) { return !examine(n).isScope } ;
-        }
-    }
-
-    try {
-        parser.treeWalker(ast, function (node, descend, path) {
-            if (fn(node)) {
-                found.path = path;
-                throw found;
-            }
-            if (node === ast || subScopes(node))
-                descend();
-        });
-    } catch (ex) {
-        if (ex === found)
-            return found.path;
-        throw ex;
-    }
-    return null;
-}
-
-function containsAwait(ast) {
-    return contains(ast, function(n){
-        return n.type==='AwaitExpression' && !n.$hidden
-    });
-}
-
-function containsAwaitInBlock(ast) {
-    return contains(ast, function(n){
-        return n.type==='AwaitExpression'  && !n.$hidden
-    }, function (n) {
-        var x = examine(n) ;
-        return !x.isBlockStatement && !x.isScope
-    });
-}
-
-function containsThis(ast) {
-    return contains(ast, {
-        type: 'ThisExpression'
-    });
+    NodeExaminer.node = node;
+    return NodeExaminer;
 }
 
 function babelLiteralNode(value) {
-    if (value === null)
+    if (value === null) 
         return {
         type: 'NullLiteral',
         value: null,
         raw: 'null'
     };
-    if (value === true || value === false)
+    if (value === true || value === false) 
         return {
         type: 'BooleanLiteral',
         value: value,
@@ -202,7 +149,7 @@ function babelLiteralNode(value) {
             flags: parts[2]
         };
     }
-    if (typeof value === 'number')
+    if (typeof value === 'number') 
         return {
         type: 'NumericLiteral',
         value: value,
@@ -216,6 +163,8 @@ function babelLiteralNode(value) {
 }
 
 function ident(name, loc) {
+	if (!name)
+		throw new Error("Illegal Identifier name") ;
     return {
         type: 'Identifier',
         name: name,
@@ -225,70 +174,166 @@ function ident(name, loc) {
 
 function idents(s) {
     var r = {};
-    for (var k in s)
+    for (var k in s) 
         r[k] = typeof s[k] === "string" ? ident(s[k]) : s[k];
     return r;
 }
 
-function asynchronize(pr, __sourceMapping, opts, logger) {
+function asynchronize(pr, opts, logger, parsePart, printNode) {
     var continuations = {};
     var generatedSymbol = 1;
     var genIdent = {};
+    
     Object.keys(opts).filter(function (k) {
         return k[0] === '$';
     }).forEach(function (k) {
-        genIdent[k.slice(1)] = ident(opts[k]);
+    		if (opts[k])
+    			genIdent[k.slice(1)] = ident(opts[k]);
     });
-
+    /*
+     * descendOn = true                     Enter scopes within scopes
+     * descendOn = false/undefined/null     Do not enter scopes within scopes
+     * descendOn = function                 Descend when function(node) is true
+     */
+    function contains(ast, fn, descendOn) {
+        if (!ast) 
+            return null;
+        if (fn && typeof fn === 'object') {
+            var keys = Object.keys(fn);
+            return contains(ast, function (node) {
+                return keys.every(function (k) {
+                    return node[k] == fn[k];
+                });
+            });
+        }
+        var n, found = {};
+        if (Array.isArray(ast)) {
+            for (var i = 0;i < ast.length; i++) 
+                if (n = contains(ast[i], fn)) 
+                return n;
+            return null;
+        }
+        var subScopes = descendOn;
+        if (typeof descendOn !== "function") {
+            if (descendOn) {
+                subScopes = function (n) {
+                    return true;
+                };
+            } else {
+                subScopes = function (n) {
+                    return !examine(n).isScope;
+                };
+            }
+        }
+        try {
+            treeWalk(ast, function (node, descend, path) {
+                if (fn(node)) {
+                    found.path = path;
+                    throw found;
+                }
+                if (node === ast || subScopes(node)) 
+                    descend();
+            });
+        } catch (ex) {
+            if (ex === found) 
+                return found.path;
+            throw ex;
+        }
+        return null;
+    }
+    
+    function containsAwait(ast) {
+        return contains(ast, function (n) {
+            return n.type === 'AwaitExpression' && !n.$hidden;
+        });
+    }
+    
+    function containsAwaitInBlock(ast) {
+        return contains(ast, function (n) {
+            return n.type === 'AwaitExpression' && !n.$hidden;
+        }, function (n) {
+            var x = examine(n);
+            return !x.isBlockStatement && !x.isScope;
+        });
+    }
+    
+    function containsThis(ast) {
+        return contains(ast, {
+            type: 'ThisExpression'
+        });
+    }
+    
     /* Generate a prototypical call of the form:
      *      (left).$asyncbind(this,...args)
      */
-    function bindAsync(left,arg) {
-        if (opts.es6target && !left.id && !arg && left.type.indexOf("Function")===0) {
-            left.type = 'ArrowFunctionExpression' ;
-            return left ;
+    function bindAsync(left, arg) {
+        if (opts.es6target && !left.id && !arg && left.type.indexOf("Function") === 0) {
+            left.type = 'ArrowFunctionExpression';
+            return left;
         }
-
         if (opts.noRuntime) {
             if (arg) {
                 if (examine(arg).isLiteral) {
-                    throw new Error("Nodent: 'noRuntime' option only compatible with -promise and -engine modes") ;
+                    throw new Error("Nodent: 'noRuntime' option only compatible with -promise and -engine modes");
                 }
                 // Add a global synchronous exception handler to (left)
-                left.body.body = parser.part("try {$:0} catch($2) {return $1($2)}",[cloneNode(left.body),arg,ident('$boundEx')]).body ;
-            } else if (opts.es6target && !left.id && left.type.indexOf("Function")===0) {
-                left.type = 'ArrowFunctionExpression' ;
-                return left ;
+                left.body.body = parsePart("try {$:0} catch($2) {return $1($2)}", [cloneNode(left.body),
+                    arg,ident('$boundEx')]).body;
+            } else if (opts.es6target && !left.id && left.type.indexOf("Function") === 0) {
+                left.type = 'ArrowFunctionExpression';
+                return left;
             }
             if (opts.es6target && !left.id) {
-                left.type = 'ArrowFunctionExpression' ;
+                left.type = 'ArrowFunctionExpression';
                 return left;
             }
-            return parser.part("$0.bind(this)",[left]).expr;
+            if (containsThis(left)) 
+                return parsePart("$0.bind(this)", [left]).expr;
+            return left;
         }
-
-        var params = [{ "type": "ThisExpression" }] ;
-        if (arg) {
-          return parser.part("$0.$1(this,$2)",[left,genIdent.asyncbind,arg]).expr;
+        var subst = {
+            runtime: genIdent.runtime,
+            asyncbind: genIdent.asyncbind,
+            fn: left,
+            arg: arg
+        };
+        if (opts.$runtime) {
+            if (arg) {
+                return parsePart("$runtime.$asyncbind.call($fn,this,$arg)", subst).expr;
+            } else {
+                if (opts.lazyThenables || containsThis(left)) 
+                    return parsePart("$runtime.$asyncbind.call($fn,this)", subst).expr;
+                return left;
+            }
+        } else {
+            if (arg) {
+                return parsePart("$fn.$asyncbind(this,$arg)", subst).expr;
+            } else {
+                if (opts.lazyThenables || containsThis(left)) 
+                    return parsePart("$fn.$asyncbind(this)", subst).expr;
+                return left;
+            }
         }
-        return parser.part("$0.$1(this)",[left,genIdent.asyncbind]).expr;
     }
-
+    
     function makeBoundFn(name, body, argnames, binding) {
-        return parser.part("var $0 = $1",[ident(name),bindAsync({
-                    "type": "FunctionExpression",
-                    "id": null,
-                    "generator": false,
-                    "expression": false,
-                    "params": argnames || [],
-                    "body": Array.isArray(body)?{type:'BlockStatement',body:body}:body
-                }, binding)]).body[0] ;
+        return parsePart("var $0 = $1", [ident(name),bindAsync({
+            "type": "FunctionExpression",
+            "id": null,
+            "generator": false,
+            "expression": false,
+            "params": argnames || [],
+            "body": Array.isArray(body) ? {
+                type: 'BlockStatement',
+                body: body
+            } : body
+        }, binding)]).body[0];
     }
-
+    
     function where(node) {
         return pr.filename + (node && node.loc && node.loc.start ? "(" + node.loc.start.line + ":" + node.loc.start.column + ")\t" : "\t");
     }
-
+    
     function literal(value) {
         if (opts.babelTree) {
             return babelLiteralNode(value);
@@ -300,10 +345,10 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             };
         }
     }
-
+    
     function getMemberFunction(node) {
-        if (!node)
-            return null ;
+        if (!node) 
+            return null;
         if (opts.babelTree && (node.type === 'ClassMethod' || node.type === 'ObjectMethod')) {
             return node;
         } else if ((!opts.babelTree && node.type === 'MethodDefinition' || node.type === 'Property' && (node.method || node.kind == 'get' || node.kind == 'set')) && examine(node.value).isFunction) {
@@ -311,50 +356,47 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         }
         return null;
     }
-
-    var assign$Args = parser.part("var $0 = arguments",[genIdent.arguments]).body[0] ;
-
+    
+    var assign$Args = parsePart("var $0 = arguments", [genIdent.arguments]).body[0];
     /* Replace 'arguments' identifiers in a function. Return true if a
      * replacement has been made and so the symbol opts.$arguments needs
      * initializing.
      */
-    function replaceArguments(ast,nested) {
-        if (!examine(ast).isFunction)
-            throw new Error("Can only replace 'arguments' in functions") ;
-
+    function replaceArguments(ast, nested) {
+        if (!examine(ast).isFunction) 
+            throw new Error("Can only replace 'arguments' in functions");
         if (!('$usesArguments' in ast)) {
-            parser.treeWalker(ast, function (node, descend, path) {
+            treeWalk(ast, function (node, descend, path) {
                 if (node.type === 'Identifier' && node.name === 'arguments') {
                     // Fix up shorthand properties
                     if (path[0].parent.shorthand) {
-                      path[0].parent.shorthand = false ;
-                      path[0].parent.key = ident('arguments') ;
-                      ast.$usesArguments = true ;
+                        path[0].parent.shorthand = false;
+                        path[0].parent.key = ident('arguments');
+                        ast.$usesArguments = true;
                     }
-    
                     // Replace identifiers that are not keys
-                    if (path[0].field !== 'key') {
-                      node.name = opts.$arguments;
-                      ast.$usesArguments = true ;
+                    if (path[0].field !== 'key' && path[0].field !== 'property') {
+                        node.name = opts.$arguments;
+                        ast.$usesArguments = true;
                     }
                 } else if (node === ast || !examine(node).isFunction) {
-                  descend();
-                } else if (node.type==='ArrowFunctionExpression') {
-                    replaceArguments(node) ;
-                    ast.$usesArguments = ast.$usesArguments || node.$usesArguments ;
+                    descend();
+                } else if (node.type === 'ArrowFunctionExpression') {
+                    replaceArguments(node);
+                    ast.$usesArguments = ast.$usesArguments || node.$usesArguments;
                 }
             });
-            ast.$usesArguments = ast.$usesArguments || false ;
+            ast.$usesArguments = ast.$usesArguments || false;
         }
         return ast.$usesArguments && ast.type !== 'ArrowFunctionExpression';
     }
-
+    
     function generateSymbol(node) {
-        if (typeof node != 'string')
-            node = node.type.replace(/Statement|Expression/g,"");
+        if (typeof node != 'string') 
+            node = node.type.replace(/Statement|Expression/g, "");
         return opts.generatedSymbolPrefix + node + "_" + generatedSymbol++;
     }
-
+    
     function setExit(n, sym) {
         if (n) {
             n.$exit = idents({
@@ -364,7 +406,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         }
         return n;
     }
-
+    
     function getExitNode(path) {
         for (var n = 0;n < path.length; n++) {
             if (path[n].self.$exit) {
@@ -376,19 +418,24 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         }
         return null;
     }
-
+    
     function getExit(path, parents) {
         var n = getExitNode(path);
-        if (n)
+        if (n) 
             return n.$exit;
         if (parents) {
-            for (var i = 0;i < parents.length; i++)
-                if (parents[i])
+            for (var i = 0;i < parents.length; i++) 
+                if (parents[i]) 
                 return idents(parents[i]);
         }
         return null;
     }
 
+
+    var looksLikeES6 = opts.es6target || pr.ast.type === 'Program' && pr.ast.sourceType === 'module' || contains(pr.ast, function (n) {
+        return examine(n).isES6;
+    }, true);
+
     // actually do the transforms
     if (opts.engine) {
         // Only Transform extensions:
@@ -398,33 +445,25 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         // - get async id(){} / async get id(){}
         // - super references (in case they are used by async exits - in general they aren't)
         // Everything else is passed through unmolested to be run by a JS engine such as V8 v5.4
-        pr.ast = fixSuperReferences(pr.ast,true);
+        pr.ast = fixSuperReferences(pr.ast, true);
         pr.ast = asyncSpawn(pr.ast, opts.engine);
         pr.ast = exposeCompilerOpts(pr.ast);
-        cleanCode(pr.ast)
+        cleanCode(pr.ast);
     } else if (opts.generators) {
         // Transform to generators
         pr.ast = fixSuperReferences(pr.ast);
         pr.ast = asyncSpawn(pr.ast);
         pr.ast = exposeCompilerOpts(pr.ast);
-        cleanCode(pr.ast)
+        cleanCode(pr.ast);
     } else {
         // Transform to callbacks, optionally with Promises
         pr.ast = fixSuperReferences(pr.ast);
         asyncTransforms(pr.ast);
     }
-    if (opts.babelTree) {
-        parser.treeWalker(pr.ast, function (node, descend, path) {
-            descend();
-            if (node.type === 'Literal') {
-                coerce(node, literal(node.value));
-            }
-        });
-    }
     return pr;
-
+    
     function asyncTransforms(ast, awaitFlag) {
-        var useLazyLoops = !(opts.promises || opts.generators || opts.engine) && opts.lazyThenables ;
+        var useLazyLoops = !(opts.promises || opts.generators || opts.engine) && opts.lazyThenables;
         // Because we create functions (and scopes), we need all declarations before use
         blockifyArrows(ast);
         hoistDeclarations(ast);
@@ -436,31 +475,32 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         // Loops are asynchronized in an odd way - the loop is turned into a function that is
         // invoked through tail recursion OR callback. They are like the inner functions of
         // async functions to allow for completion and throwing
-        (useLazyLoops?asyncLoops_1:Nothing)(ast);
+        (useLazyLoops ? asyncLoops_1 : Nothing)(ast);
         // Handle the various JS control flow keywords by splitting into continuations that could
         // be invoked asynchronously
         mapLogicalOp(ast);
         mapCondOp(ast);
-        walkDown(ast, [mapTryCatch,(useLazyLoops?Nothing:mapLoops),mapIfStmt,mapSwitch,mapBlock]);
+        walkDown(ast, [mapTryCatch,useLazyLoops ? Nothing : mapLoops,mapIfStmt,mapSwitch,
+            mapBlock]);
         // Map awaits by creating continuations and passing them into the async resolver
         asyncAwait(ast, awaitFlag);
         exposeCompilerOpts(ast);
         // Remove guff generated by transpiling
         cleanCode(ast);
     }
-
+    
     /* Create a 'continuation' - a block of statements that have been hoisted
      * into a named function so they can be invoked conditionally or asynchronously */
     function makeContinuation(name, body) {
         var ctn = {
             $continuation: true,
-            type: name?'FunctionDeclaration':'FunctionExpression',
-                id: name?typeof name==="string"?ident(name):name:undefined,
-                    params: [],
-                    body: {
-                        type: 'BlockStatement',
-                        body: cloneNode(body)
-                    }
+            type: name ? 'FunctionDeclaration' : 'FunctionExpression',
+            id: name ? typeof name === "string" ? ident(name) : name : undefined,
+            params: [],
+            body: {
+                type: 'BlockStatement',
+                body: cloneNode(body)
+            }
         };
         if (name) {
             continuations[name] = {
@@ -469,7 +509,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         }
         return ctn;
     }
-
+    
     /* Generate an expression AST the immediate invokes the specified async function, e.g.
      *      (await ((async function(){ ...body... })()))
      */
@@ -487,9 +527,9 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                     "body": body
                 }
             }).body.body[0].argument
-        }
+        };
     }
-
+    
     /* Used to invoke a 'continuation' - a function that represents
      * a block of statements lifted out so they can be labelled (as
      * a function definition) to be invoked via multiple execution
@@ -497,20 +537,23 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
      * in the original scope of the statements, the continuation function
      * must also have the correct 'this'.*/
     function thisCall(name, args) {
-        if (typeof name === 'string')
+        if (typeof name === 'string') 
             name = ident(name);
-        var n = parser.part("$0.call($1)",[name,[{"type": "ThisExpression"}].concat(args || [])]).expr ;
+        var n = parsePart("$0.call($1)", [name,[{
+            "type": "ThisExpression"
+        }].concat(args || [])]).expr;
         name.$thisCall = n;
         n.$thisCallName = name.name;
         return n;
     }
-    function returnThisCall(name,args) {
+    
+    function returnThisCall(name, args) {
         return {
-            type:'ReturnStatement',
-            argument: thisCall(name,args)
-        }
+            type: 'ReturnStatement',
+            argument: thisCall(name, args)
+        };
     }
-
+    
     function deferredFinally(node, expr) {
         return {
             "type": "CallExpression",
@@ -518,7 +561,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             "arguments": expr ? [expr] : []
         };
     }
-
+    
     /**
      * returnMapper is an Uglify2 transformer that is used to change statements such as:
      *     return some-expression ;
@@ -536,8 +579,8 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             });
         }
         var lambdaNesting = 0;
-        var tryNesting = 0 ;
-        return parser.treeWalker(n, function (node, descend, path) {
+        var tryNesting = 0;
+        return treeWalk(n, function (node, descend, path) {
             if (node.type === 'ReturnStatement' && !node.$mapped) {
                 if (lambdaNesting > 0) {
                     if (!examine(node).isAsync) {
@@ -571,7 +614,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 }
                 return;
             } else if (node.type === 'ThrowStatement') {
-                var isAsync = examine(node).isAsync ;
+                var isAsync = examine(node).isAsync;
                 if (lambdaNesting > 0) {
                     if (!isAsync) {
                         return descend(node);
@@ -579,22 +622,22 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                     delete node.async;
                 }
                 if (!isAsync && tryNesting) {
-                    descend() ;
+                    descend();
                 } else {
-                  node.type = 'ReturnStatement';
-                  node.$mapped = true;
-                  node.argument = {
-                      type: 'CallExpression',
-                      callee: getExit(path, [opts]).$error,
-                      arguments: [node.argument]
-                  };
+                    node.type = 'ReturnStatement';
+                    node.$mapped = true;
+                    node.argument = {
+                        type: 'CallExpression',
+                        callee: getExit(path, [opts]).$error,
+                        arguments: [node.argument]
+                    };
                 }
                 return;
             } else if (node.type === 'TryStatement') {
-              tryNesting++;
-              descend(node);
-              tryNesting--;
-              return;
+                tryNesting++;
+                descend(node);
+                tryNesting--;
+                return;
             } else if (examine(node).isFunction) {
                 lambdaNesting++;
                 descend(node);
@@ -606,7 +649,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             }
         }, path);
     }
-
+    
     /*
     To implement conditional execution, a?b:c is mapped to
 
@@ -615,21 +658,22 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
       Note that 'await (async function(){})()' can be optimized to a Thenable since no args are passed
    */
     function mapCondOp(ast, state) {
-        if (Array.isArray(ast))
+        if (Array.isArray(ast)) 
             return ast.map(function (n) {
             return mapCondOp(n, state);
         });
-        parser.treeWalker(ast, function (node, descend, path) {
+        treeWalk(ast, function (node, descend, path) {
             descend();
             if (node.type === 'ConditionalExpression' && (containsAwait(node.alternate) || containsAwait(node.consequent))) {
                 var z = ident(generateSymbol("condOp"));
-                var xform = internalIIAFE(parser.part("if ($0) return $1 ; return $2",[node.test,node.consequent,node.alternate]).body);
+                var xform = internalIIAFE(parsePart("if ($0) return $1 ; return $2", [node.test,
+                    node.consequent,node.alternate]).body);
                 coerce(node, xform);
             }
         }, state);
         return ast;
     }
-
+    
     /*
       To implement conditional execution, logical operators with an awaited RHS are mapped thus:
 
@@ -639,56 +683,57 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         Note that 'await (async function(){})()' can be optimized to a Thenable since no args are passed
      */
     function mapLogicalOp(ast, state) {
-        if (Array.isArray(ast))
+        if (Array.isArray(ast)) 
             return ast.map(function (n) {
             return mapLogicalOp(n, state);
         });
-        parser.treeWalker(ast, function (node, descend, path) {
+        treeWalk(ast, function (node, descend, path) {
             descend();
             if (node.type === 'LogicalExpression' && containsAwait(node.right)) {
                 var codeFrag;
                 var z = ident(generateSymbol("logical" + (node.operator === '&&' ? "And" : "Or")));
-
                 if (node.operator === '||') {
-                    codeFrag = "var $0; if (!($0 = $1)) {$0 = $2} return $0" ;
+                    codeFrag = "var $0; if (!($0 = $1)) {$0 = $2} return $0";
                 } else if (node.operator === '&&') {
-                    codeFrag = "var $0; if ($0 = $1) {$0 = $2} return $0" ;
-                } else
-                    throw new Error(where(node) + "Illegal logical operator: "+node.operator);
-
-                coerce(node, internalIIAFE(parser.part(codeFrag,[z,node.left, node.right]).body));
+                    codeFrag = "var $0; if ($0 = $1) {$0 = $2} return $0";
+                } else 
+                    throw new Error(where(node) + "Illegal logical operator: " + node.operator);
+                coerce(node, internalIIAFE(parsePart(codeFrag, [z,node.left,node.right]).body));
             }
         }, state);
         return ast;
     }
-
+    
     function mapBlock(block, path, down) {
         if (block.type !== "SwitchCase" && examine(block).isBlockStatement) {
-            var idx = 0 ;
+            var idx = 0;
             while (idx < block.body.length) {
-                var node = block.body[idx] ;
+                var node = block.body[idx];
                 if (node.type !== "SwitchCase" && examine(node).isBlockStatement) {
-                    var blockScoped = containsBlockScopedDeclarations(node.body) ;
+                    var blockScoped = containsBlockScopedDeclarations(node.body);
                     if (!blockScoped) {
-                        block.body.splice.apply(block.body,[idx,1].concat(node.body));
+                        block.body.splice.apply(block.body, [idx,1].concat(node.body));
                     } else {
                         if (containsAwaitInBlock(node)) {
                             var symName = generateSymbol(node);
                             var deferredCode = block.body.splice(idx + 1, block.body.length - (idx + 1));
                             if (deferredCode.length) {
                                 var ctn = makeContinuation(symName, deferredCode);
-                                delete continuations[symName] ;
+                                delete continuations[symName];
                                 node.body.push(returnThisCall(symName));
-                                block.body.push(ctn) ;
-                                idx++ ;
-                            } else idx++ ;
-                        } else idx++ ;
+                                block.body.push(ctn);
+                                idx++;
+                            } else 
+                                idx++;
+                        } else 
+                            idx++;
                     }
-                } else idx++ ;
+                } else 
+                    idx++;
             }
         }
     }
-
+    
     /*
      * Translate:
   if (x) { y; } more... ;
@@ -714,12 +759,12 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                     var call = returnThisCall(symName);
                     synthBlock.body.push(down(makeContinuation(symName, deferredCode)));
                     [ifStmt.consequent,ifStmt.alternate].forEach(function (cond) {
-                        if (!cond)
+                        if (!cond) 
                             return;
                         var blockEnd;
-                        if (!examine(cond).isBlockStatement)
+                        if (!examine(cond).isBlockStatement) 
                             blockEnd = cond;
-                         else
+                         else 
                             blockEnd = cond.body[cond.body.length - 1];
                         if (!(blockEnd && blockEnd.type === 'ReturnStatement')) {
                             if (!(cond.type === 'BlockStatement')) {
@@ -735,7 +780,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                     });
                     // If both blocks are transformed, the trailing call to $post_if()
                     // can be omitted as it'll be unreachable via a synchronous path
-                    if (!(ifStmt.consequent && ifStmt.alternate && ifStmt.consequent.$deferred && ifStmt.alternate.$deferred))
+                    if (!(ifStmt.consequent && ifStmt.alternate && ifStmt.consequent.$deferred && ifStmt.alternate.$deferred)) 
                         synthBlock.body.push(cloneNode(call));
                 }
             } else {
@@ -743,7 +788,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             }
         }
     }
-
+    
     function mapSwitch(switchStmt, path, down) {
         if (!switchStmt.$switched && switchStmt.type === 'SwitchStatement' && containsAwait(switchStmt.cases)) {
             switchStmt.$switched = true;
@@ -751,7 +796,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             if ('index' in ref) {
                 var j = ref.index + 1;
                 deferredCode = ref.parent[ref.field].splice(j, ref.parent[ref.field].length - j);
-                if (deferredCode.length && deferredCode[deferredCode.length - 1].type === 'BreakStatement')
+                if (deferredCode.length && deferredCode[deferredCode.length - 1].type === 'BreakStatement') 
                     ref.parent[ref.field].push(deferredCode.pop());
                 symName = generateSymbol(switchStmt);
                 deferred = returnThisCall(symName);
@@ -766,7 +811,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 if (containsAwait(caseStmt.consequent)) {
                     var end = caseStmt.consequent[caseStmt.consequent.length - 1];
                     if (end.type === 'BreakStatement') {
-                        caseStmt.consequent[caseStmt.consequent.length - 1] = cloneNode(deferred) ;
+                        caseStmt.consequent[caseStmt.consequent.length - 1] = cloneNode(deferred);
                     } else if (end.type === 'ReturnStatement' || end.type === 'ThrowStatement') {} else {
                         // Do nothing - block ends in return or throw
                         logger(where(caseStmt) + "switch-case fall-through not supported - added break. See https://github.com/MatAtBread/nodent#differences-from-the-es7-specification");
@@ -777,27 +822,27 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             return true;
         }
     }
-
+    
     function isExitStatement(n) {
-        return n.type==='ReturnStatement' || n.type==='ThrowStatement'
+        return n.type === 'ReturnStatement' || n.type === 'ThrowStatement';
     }
+    
     /* Give unique names to TryCatch blocks */
-    function labelTryCatch(ast,engineMode) {
-        parser.treeWalker(ast, function (node, descend, path) {
+    function labelTryCatch(ast, engineMode) {
+        treeWalk(ast, function (node, descend, path) {
             if (node.type === 'TryStatement' && !node.$seh) {
                 if (!examine(path[0].parent).isBlockStatement) {
-                  path[0].parent[path[0].field] = {
-                    type:'BlockStatement',
-                    body:[node]
-                  } ;
+                    path[0].parent[path[0].field] = {
+                        type: 'BlockStatement',
+                        body: [node]
+                    };
                 }
                 // Every try-catch needs a name, so asyncDefine/asyncAwait knows who's handling errors
                 node.$seh = generateSymbol("Try") + "_";
-                node.$containedAwait = !!containsAwait(node);
-                node.$finallyExit = node.finalizer && inAsync(path) && !!contains(node.finalizer.body,isExitStatement) ;
-
+                node.$containedAwait = !(!containsAwait(node));
+                node.$finallyExit = node.finalizer && inAsync(path) && !(!contains(node.finalizer.body, isExitStatement));
                 if (node.$containedAwait || node.$finallyExit) {
-                    node.$needsMapping = engineMode? !node.$finallyExit : true ;
+                    node.$needsMapping = engineMode ? !node.$finallyExit : true;
                     var parent = getExit(path, [opts]);
                     if (node.finalizer && !node.handler) {
                         // We have a finally, but no 'catch'. Create the default catch clause 'catch(_ex) { throw _ex }'
@@ -841,24 +886,24 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         });
         return ast;
     }
-
-    function afterDirectives(body,nodes) {
-        for (var i=0; i<body.length; i++) {
-            if (examine(body[i]).isDirective)
-                continue ;
-            body.splice.apply(body,[i,0].concat(nodes)) ;
-            return ;
+    
+    function afterDirectives(body, nodes) {
+        for (var i = 0;i < body.length; i++) {
+            if (examine(body[i]).isDirective) 
+                continue;
+            body.splice.apply(body, [i,0].concat(nodes));
+            return;
         }
-        body.splice.apply(body,[body.length,0].concat(nodes)) ;
+        body.splice.apply(body, [body.length,0].concat(nodes));
     }
-
+    
     function inAsync(path) {
-        for (var i=0; i<path.length; i++)
-            if (examine(path[i].self).isFunction)
-                return path[i].self.async || path[i].self.$wasAsync ;
-        return false ;
+        for (var i = 0;i < path.length; i++) 
+            if (examine(path[i].self).isFunction) 
+            return path[i].self.async || path[i].self.$wasAsync;
+        return false;
     }
-
+    
     function mapTryCatch(node, path, down) {
         if (node.$needsMapping) {
             var continuation, ctnName, catchBody;
@@ -867,11 +912,10 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 var i = ref.index + 1;
                 var afterTry = ref.parent[ref.field].splice(i, ref.parent[ref.field].length - i);
                 if (afterTry.length) {
-                    ctnName = node.$seh + "Post";
-                    var afterContinuation = down(makeBoundFn(ctnName, afterTry, [], getExit(path, [opts]).$error));
-                    ref.parent[ref.field].splice(ref.index,0,afterContinuation);
-                    continuation = parser.part("return $0()",
-                        [node.finalizer ? deferredFinally(node, ident(ctnName)) : ident(ctnName)]).body[0] ;
+                    ctnName = ident(node.$seh + "Post") ;
+                    var afterContinuation = down(makeBoundFn(ctnName.name, afterTry, [], getExit(path, [opts]).$error));
+                    ref.parent[ref.field].splice(ref.index, 0, afterContinuation);
+                    continuation = parsePart("return $0()", [node.finalizer ? deferredFinally(node, ctnName) : ctnName]).body[0];
                 } else if (node.finalizer) {
                     continuation = returnThisCall(deferredFinally(node));
                 }
@@ -887,28 +931,27 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             if (node.handler) {
                 var symCatch = ident(node.$seh + "Catch");
                 catchBody = cloneNode(node.handler.body);
+                down(catchBody);
                 var catcher = makeBoundFn(symCatch.name, catchBody, [cloneNode(node.handler.param)], node.finalizer ? deferredFinally(node, binding.$error) : binding.$error);
                 node.handler.body.body = [{
                     type: 'CallExpression',
                     callee: symCatch,
                     arguments: [cloneNode(node.handler.param)]
                 }];
-                ref.parent[ref.field].splice(ref.index,0,catcher) ;
+                ref.parent[ref.field].splice(ref.index, 0, catcher);
             }
             if (node.finalizer) {
-                down(node.finalizer) ;
+                down(node.finalizer);
                 var finalParams = {
-                    exit:ident(node.$seh + "Exit"),
-                    value:ident(node.$seh + "Value"),
-                    body:cloneNode(node.finalizer.body),
-                } ;
-
-                var chainFinalize = parser.part(
-                    "(function ($value) {                                      "+
-                    "       $:body;                                           "+
-                    "       return $exit && ($exit.call(this, $value));        "+
-                    "   })",finalParams).expr ;
-
+                    exit: ident(node.$seh + "Exit"),
+                    value: ident(node.$seh + "Value"),
+                    body: cloneNode(node.finalizer.body)
+                };
+                var chainFinalize = parsePart(
+                		"(function ($value) {                                  " + 
+                		"    $:body;                                           " + 
+                		"   return $exit && ($exit.call(this, $value));        " + 
+                		"})", finalParams).expr;
                 var finalizer = {
                     type: 'VariableDeclaration',
                     kind: 'var',
@@ -916,41 +959,38 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         type: "VariableDeclarator",
                         id: ident(node.$seh + "Finally"),
                         init: bindAsync({
-                            type:'FunctionExpression',
-                            params:[finalParams.exit],
-                            id:null,
-                            body:{
-                                type:'BlockStatement',
-                                body:[{
+                            type: 'FunctionExpression',
+                            params: [finalParams.exit],
+                            id: null,
+                            body: {
+                                type: 'BlockStatement',
+                                body: [{
                                     type: 'ReturnStatement',
-                                    argument: bindAsync(chainFinalize,binding.$error)
+                                    argument: bindAsync(chainFinalize, binding.$error)
                                 }]
                             }
                         })
                     }]
-                } ;
-
-                afterDirectives(ref.parent[ref.field],[finalizer]);
-                var callFinally = parser.part("return $0()",
-                    [node.finalizer ? deferredFinally(node, ident(ctnName)) : ident(ctnName)]).body[0] ;
+                };
+                afterDirectives(ref.parent[ref.field], [finalizer]);
+                var callFinally = cloneNode(continuation) ;//parsePart("return $0()", [node.finalizer ? deferredFinally(node, ctnName) : ctnName]).body[0];
                 catchBody.body[catchBody.length - 1] = callFinally;
                 node.block.body[node.block.body.length - 1] = callFinally;
                 delete node.finalizer;
             }
         }
     }
-
+    
     function walkDown(ast, mappers, state) {
         var walked = [];
-
-        function closedWalk(ast,state) {
-            return parser.treeWalker(ast, function (node, descend, path) {
+        function closedWalk(ast, state) {
+            return treeWalk(ast, function (node, descend, path) {
                 function walkDownSubtree(node) {
                     return closedWalk(node, path);
                 }
-
+                
                 if (walked.indexOf(node) < 0) {
-                    walked.push(node) ;
+                    walked.push(node);
                     mappers.forEach(function (m) {
                         m(node, path, walkDownSubtree);
                     });
@@ -959,20 +999,20 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 return;
             }, state);
         }
-
-        closedWalk(ast,state)
-        return ast ;
+        
+        closedWalk(ast, state);
+        return ast;
     }
-
+    
     function asyncAwait(ast, inAsync, parentCatcher) {
-        parser.treeWalker(ast, function (node, descend, path) {
+        treeWalk(ast, function (node, descend, path) {
             if (node.type == 'IfStatement') {
-                if (node.consequent.type != 'BlockStatement' && containsAwait(node.consequent))
+                if (node.consequent.type != 'BlockStatement' && containsAwait(node.consequent)) 
                     node.consequent = {
                     type: 'BlockStatement',
                     body: [node.consequent]
                 };
-                if (node.alternate && node.alternate.type != 'BlockStatement' && containsAwait(node.alternate))
+                if (node.alternate && node.alternate.type != 'BlockStatement' && containsAwait(node.alternate)) 
                     node.alternate = {
                     type: 'BlockStatement',
                     body: [node.alternate]
@@ -989,9 +1029,9 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 });
                 if (!inAsync || inAsync === "warn") {
                     var errMsg = where(node) + "'await' used inside non-async function. ";
-                    if (opts.promises)
+                    if (opts.promises) 
                         errMsg += "'return' value Promise runtime-specific";
-                     else
+                     else 
                         errMsg += "'return' value from await is synchronous";
                     logger(errMsg + ". See https://github.com/MatAtBread/nodent#differences-from-the-es7-specification");
                 }
@@ -1013,7 +1053,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         break;
                     }
                 }
-                if (!stmt)
+                if (!stmt) 
                     throw new Error(where(node) + "Illegal await not contained in a statement");
                 var containingExits = getExit(path, [parentCatcher,opts]);
                 var i = stmt.index;
@@ -1036,7 +1076,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         }, inAsync, containingExits)
                     };
                 } else {
-                    if (callBack.length)
+                    if (callBack.length) 
                         callback = {
                         type: 'FunctionExpression',
                         params: [cloneNode(result)],
@@ -1059,7 +1099,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 // Wrap the callback statement(s) in a Block and transform them
                 if (!returner) {
                     if (callback) {
-                        returner = bindAsync(callback,containingExits.$error) ;
+                        returner = bindAsync(callback, containingExits.$error);
                     } else {
                         returner = {
                             type: 'FunctionExpression',
@@ -1075,11 +1115,11 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                     expr = {
                         type: 'CallExpression',
                         arguments: [expr],
-                        callee: (opts.promises || opts.generators)?{
+                        callee: opts.promises || opts.generators ? {
                             type: 'MemberExpression',
-                            object: ident('Promise'),
+                            object: genIdent.Promise,
                             property: ident('resolve')
-                        }:{
+                        } : {
                             // ES7 makeThenable
                             type: 'MemberExpression',
                             object: ident('Object'),
@@ -1107,30 +1147,28 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         });
         return ast;
     }
-
+    
     // Transform a for..in into it's iterative equivalent
     function transformForIn(node, path) {
-        var label = node.$label ;
-        delete node.$label ;
-
-        var idx = ident(generateSymbol("idx"))
+        var label = node.$label;
+        delete node.$label;
+        var idx = ident(generateSymbol("idx"));
         var inArray = ident(generateSymbol("in"));
-        var declVars = parser.part("var $0,$1 = [];for ($0 in $2) $1.push($0)",[idx,inArray,node.right]).body ;
-        var loop = parser.part("for ($0; $1.length;){ $2 = $1.shift(); $:3 ; }",[
-            node.left,
-            inArray,
-            node.left.type === 'VariableDeclaration' ? node.left.declarations[0].id : node.left,
-            node.body]).body[0] ;
-        loop.$label = label ;
-        for (var b=0; b<path.length; b++) {
+        var declVars = parsePart("var $0,$1 = [];for ($0 in $2) $1.push($0)", [idx,
+            inArray,node.right]).body;
+        var loop = parsePart("for ($0; $1.length;){ $2 = $1.shift(); $:3 ; }", [node.left,
+            inArray,node.left.type === 'VariableDeclaration' ? node.left.declarations[0].id : node.left,
+            node.body]).body[0];
+        loop.$label = label;
+        for (var b = 0;b < path.length; b++) {
             if (examine(path[b].parent).isBlockStatement) {
-                path[b].parent[path[b].field].splice(path[b].index,0,declVars[0],declVars[1]) ;
-                break ;
+                path[b].parent[path[b].field].splice(path[b].index, 0, declVars[0], declVars[1]);
+                break;
             }
         }
-        coerce(node,loop) ;
+        coerce(node, loop);
     }
-
+    
     // Transform a for..of into it's iterative equivalent
     function iterizeForOf(node, path) {
         if (node.body.type !== 'BlockStatement') {
@@ -1139,22 +1177,23 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 body: [node.body]
             };
         }
-        var index, iterator, initIterator = parser.part("[$0[Symbol.iterator]()]",[node.right]).expr;
-
+        var index, iterator, initIterator = parsePart("[$0[Symbol.iterator]()]", [node.right]).expr;
         if (node.left.type === 'VariableDeclaration') {
-            if (node.left.kind==='const')
-                node.left.kind = 'let' ;
-
-            index = node.left.declarations[0].id ;
-            var decls = getDeclNames(node.left.declarations[0].id) ;
+            if (node.left.kind === 'const') 
+                node.left.kind = 'let';
+            if (node.left.kind === 'let') { 
+            	    node.update = literal(null) ;
+                node.update.$EmptyExpression = true ;
+            }
+            index = node.left.declarations[0].id;
+            var decls = getDeclNames(node.left.declarations[0].id);
             iterator = ident(generateSymbol("iterator_" + decls.join('_')));
-
-            node.left.declarations = decls.map(function(name){
+            node.left.declarations = decls.map(function (name) {
                 return {
                     type: "VariableDeclarator",
                     id: ident(name)
-                } ;
-            }) ;
+                };
+            });
             node.left.declarations.push({
                 type: "VariableDeclarator",
                 id: iterator,
@@ -1176,282 +1215,276 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             node.init = declaration;
         }
         node.type = 'ForStatement';
-        node.test = parser.part("!($0[1] = $0[0].next()).done && (($1 = $0[1].value) || true)",[iterator,index]).expr ;
+        node.test = parsePart("!($0[1] = $0[0].next()).done && (($1 = $0[1].value) || true)", [iterator,
+            index]).expr;
         delete node.left;
         delete node.right;
     }
-
+    
     /* Map loops */
     /* As of v3.0.0 loops are asynchronized via a trampoline to prevent stack overflow in big loops with no actionable awaits. */
     function mapLoops(node, path, down) {
-        var depth = node.$depth ;
+        var depth = node.$depth;
         if (node.type === 'ForInStatement' && containsAwait(node)) {
-          transformForIn(node, path) ;
+            transformForIn(node, path);
         } else if (node.type === 'ForOfStatement' && containsAwait(node)) {
-          iterizeForOf(node, path);
+            iterizeForOf(node, path);
         }
-
         // Are we inside a loop that has already been asynchronized and is labelled?
-        var inAsyncLoop = path.some(function(p){
-            return ('$label' in p.self && p.self.type==='ForStatement' && p.self.$mapped) ;
-        }) ;
-
+        var inAsyncLoop = path.some(function (p) {
+            return '$label' in p.self && p.self.type === 'ForStatement' && p.self.$mapped;
+        });
         // Check if the loop contains an await, or a labelled exit if we're inside an async loop
-        function mappableLoop(n){
-            return (n.type==='AwaitExpression' && !n.$hidden)
-                || (inAsyncLoop && (n.type==='BreakStatement'|| n.type==='ContinueStatement') && n.label)
-        };
-
-        if (!node.$mapped && examine(node).isLoop && contains(node,mappableLoop)) {
-          path[0].self.$mapped = true ;
-          var p ;
-          var mapped = [] ;
-          var init = node.init;
-          var test = node.test || literal(true);
-          var step = node.update;
-          var body = node.body;
-
-          if (step) {
-            step = {
-              type:'ExpressionStatement',
-              expression: step
-            } ;
-          }
-
-          if (init) {
-            if (!examine(init).isStatement) {
-              init = {
-                type: 'ExpressionStatement',
-                expression: init
-              };
-            }
-            mapped.push(init) ;
-          }
-
-          var ref, label ;
-          if (node.$label) {
-            label = node.$label.name ;
-            ref = path[1] ;
-          } else {
-            label = generatedSymbol++ ;
-            ref = path[0] ;
-          }
-
-          label = opts.generatedSymbolPrefix + "Loop_" + label;
-          var idTrampoline = ident(label + "_trampoline") ;
-          var idIter = ident(label) ;
-          var idStep = step ? ident(label + "_step") : idIter ;
-          var idContinuation  = ident(label + "_exit") ;
-          var idBounce = ident("q") ;
-          var idCatchParam = ident("$exception") ;
-          var continuation, deferredCode ;
-
-          if ('index' in ref) {
-            var idx = ref.index;
-            deferredCode = ref.parent[ref.field].splice(idx + 1, ref.parent[ref.field].length - (idx + 1));
-          } else {
-            deferredCode = [] ;
-          }
-
-          continuation = makeContinuation(idContinuation, deferredCode) ;
-          var returnIter = {
-            "type": "ReturnStatement",
-            "argument": idIter
-          } ;
-
-          var returnStep = {
-              "type": "ReturnStatement",
-              "argument": idStep
-          } ;
-
-          var returnBreak = {
-              type: 'ReturnStatement',
-              argument: {
-                  "type": "ArrayExpression",
-                  "elements":[literal(1)]
-              }
-          };
-
-          parser.treeWalker(body, function mapExits(n, descend, subpath) {
-              if (examine(n).isFunction || examine(n).isLoop) {
-                  return true;
-              } else if (n.type === 'BreakStatement' || n.type === 'ContinueStatement') {
-                  if (n.label) {
-                      var labelStack = subpath.filter(function(p){
-                          return '$label' in p.self
-                      }).map(function(p,idx){
-                          return p.self.$label && p.self.$label.name
-                      }) ;
-
-                      // Work out how many loops to exit by examining subpath.
-                      var loops = [] ;
-                      for (var l=0; l<labelStack.length; l++) {
-                          if (labelStack[l] === n.label.name) {
-                              if (n.type === 'BreakStatement')
-                                  loops.push(literal(1)) ;
-                              subpath[0].replace({
-                                  type: 'ReturnStatement',
-                                  argument: {
-                                      "type": "ArrayExpression",
-                                      "elements":loops.reverse()
-                                  }
-                              }) ;
-                              break ;
-                          }
-                          loops.push(literal(0)) ;
-                      }
-                  } else {
-                      if (n.type === 'BreakStatement')
-                          subpath[0].replace(returnBreak) ;
-                      else // continue;
-                          subpath[0].replace(returnStep) ;
-                  }
-              } else {
-                descend();
-              }
-          },path) ;
-
-          if (body.type === 'BlockStatement')
-            body = body.body.slice(0) ;
-          else
-            body = [body] ;
-
-          if (node.type==='DoWhileStatement') {
-            body = body.concat({
-              "type": "IfStatement",
-              "test": {
-                type:'UnaryExpression',
-                argument:test,
-                prefix:true,
-                operator:'!'
-              },
-              "consequent": returnBreak,
-              alternate:returnStep
-            }) ;
-          } else {
-            body = [{
-              "type": "IfStatement",
-              "test": test,
-              "consequent": {
-                "type": "BlockStatement",
-                "body": body.concat(returnStep)
-              },
-              alternate:returnBreak
-            }] ;
-          }
-
-          if (opts.noRuntime) {
-              mapped.push({
-                  "type": "VariableDeclaration",
-                  "declarations": [{
-                    "type": "VariableDeclarator",
-                    "id": idTrampoline
-                  }],
-                  "kind": "var"
-                }) ;
-          }
-          var invokeIterate ;
-          var exit = getExit(path, [opts]).$error ;
-          if (opts.noRuntime) {
-            invokeIterate = parser.part(
-                opts.es6target?
-                    "($idTrampoline = ((q) => { "+
-                    "    $$setMapped: while (q) { "+
-                    "         if (q.then)  "+
-                    (depth===1?
-                    "             return void q.then($idTrampoline, $exit); ":
-                    "             return q.then($idTrampoline, $exit); ")+
-                    "         try { "+
-                    "             if (q.pop)  "+
-                    "                 if (q.length)  "+
-                    "                 return q.pop() ? $idContinuation.call(this) : q; "+
-                    "              else  "+
-                    "                 q = $idStep; "+
-                    "              else  "+
-                    "                 q = q.call(this) "+
-                    "          } catch (_exception) { "+
-                    "             return $exit(_exception); "+
-                    "          } "+
-                    "     } "+
-                    "}))($idIter)":
-                    "($idTrampoline = (function (q) { "+
-                    "    $$setMapped: while (q) { "+
-                    "         if (q.then)  "+
-                    (depth===1?
-                    "             return void q.then($idTrampoline, $exit); ":
-                    "             return q.then($idTrampoline, $exit); ")+
-                    "         try { "+
-                    "             if (q.pop)  "+
-                    "                 if (q.length)  "+
-                    "                 return q.pop() ? $idContinuation.call(this) : q; "+
-                    "              else  "+
-                    "                 q = $idStep; "+
-                    "              else  "+
-                    "                 q = q.call(this) "+
-                    "          } catch (_exception) { "+
-                    "             return $exit(_exception); "+
-                    "          } "+
-                    "     } "+
-                    "}).bind(this))($idIter)",
+        function mappableLoop(n) {
+            return n.type === 'AwaitExpression' && !n.$hidden || inAsyncLoop && (n.type === 'BreakStatement' || n.type === 'ContinueStatement') && n.label;
+        }
+        
+        if (!node.$mapped && examine(node).isLoop && contains(node, mappableLoop)) {
+            path[0].self.$mapped = true;
+            var p;
+            var mapped = [];
+            var init = node.init;
+            var test = node.test || literal(true);
+            var step = node.update;
+            var body = node.body;
+            var localised = init && init.type === 'VariableDeclaration' && (init.kind === 'let' || init.kind === 'const');
+            if (localised) {
+                init.kind = 'let';
+            }
+            if (step) {
+                step = {
+                    type: 'ExpressionStatement',
+                    expression: step
+                };
+            }
+            if (init) {
+                if (!examine(init).isStatement) {
+                    init = {
+                        type: 'ExpressionStatement',
+                        expression: init
+                    };
+                }
+                if (!localised) 
+                    mapped.push(init);
+            }
+            var ref, label;
+            if (node.$label) {
+                label = node.$label.name;
+                ref = path[1];
+            } else {
+                label = generatedSymbol++;
+                ref = path[0];
+            }
+            label = opts.generatedSymbolPrefix + "Loop_" + label;
+            var idLocal = localised ? ident(label + "_local"):null ;
+            var idTrampoline = ident(label + "_trampoline");
+            var idIter = ident(label);
+            var idStep = step ? ident(label + "_step") : idIter;
+            var idContinuation = ident(label + "_exit");
+            var idBounce = ident("q");
+            var idCatchParam = ident("$exception");
+            var continuation, deferredCode;
+            if ('index' in ref) {
+                var idx = ref.index;
+                deferredCode = ref.parent[ref.field].splice(idx + 1, ref.parent[ref.field].length - (idx + 1));
+            } else {
+                deferredCode = [];
+            }
+            continuation = makeContinuation(idContinuation, deferredCode);
+            var initIter = localised ? parsePart("$0.bind(this,$1)", [idIter,init ? init.declarations.map(function (d) {
+                return d && d.init ? d.init : ident("undefined");
+            }) : []]).expr : idIter;
+            var returnStep = parsePart("return $0", [idStep]).body[0];
+            var returnBreak = {
+                type: 'ReturnStatement',
+                argument: {
+                    "type": "ArrayExpression",
+                    "elements": [literal(1)]
+                }
+            };
+            treeWalk(body, function mapExits(n, descend, subpath) {
+                if (examine(n).isFunction || examine(n).isLoop) {
+                    return true;
+                } else if (n.type === 'BreakStatement' || n.type === 'ContinueStatement') {
+                    if (n.label) {
+                        var labelStack = subpath.filter(function (p) {
+                            return '$label' in p.self;
+                        }).map(function (p, idx) {
+                            return p.self.$label && p.self.$label.name;
+                        });
+                        // Work out how many loops to exit by examining subpath.
+                        var loops = [];
+                        for (var l = 0;l < labelStack.length; l++) {
+                            if (labelStack[l] === n.label.name) {
+                                if (n.type === 'BreakStatement') 
+                                    loops.push(literal(1));
+                                subpath[0].replace({
+                                    type: 'ReturnStatement',
+                                    argument: {
+                                        "type": "ArrayExpression",
+                                        "elements": loops.reverse()
+                                    }
+                                });
+                                break;
+                            }
+                            loops.push(literal(0));
+                        }
+                    } else {
+                        if (n.type === 'BreakStatement') 
+                            subpath[0].replace(returnBreak);
+                         else 
+                            subpath[0].replace(returnStep); //  continue;
+                    }
+                } else {
+                    descend();
+                }
+            }, path);
+            if (body.type === 'BlockStatement') 
+                body = body.body.slice(0);
+             else 
+                body = [body];
+            if (node.type === 'DoWhileStatement') {
+                body = body.concat({
+                    "type": "IfStatement",
+                    "test": {
+                        type: 'UnaryExpression',
+                        argument: test,
+                        prefix: true,
+                        operator: '!'
+                    },
+                    "consequent": returnBreak,
+                    alternate: returnStep
+                });
+            } else {
+                body = [{
+                    "type": "IfStatement",
+                    "test": test,
+                    "consequent": {
+                        "type": "BlockStatement",
+                        "body": body.concat(returnStep)
+                    },
+                    alternate: returnBreak
+                }];
+            }
+            var decls = [];
+            if (opts.noRuntime) 
+                decls.push({
+                "type": "VariableDeclarator",
+                "id": idTrampoline
+            });
+            if (step && localised) 
+                decls.push({
+                "type": "VariableDeclarator",
+                "id": idLocal
+            });
+            if (decls.length) 
+                mapped.push({
+                "type": "VariableDeclaration",
+                "declarations": decls,
+                "kind": "var"
+            });
+            var invokeIterate;
+            var exit = getExit(path, [opts]).$error;
+            if (opts.noRuntime) {
+                invokeIterate = parsePart(
+	                opts.es6target?
+	                    "($idTrampoline = ((q) => { "+
+	                    "    $$setMapped: while (q) { "+
+	                    "         if (q.then)  "+
+	                    (depth===1?
+	                    "             return void q.then($idTrampoline, $exit); ":
+	                    "             return q.then($idTrampoline, $exit); ")+
+	                    "         try { "+
+	                    "             if (q.pop)  "+
+	                    "                 if (q.length)  "+
+	                    "                 return q.pop() ? $idContinuation.call(this) : q; "+
+	                    "              else  "+
+	                    "                 q = $idStep; "+
+	                    "              else  "+
+	                    "                 q = q.call(this) "+
+	                    "          } catch (_exception) { "+
+	                    "             return $exit(_exception); "+
+	                    "          } "+
+	                    "     } "+
+	                    "}))($idIter)":
+	                    "($idTrampoline = (function (q) { "+
+	                    "    $$setMapped: while (q) { "+
+	                    "         if (q.then)  "+
+	                    (depth===1?
+	                    "             return void q.then($idTrampoline, $exit); ":
+	                    "             return q.then($idTrampoline, $exit); ")+
+	                    "         try { "+
+	                    "             if (q.pop)  "+
+	                    "                 if (q.length)  "+
+	                    "                 return q.pop() ? $idContinuation.call(this) : q; "+
+	                    "              else  "+
+	                    "                 q = $idStep; "+
+	                    "              else  "+
+	                    "                 q = q.call(this) "+
+	                    "          } catch (_exception) { "+
+	                    "             return $exit(_exception); "+
+	                    "          } "+
+	                    "     } "+
+	                    "}).bind(this))($idIter)",
                 {
-                     setMapped:function(n){ n.$mapped = true ; return n },
-                     idTrampoline:idTrampoline,
-                     exit:exit,
-                     idIter:idIter,
-                     idContinuation:idContinuation,
-                     idStep:idStep
-                }).expr ;
-          } else {
-            invokeIterate = parser.part("(Function.$0.trampoline(this,$1,$2,$3,$5)($4))",[
-                genIdent.asyncbind,
-                idContinuation,idStep,exit,
-                idIter,
-                literal(depth===1)
-            ]).expr;
-          }
-
-          mapped.push({type:'ReturnStatement',argument:invokeIterate}) ;
-          mapped.push({
-              $label:node.$label,
-              "type": "FunctionDeclaration",
-              "id": idIter,
-              "params": [],
-              "body": {
-                  "type": "BlockStatement",
-                  "body": body
-              }
-          }) ;
-
-          if (step) {
-              mapped.push({
-                  "type": "FunctionDeclaration",
-                  id: idStep,
-                  "params": [],
-                  "body": {
-                      "type": "BlockStatement",
-                      "body": [ step,returnIter ]
-                  }
-              }) ;
-          }
-
-          if (init && init.type==='VariableDeclaration' && (init.kind==='let' || init.kind==='const')) {
-              if (init.kind==='const')
-                  init.kind = 'let' ;
-
-              path[0].replace([{
-                  type:'BlockStatement',
-                  body:mapped.map(down)
-              },down(continuation)]) ;
-          } else {
-              mapped.push(continuation) ;
-              path[0].replace(mapped.map(down)) ;
-          }
+                    setMapped: function (n) {
+                        n.$mapped = true;
+                        return n;
+                    },
+                    idTrampoline: idTrampoline,
+                    exit: exit,
+                    idIter: initIter,
+                    idContinuation: idContinuation,
+                    idStep: idStep
+                }).expr;
+            } else {
+                invokeIterate = parsePart("($0.$1.trampoline(this,$2,$3,$4,$6)($5))", [opts.$runtime ? genIdent.runtime : ident('Function'),
+                    genIdent.asyncbind,idContinuation,idStep,
+                    exit,initIter,literal(depth === 1)]).expr;
+            }
+            var iterDecls = init && init.declarations ? init.declarations.map(function (d) {
+                return d.id;
+            }) : [];
+            if (step) {
+                var stepArgs = {
+                    idIter: idIter,
+                    idStep: idStep,
+                    step: step,
+                    idLocal: idLocal,
+                    decId: iterDecls
+                };
+                if (localised) {
+                    stepArgs.iterDecls = iterDecls;
+                    mapped.push(parsePart(step.expression.$EmptyExpression ? 
+                    		(opts.es6target ? "function $idStep(){ return $idIter.bind(this,...$idLocal()) }" : "function $idStep(){ var [$decId] = $idLocal(); return $idIter.bind(this,$decId) }") :
+                    		"function $idStep(){ var [$decId] = $idLocal(); $:step; return $idIter.bind(this,$decId) }", stepArgs).body[0]);
+                    body.unshift(parsePart("$idLocal = function(){ return [$decId] }", stepArgs).body[0]);
+                } else {
+                    mapped.push(parsePart(step.expression.$EmptyExpression ? "function $idStep(){ return $idIter }" : "function $idStep(){ $:step; return $idIter }", stepArgs).body[0]);
+                }
+            }
+            mapped.push({
+                $label: node.$label,
+                "type": "FunctionDeclaration",
+                "id": idIter,
+                "params": localised ? iterDecls : [],
+                "body": {
+                    "type": "BlockStatement",
+                    "body": body
+                }
+            });
+            mapped.push({
+                type: 'ReturnStatement',
+                argument: invokeIterate
+            });
+            mapped.push(continuation);
+            path[0].replace(mapped.map(down));
         }
     }
-
+    
     /* Previous, recursive implementation for backwards compatibility */
-    function asyncLoops_1(ast,state) {
-        parser.treeWalker(ast, function (node, descend, path) {
+    function asyncLoops_1(ast, state) {
+        treeWalk(ast, function (node, descend, path) {
             function mapContinue(label) {
                 return {
                     type: 'ReturnStatement',
@@ -1462,7 +1495,9 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         argument: thisCall(label || symContinue)
                     }
                 };
-            };
+            }
+            
+            ;
             function mapExits(n, descend) {
                 if (n.type === 'BreakStatement') {
                     coerce(n, cloneNode(mapBreak(n.label && opts.generatedSymbolPrefix + "Loop_" + n.label.name + "_exit")));
@@ -1473,9 +1508,9 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 }
                 descend();
             }
-
+            
             if (node.type === 'ForInStatement' && containsAwait(node)) {
-                transformForIn(node, path) ;
+                transformForIn(node, path);
             } else if (node.type === 'ForOfStatement' && containsAwait(node)) {
                 iterizeForOf(node, path);
             }
@@ -1486,7 +1521,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 var condition = node.test || literal(true);
                 var step = node.update;
                 var body = node.body;
-                var loopUsesThis = containsThis(body) ;
+                var loopUsesThis = containsThis(body);
                 if (init) {
                     if (!examine(init).isStatement) {
                         init = {
@@ -1498,13 +1533,13 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 step = step && {
                     type: 'ExpressionStatement',
                     expression: step
-                } ;
+                };
                 body = examine(body).isBlockStatement ? cloneNode(body).body : [cloneNode(body)];
-                var label = node.$label && node.$label.name ;
+                var label = node.$label && node.$label.name;
                 label = "Loop_" + (label || generatedSymbol++);
                 var symExit = opts.generatedSymbolPrefix + (label + "_exit");
                 var symContinue = opts.generatedSymbolPrefix + (label + "_next");
-                var loop = ident(opts.generatedSymbolPrefix + (label));
+                var loop = ident(opts.generatedSymbolPrefix + label);
                 // How to exit the loop
                 var mapBreak = function (label) {
                     return {
@@ -1521,20 +1556,19 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         }
                     };
                 };
-
                 // How to continue the loop
                 var defContinue = makeContinuation(symContinue, [{
                     type: 'ReturnStatement',
                     argument: {
                         type: 'CallExpression',
-                        callee: loopUsesThis? bindAsync(loop):loop,
+                        callee: loopUsesThis ? bindAsync(loop) : loop,
                         arguments: [ident(symExit),genIdent.error]
                     }
                 }]);
-                if (step)
+                if (step) 
                     defContinue.body.body.unshift(step);
                 for (var i = 0;i < body.length; i++) {
-                    parser.treeWalker(body[i], mapExits);
+                    treeWalk(body[i], mapExits);
                 }
                 body.push(cloneNode(mapContinue()));
                 var subCall = {
@@ -1583,17 +1617,15 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         argument: bindAsync(subCall, literal(0))
                     }
                 };
-
-                if (init && init.type==='VariableDeclaration' && (init.kind==='let' || init.kind==='const')) {
-                    if (init.kind==='const')
-                        init.kind = 'let' ;
+                if (init && init.type === 'VariableDeclaration' && (init.kind === 'let' || init.kind === 'const')) {
+                    if (init.kind === 'const') 
+                        init.kind = 'let';
                     replace = {
-                        type:'BlockStatement',
-                        body:[cloneNode(init),replace]
+                        type: 'BlockStatement',
+                        body: [cloneNode(init),replace]
                     };
-                    init = null ;
+                    init = null;
                 }
-
                 for (p = 0; p < path.length; p++) {
                     var ref = path[p];
                     if ('index' in ref) {
@@ -1607,29 +1639,27 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 }
             }
             return true;
-        },state);
+        }, state);
         return ast;
     }
-
+    
     function containsAsyncExit(fn) {
         if (!examine(fn).isFunction) {
-            throw new Error("Cannot examine non-Function node types for async exits") ;
+            throw new Error("Cannot examine non-Function node types for async exits");
         }
-
-        return contains(fn.body,function(node){
-            return ((node.type === 'Identifier' && (node.name === opts.$return || node.name === opts.$error))
-                || (isExitStatement(node) && examine(node).isAsync)) ;
-        },function(node){
-            return !(examine(node).isFunction && (node.$wasAsync || examine(node).isAsync)) ;
-        }) ;
+        return contains(fn.body, function (node) {
+            return node.type === 'Identifier' && (node.name === opts.$return || node.name === opts.$error) || isExitStatement(node) && examine(node).isAsync;
+        }, function (node) {
+            return !(examine(node).isFunction && (node.$wasAsync || examine(node).isAsync));
+        });
     }
-
+    
     // TODO: Hoist directives (as in asyncDefine)
     function asyncDefineMethod(ast) {
-        return parser.treeWalker(ast, function (node, descend, path) {
+        return treeWalk(ast, function (node, descend, path) {
             var transform = getMemberFunction(node);
             descend();
-            if (!transform || !examine(transform).isAsync)
+            if (!transform || !examine(transform).isAsync) 
                 return;
             if (node.kind == 'set') {
                 var ex = new SyntaxError(where(transform) + "method 'async set' cannot be invoked", pr.filename, node.start);
@@ -1637,7 +1667,6 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 ex.loc = node.loc.start;
                 throw ex;
             }
-
             transform.async = false;
             var usesArgs = replaceArguments(transform);
             if (!containsAsyncExit(transform) && (transform.body.body.length === 0 || transform.body.body[transform.body.body.length - 1].type !== 'ReturnStatement')) {
@@ -1646,12 +1675,11 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 });
             }
             var funcback = bindAsync(setExit({
-                    type: 'FunctionExpression',
-                    params: [genIdent.return,genIdent.error],
-                    body: asyncDefineMethod(mapReturns(transform.body, path)),
-                    $wasAsync: true
-                }, opts),(opts.promises || opts.generators || opts.engine) ? null : literal(opts.lazyThenables?0:true) ) ;
-
+                type: 'FunctionExpression',
+                params: [genIdent.return,genIdent.error],
+                body: asyncDefineMethod(mapReturns(transform.body, path)),
+                $wasAsync: true
+            }, opts), opts.promises || opts.generators || opts.engine ? null : literal(opts.lazyThenables ? 0 : true));
             if (opts.promises) {
                 transform.body = {
                     type: 'BlockStatement',
@@ -1659,7 +1687,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         type: 'ReturnStatement',
                         argument: {
                             type: 'NewExpression',
-                            callee: ident('Promise'),
+                            callee: genIdent.Promise,
                             arguments: [funcback]
                         }
                     }]
@@ -1674,30 +1702,29 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 };
             }
             if (usesArgs) {
-                afterDirectives(transform.body.body,[assign$Args]);
+                afterDirectives(transform.body.body, [assign$Args]);
             }
         });
     }
-
+    
     function asyncDefine(ast) {
-        parser.treeWalker(ast, function (node, descend, path) {
+        treeWalk(ast, function (node, descend, path) {
             descend();
             if (examine(node).isAsync && examine(node).isFunction) {
-                var member ;
-                if ((member = getMemberFunction(path[0].parent))
-                    && examine(member).isAsync && path[0].parent.kind === 'get')  {
-                    warnAsyncGetter(path[0].parent.key) ;
+                var member;
+                if ((member = getMemberFunction(path[0].parent)) && examine(member).isAsync && path[0].parent.kind === 'get') {
+                    warnAsyncGetter(path[0].parent.key);
                 }
                 delete node.async;
-
                 var usesArgs = replaceArguments(node);
                 var fnBody = setExit({
                     type: 'FunctionExpression',
                     params: [genIdent.return,genIdent.error],
                     $wasAsync: true
-                }, opts) ;
-                var thisPath = [{self:fnBody}].concat(path) ;
-                
+                }, opts);
+                var thisPath = [{
+                    self: fnBody
+                }].concat(path);
                 if (examine(node.body).isBlockStatement) {
                     if (!containsAsyncExit(node) && (node.body.body.length === 0 || node.body.body[node.body.body.length - 1].type !== 'ReturnStatement')) {
                         node.body.body.push({
@@ -1720,13 +1747,11 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                     };
                     node.expression = false;
                 }
-
-                fnBody = bindAsync(fnBody,(opts.promises || opts.generators || opts.engine) ? null : literal(opts.lazyThenables?0:true)) ;
-
+                fnBody = bindAsync(fnBody, opts.promises || opts.generators || opts.engine ? null : literal(opts.lazyThenables ? 0 : true));
                 if (opts.promises) {
                     fnBody = {
                         type: 'NewExpression',
-                        callee: ident('Promise'),
+                        callee: genIdent.Promise,
                         arguments: [fnBody]
                     };
                 }
@@ -1738,20 +1763,22 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         argument: fnBody
                     }]
                 };
-                if (usesArgs)
-                    afterDirectives(fnBody.body,[assign$Args]);
+                if (usesArgs) 
+                    afterDirectives(fnBody.body, [assign$Args]);
                 node.body = fnBody;
                 return;
             }
         });
         return ast;
     }
-
+    
     /*
      * Rewrite
       async function <name>?<argumentlist><body>
     to
-      function <name>?<argumentlist>{ return function*() {<body>}.$asyncspawn(); }
+      function <name>?<argumentlist>{ return function*() {<body>}.$asyncspawn(Promise,this); }
+    or if the $runtime is set:
+      $runtime.$asyncspawn.call(function <name>?<argumentlist>{ return function*() {<body>},Promise,this); }
      */
     // Like mapReturns, but ONLY for return/throw async
     function mapAsyncReturns(ast) {
@@ -1759,7 +1786,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             return ast.map(mapAsyncReturns);
         }
         var lambdaNesting = 0;
-        return parser.treeWalker(ast, function (node, descend, path) {
+        return treeWalk(ast, function (node, descend, path) {
             if ((node.type === 'ThrowStatement' || node.type === 'ReturnStatement') && !node.$mapped) {
                 if (lambdaNesting > 0) {
                     if (examine(node).isAsync) {
@@ -1782,33 +1809,35 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             descend(node);
         });
     }
-
+    
     function spawnBody(body, deferExit) {
-        if (opts.noRuntime)
-            throw new Error("Nodent: 'noRuntime' option only compatible with -promise and -engine modes") ;
-
-        return parser.part("{ return (function*($return,$error){ $:body }).$asyncspawn(Promise,this) }",{
-            'return':genIdent.return,
-            error:genIdent.error,
-            asyncspawn:genIdent.asyncspawn,
-              body: mapAsyncReturns(body).concat(deferExit ? [{
-                  type: 'ReturnStatement',
-                  argument: genIdent.return
-              }] : [])
-        }).body[0] ;
+        if (opts.noRuntime) 
+            throw new Error("Nodent: 'noRuntime' option only compatible with -promise and -engine modes");
+        var template = !opts.$runtime ? "{ return (function*($return,$error){ $:body }).$asyncspawn($promise,this) }" : "{ return $runtime.$asyncspawn.call(function*($return,$error){ $:body },$promise,this) }";
+        return parsePart(template, {
+            'return': genIdent.return,
+            error: genIdent.error,
+            asyncspawn: genIdent.asyncspawn,
+            runtime: genIdent.runtime,
+            promise: genIdent.Promise,
+            body: mapAsyncReturns(body).concat(deferExit ? [{
+                type: 'ReturnStatement',
+                argument: genIdent.return
+            }] : [])
+        }).body[0];
     }
-
+    
     function warnAsyncGetter(id) {
         if (!id.$asyncgetwarninig) {
             id.$asyncgetwarninig = true;
-            logger(where(id) + "'async get "+printNode(id)+"(){...}' is non-standard. See https://github.com/MatAtBread/nodent#differences-from-the-es7-specification");
+            logger(where(id) + "'async get " + printNode(id) + "(){...}' is non-standard. See https://github.com/MatAtBread/nodent#differences-from-the-es7-specification");
         }
     }
-
-    function asyncSpawn(ast,engine) {
-        function mapAwaits(ast,hide) {
-            parser.treeWalker(ast, function (node, descend, path) {
-                if (node !== ast && examine(node).isFunction)
+    
+    function asyncSpawn(ast, engine) {
+        function mapAwaits(ast, hide) {
+            treeWalk(ast, function (node, descend, path) {
+                if (node !== ast && examine(node).isFunction) 
                     return;
                 if (examine(node).isAwait) {
                     if (hide) {
@@ -1820,18 +1849,18 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         node.type = 'YieldExpression';
                         descend();
                     }
-                } else
+                } else 
                     descend();
             });
         }
-
+        
         function promiseTransform(ast) {
             var promises = opts.promises;
             opts.promises = true;
             asyncTransforms(ast, true);
             opts.promises = promises;
         }
-
+        
         function expandArrows(fn) {
             if (fn.body.type !== 'BlockStatement') {
                 fn.body = {
@@ -1844,25 +1873,24 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             }
             return fn;
         }
-
+        
         function warnAsyncExit(exit, fn) {
             if (!fn.$asyncexitwarninig) {
                 fn.$asyncexitwarninig = true;
                 logger(where(exit) + "'async " + ({
                     ReturnStatement: 'return',
                     ThrowStatement: 'throw'
-                })[exit.type] + "' not possible in "+(engine?'engine':'generator')+" mode. Using Promises for function at " + where(fn));
+                })[exit.type] + "' not possible in " + (engine ? 'engine' : 'generator') + " mode. Using Promises for function at " + where(fn));
             }
         }
-
-        parser.treeWalker(ast, function (node, descend, path) {
+        
+        treeWalk(ast, function (node, descend, path) {
             descend();
             var fn, exit, usesArgs;
             if (examine(node).isAsync && examine(node).isFunction) {
-                var member ;
-                if ((member = getMemberFunction(path[0].parent))
-                    && examine(member).isAsync && path[0].parent.kind === 'get')  {
-                    warnAsyncGetter(path[0].parent.key) ;
+                var member;
+                if ((member = getMemberFunction(path[0].parent)) && examine(member).isAsync && path[0].parent.kind === 'get') {
+                    warnAsyncGetter(path[0].parent.key);
                 }
                 if (exit = containsAsyncExit(node)) {
                     // Do the Promise transform
@@ -1872,40 +1900,39 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                     fn = node;
                     delete fn.async;
                     usesArgs = replaceArguments(fn);
-                    mapAwaits(fn,false);
+                    mapAwaits(fn, false);
                     fn = expandArrows(fn);
                     fn.body = spawnBody(fn.body.body, exit);
-                    if (usesArgs)
-                        afterDirectives(fn.body.body,[assign$Args]);
+                    if (usesArgs) 
+                        afterDirectives(fn.body.body, [assign$Args]);
                     if (fn.id && path[0].parent.type === 'ExpressionStatement') {
                         fn.type = 'FunctionDeclaration';
                         path[1].replace(fn);
                     } else {
                         path[0].replace(fn);
                     }
-                } else if (path[0].parent.kind !== 'get')
-                    mapAwaits(node,true) ;
+                } else if (path[0].parent.kind !== 'get') 
+                    mapAwaits(node, true);
             } else if ((fn = getMemberFunction(node)) && examine(fn).isAsync) {
                 if (exit = containsAsyncExit(fn)) {
                     // Do the Promise transform
                     warnAsyncExit(exit, fn);
                     promiseTransform(node);
-                } else if (!engine || node.kind==='get') {
+                } else if (!engine || node.kind === 'get') {
                     if (engine) {
-                        promiseTransform(node) ;
+                        promiseTransform(node);
                     } else {
                         node.async = false;
                         usesArgs = replaceArguments(fn);
-                        mapAwaits(fn,false);
+                        mapAwaits(fn, false);
                         coerce(fn, expandArrows(fn));
                         fn.body = spawnBody(fn.body.body, exit);
                     }
-                    if (usesArgs)
-                        afterDirectives(fn.body.body,[assign$Args]);
+                    if (usesArgs) 
+                        afterDirectives(fn.body.body, [assign$Args]);
                 }
             }
         });
-
         // Map (and warn) about any out-of-scope awaits that are being
         // mapped using Promises.
         var st = cloneNode(opts);
@@ -1913,7 +1940,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         opts.generators = false;
         blockifyArrows(ast);
         hoistDeclarations(ast);
-        labelTryCatch(ast,st.engine);
+        labelTryCatch(ast, st.engine);
         mapLogicalOp(ast);
         mapCondOp(ast);
         walkDown(ast, [mapTryCatch,mapLoops,mapIfStmt,mapSwitch,mapBlock]);
@@ -1922,47 +1949,52 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         opts.generators = st.generators;
         return ast;
     }
-
+    
     /* Find all nodes within this scope matching the specified function */
     function scopedNodes(ast, matching, flat) {
+    		if (!flat) flat = ['isScope','isLoop'] ;
         var matches = [];
-        parser.treeWalker(ast, function (node, descend, path) {
-            if (node === ast)
+        treeWalk(ast, function (node, descend, path) {
+            if (node === ast) 
                 return descend();
             if (matching(node, path)) {
                 matches.push([].concat(path));
                 return;
             }
-            if (flat || examine(node).isScope) {
-                return;
-            }
+            if (flat === true) return ;
+            var x = examine(node) ;
+            for (var i=0; i<flat.length; i++) 
+                if (x[flat[i]]) 
+            		   return ;
             descend();
         });
         return matches;
     }
-
-    function extractVars(vars,kind) {
+    
+    function extractVars(vars, kind) {
         var varDecls = [];
-        var duplicates = {} ;
-        vars = vars.filter(function(v){ return v[0].parent.type !== 'ExportNamedDeclaration'}) ;
+        var duplicates = {};
+        vars = vars.filter(function (v) {
+            return v[0].parent.type !== 'ExportNamedDeclaration';
+        });
         if (vars.length) {
             var definitions = {};
             vars.forEach(function (path) {
                 function addName(name) {
                     if (name in definitions) {
-                        duplicates[name] = self.declarations[i] ;
+                        duplicates[name] = self.declarations[i];
                     } else {
-                        definitions[name] = self.declarations[i] ;
+                        definitions[name] = self.declarations[i];
                     }
                 }
-
+                
                 var ref = path[0];
                 var self = ref.self;
-                var kind = self.kind ;
+                var kind = self.kind;
                 var values = [];
                 for (var i = 0;i < self.declarations.length; i++) {
-                    var decl = self.declarations[i] ;
-                    getDeclNames(decl.id).forEach(addName) ;
+                    var decl = self.declarations[i];
+                    getDeclNames(decl.id).forEach(addName);
                     if (decl.init) {
                         var value = {
                             type: 'AssignmentExpression',
@@ -1973,17 +2005,22 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         values.push(value);
                     }
                 }
-                if (values.length == 0)
+                if (values.length == 0) 
                     ref.remove();
-                else {
-                   var repl = (values.length > 1)?{type:'SequenceExpression',expressions:values} : values[0] ;
-                   if (ref.parent.type.slice(0,3)!=='For')
-                       repl = {type:'ExpressionStatement',expression:repl} ;
-                   ref.replace(repl);
+                 else {
+                    var repl = values.length > 1 ? {
+                        type: 'SequenceExpression',
+                        expressions: values
+                    } : values[0];
+                    if (ref.parent.type.slice(0, 3) !== 'For') 
+                        repl = {
+                        type: 'ExpressionStatement',
+                        expression: repl
+                    };
+                    ref.replace(repl);
                 }
             });
-
-            var defs = Object.keys(definitions) ;
+            var defs = Object.keys(definitions);
             if (defs.length) {
                 defs = defs.map(function (name) {
                     return {
@@ -2005,200 +2042,215 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 }
             }
         }
-        return { decls: varDecls, duplicates: duplicates } ;
+        return {
+            decls: varDecls,
+            duplicates: duplicates
+        };
     }
-
+    
     function getDeclNames(id) {
-        if (!id) return [] ;
+        if (!id) 
+            return [];
         if (Array.isArray(id)) {
-            return id.reduce(function(z,j){ return z.concat(getDeclNames(j.id))},[]) ;
+            return id.reduce(function (z, j) {
+                return z.concat(getDeclNames(j.id));
+            }, []);
         }
         switch (id.type) {
-        case 'Identifier':
-            return [id.name]  ;
-        case 'AssignmentPattern':
-            return getDeclNames(id.left);
-        case 'ArrayPattern':
-            return id.elements.reduce(function(z,e){ return z.concat(getDeclNames(e)) },[]) ;
-        case 'ObjectPattern':
-            return id.properties.reduce(function(z,e){ return z.concat(getDeclNames(e)) },[]) ;
-        case 'ObjectProperty':
-        case 'Property':
-            return getDeclNames(id.value) ;
-        case 'RestElement':
-        case 'RestProperty':
-            return getDeclNames(id.argument) ;
+            case 'Identifier':
+                return [id.name];
+            case 'AssignmentPattern':
+                return getDeclNames(id.left);
+            case 'ArrayPattern':
+                return id.elements.reduce(function (z, e) {
+                    return z.concat(getDeclNames(e));
+                }, []);
+            case 'ObjectPattern':
+                return id.properties.reduce(function (z, e) {
+                    return z.concat(getDeclNames(e));
+                }, []);
+            case 'ObjectProperty':
+            case 'Property':
+                return getDeclNames(id.value);
+            case 'RestElement':
+            case 'RestProperty':
+                return getDeclNames(id.argument);
         }
     }
-
+    
     function checkConstsNotAssigned(ast) {
         /* Ensure no consts are on the LHS of an AssignmentExpression */
-        var names = {} ;
-
-        function fail(node){
-            logger(where(node) + "Possible assignment to 'const " + printNode(node)+"'");
+        var names = {};
+        function fail(node) {
+            logger(where(node) + "Possible assignment to 'const " + printNode(node) + "'");
         }
-
+        
         function checkAssignable(target) {
             switch (target.type) {
-            case 'Identifier':
-                // Find the declaration of any names on the left
-                if (names[target.name] === 'const') fail(target) ;
-                break ;
-            case 'ArrayPattern':
-                target.elements.forEach(function(e){
-                    if (names[e.name] === 'const') fail(e) ;
-                }) ;
-                break ;
-            case 'ObjectPattern':
-                target.properties.forEach(function(p){
-                    if (names[p.key.name] === 'const') fail(p) ;
-                }) ;
-                break ;
+                case 'Identifier':
+                    // Find the declaration of any names on the left
+                    if (names[target.name] === 'const') 
+                        fail(target);
+                    break;
+                case 'ArrayPattern':
+                    target.elements.forEach(function (e) {
+                        if (names[e.name] === 'const') 
+                            fail(e);
+                    });
+                    break;
+                case 'ObjectPattern':
+                    target.properties.forEach(function (p) {
+                        if (names[p.key.name] === 'const') 
+                            fail(p);
+                    });
+                    break;
             }
         }
-
-        parser.treeWalker(ast, function (node, descend, path) {
-            var body = examine(node).isBlockStatement ;
+        
+        treeWalk(ast, function (node, descend, path) {
+            var body = examine(node).isBlockStatement;
             if (body) {
-                names = Object.create(names) ;
-
-                for (var h=0; h<body.length; h++) {
+                names = Object.create(names);
+                for (var h = 0;h < body.length; h++) {
                     if (body[h].type === 'VariableDeclaration') {
-                        for (var i=0; i<body[h].declarations.length; i++) {
-                            getDeclNames(body[h].declarations[i].id).forEach(function(name){
-                                names[name] = body[h].kind ;
-                            }) ;
+                        for (var i = 0;i < body[h].declarations.length; i++) {
+                            getDeclNames(body[h].declarations[i].id).forEach(function (name) {
+                                names[name] = body[h].kind;
+                            });
                         }
                     }
                 }
             }
-            descend() ;
-
-            if (node.type === 'AssignmentExpression')
-                checkAssignable(node.left) ;
-            else if (node.type === 'UpdateExpression')
-                checkAssignable(node.argument) ;
-            if (body)
-                names = Object.getPrototypeOf(names) ;
+            descend();
+            if (node.type === 'AssignmentExpression') 
+                checkAssignable(node.left);
+             else if (node.type === 'UpdateExpression') 
+                checkAssignable(node.argument);
+            if (body) 
+                names = Object.getPrototypeOf(names);
         });
     }
-
+    
     /* Move directives, vars and named functions to the top of their scope iff. the scope contains an 'await' */
     function hoistDeclarations(ast) {
-      var sequences = {
-        TemplateLiteral:function(x) { return x.expressions },
-        NewExpression:function(x) { return x.arguments },
-        CallExpression:function(x) { return x.arguments },
-        SequenceExpression:function(x) { return x.expressions },
-        ArrayExpression:function(x) { return x.elements },
-        ObjectExpression:function(oe){ return oe.properties.map(function(p){ return p.value })}
-      };
+        var sequences = {
+            TemplateLiteral: function (x) {
+                return x.expressions;
+            },
+            NewExpression: function (x) {
+                return x.arguments;
+            },
+            CallExpression: function (x) {
+                return x.arguments;
+            },
+            SequenceExpression: function (x) {
+                return x.expressions;
+            },
+            ArrayExpression: function (x) {
+                return x.elements;
+            },
+            ObjectExpression: function (oe) {
+                return oe.properties.map(function (p) {
+                    return p.value;
+                });
+            }
+        };
         /* Identify SequenceExpressions, Parameter lists and VariableDeclarators that contain assigments and split them up
         to ensure the correct evaluation order */
-
-        function containsAssign(ast){
-          return contains(ast, function(n){
-              return n.type==='AssignmentExpression'
-          });
+        function containsAssign(ast) {
+            return contains(ast, function (n) {
+                return n.type === 'AssignmentExpression';
+            });
         }
-
-        parser.treeWalker(ast, function (node, descend, path) {
-          var i ;
-          descend() ;
-          // Ensure assigments are evaluated before any await expressions, eg:
-          // f(a=1, b = await a) --> a=1; f(a,b=await a)
-          
-          function moveAssignments(dest){
-              if (assignments.length) {
-                  dest.argument = {
-                      type:'SequenceExpression',
-                      expressions:assignments.map(function(a){
-                          var b = cloneNode(a)
-                          coerce(a,a.left);
-                          return b ;
-                      }).concat(dest.argument)
-                  } ;
-                  assignments = [] ;
-                }
-          }
-          
-          
-          if (node.type in sequences && !node.$hoisted) {
-            var expr = sequences[node.type](node) ;
-            var assignments = [] ;
-            var path ;
-            for (i=0; i<expr.length;i++) {
-              if (examine(expr[i]).isScope)
-                  continue ;
-              
-              if (path = containsAwait(expr[i]))
-                  moveAssignments(path[0].self) ;
-
-              if (!containsAwait(expr.slice(i+1)))
-                break ;
-
-              if (path = containsAssign(expr[i]))
-                assignments.push(path[0].self) ;
-            }
-          } else if (node.type === 'VariableDeclaration') {
-            // If any of the VariableDeclarators contain an initial value and are followed by a VariableDeclarator
-            // containing an await, split them up into multiple statements
-            for (i=node.declarations.length-1; i>0; i--) {
-              if (node.declarations[i] && node.declarations[i].init && containsAwait(node.declarations[i].init)) {
-                var insert = {
-                  type:'VariableDeclaration',
-                  kind: node.kind,
-                  declarations: node.declarations.splice(i)
-                } ;
-                var ref = path[0] ;
-                if ('index' in ref) {
-                  ref.parent[ref.field].splice(ref.index+1,0,insert) ;
-                } else throw new Error("VariableDeclaration not in a block") ;
-              }
+        
+        treeWalk(ast, function (node, descend, path) {
+            var i;
+            descend();
+            // Ensure assigments are evaluated before any await expressions, eg:
+            // f(a=1, b = await a) --> a=1; f(a,b=await a)
+            function moveAssignments(dest) {
+                if (assignments.length) {
+                    dest.argument = {
+                        type: 'SequenceExpression',
+                        expressions: assignments.map(function (a) {
+                            var b = cloneNode(a);
+                            coerce(a, a.left);
+                            return b;
+                        }).concat(dest.argument)
+                    };
+                    assignments = [];
+                }
             }
-          }
-        }) ;
-
+            
+            if (node.type in sequences && !node.$hoisted) {
+                var expr = sequences[node.type](node);
+                var assignments = [];
+                var path;
+                for (i = 0; i < expr.length; i++) {
+                    if (examine(expr[i]).isScope) 
+                        continue;
+                    if (path = containsAwait(expr[i])) 
+                        moveAssignments(path[0].self);
+                    if (!containsAwait(expr.slice(i + 1))) 
+                        break;
+                    if (path = containsAssign(expr[i])) 
+                        assignments.push(path[0].self);
+                }
+            } else if (node.type === 'VariableDeclaration') {
+                // If any of the VariableDeclarators contain an initial value and are followed by a VariableDeclarator
+                // containing an await, split them up into multiple statements
+                for (i = node.declarations.length - 1; i > 0; i--) {
+                    if (node.declarations[i] && node.declarations[i].init && containsAwait(node.declarations[i].init)) {
+                        var insert = {
+                            type: 'VariableDeclaration',
+                            kind: node.kind,
+                            declarations: node.declarations.splice(i)
+                        };
+                        var ref = path[0];
+                        if ('index' in ref) {
+                            ref.parent[ref.field].splice(ref.index + 1, 0, insert);
+                        } else 
+                            throw new Error("VariableDeclaration not in a block");
+                    }
+                }
+            }
+        });
         /* Hoist declarations */
         function isFreeVariable(kinds) {
-            return function(n, path) {
-                if (n.type === 'VariableDeclaration' && (n.kind = n.kind || 'var') && kinds.indexOf(n.kind)>=0) {
-                    var p = path[0] ;
+            return function (n, path) {
+                if (n.type === 'VariableDeclaration' && (n.kind = n.kind || 'var') && kinds.indexOf(n.kind) >= 0) {
+                    var p = path[0];
                     // Don't hoist the LHS of for (var/let/const _ of/in ... ; ;){}
-                    if (p.field == "left" && (p.parent.type === 'ForInStatement' || p.parent.type === 'ForOfStatement'))
+                    if (p.field == "left" && (p.parent.type === 'ForInStatement' || p.parent.type === 'ForOfStatement')) 
                         return false;
-
                     // Don't hoist the LHS of for (let/const _ = ... ; ;){}
-                    if (p.field == "init" && p.parent.type === 'ForStatement' && (n.kind==="const" || n.kind==="let"))
+                    if (p.field == "init" && p.parent.type === 'ForStatement' && (n.kind === "const" || n.kind === "let")) 
                         return false;
-
                     return true;
                 }
-            }
+            };
         }
-
+        
         function isHoistableFunction(n, path) {
             // YES: We're a named function, but not a continuation
-            if (n.type==='FunctionDeclaration'  && n.id) {
+            if (n.type === 'FunctionDeclaration' && n.id) {
                 return examine(n).isAsync || !n.$continuation;
             }
             // No, we're not a hoistable function
             return false;
         }
-
-        checkConstsNotAssigned(ast) ;
-
-        var inStrictBody = false ;
-        parser.treeWalker(ast, function (node, descend, path) {
-            var prevScope = inStrictBody ;
-            inStrictBody = inStrictBody || isStrict(node) ;
-
+        
+        checkConstsNotAssigned(ast);
+        var inStrictBody = false;
+        treeWalk(ast, function (node, descend, path) {
+            var prevScope = inStrictBody;
+            inStrictBody = inStrictBody || isStrict(node);
             if (examine(node).isBlockStatement) {
                 if (containsAwait(node)) {
                     // For this scope/block, find all the hoistable functions, vars and directives
-                    var isScope = !path[0].parent || examine(path[0].parent).isScope ;
-
+                	    var isVarScope = !path[0].parent || examine(path[0].parent).isScope  ; 
+                	    var isLoopScope = path[0].parent && examine(path[0].parent).isLoop ;
+                    var isScope = isVarScope || isLoopScope ;
                     /* 'const' is highly problematic. In early version of Chrome (Node 0.10, 4.x, 5.x) non-standard behaviour:
                      *
                      * Node             scope           multiple-decls
@@ -2217,36 +2269,34 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                      * - const's with a single declaration in the current scope (NOT block) should be hoisted to function level, and defined as 'var'
                      * - const's with duplicate declarations in the current scope (NOT block) should be hoisted to block level, and defined as 'let'
                      */
-
-                    var directives, consts, vars, lets, functions ;
+                    var directives, consts, vars, lets, functions;
                     if (isScope) {
-                        consts = scopedNodes(node, isFreeVariable(['const']),false);
-                        var names = {}, duplicates = {} ;
-
+                        consts = scopedNodes(node, isFreeVariable(['const']), false);
+                        var names = {}, duplicates = {};
                         // Work out which const identifiers are duplicates
                         // Ones that are only declared once can simply be treated as vars, whereas
                         // identifiers that are declared multiple times have block-scope and are
-                        // only valid in node 6 or in strict mode on node 4/5
-                        consts.forEach(function(d){
-                            d[0].self.declarations.forEach(function(e){
-                                getDeclNames(e.id).forEach(function(n){
-                                    if (names[n] || duplicates[n]) {
-                                        delete names[n] ;
-                                        duplicates[n] = e ;
+                        // only valid in node 6 or in strict mode on node 4/5. 
+                        // In strict mode or ES6-a-like targets always assume the correct ES6 semantics (block scope)
+                        consts.forEach(function (d) {
+                            d[0].self.declarations.forEach(function (e) {
+                                getDeclNames(e.id).forEach(function (n) {
+                                    if (inStrictBody || looksLikeES6 || names[n] || duplicates[n]) {
+                                    	   looksLikeES6 = true ;
+                                        delete names[n];
+                                        duplicates[n] = e;
                                     } else {
-                                        names[n] = e ;
+                                        names[n] = e;
                                     }
-                                }) ;
-                            }) ;
-                        }) ;
-
+                                });
+                            });
+                        });
                         // Change all the declarations into assignments, since consts are always initialized
-                        consts.forEach(function(d){
-                            for (var depth=0; depth<d.length; depth++)
-                                if (examine(d[depth].parent).isBlockStatement)
-                                    break ;
-
-                            var ref = d[depth] ;
+                        consts.forEach(function (d) {
+                            for (var depth = 0;depth < d.length; depth++) 
+                                if (examine(d[depth].parent).isBlockStatement) 
+                                break;
+                            var ref = d[depth];
                             ref.append({
                                 type: 'ExpressionStatement',
                                 expression: {
@@ -2258,58 +2308,66 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                                             left: d.id,
                                             right: d.init
                                         };
-                                        d.init = null ;
-                                        return a ;
+                                        d.init = null;
+                                        return a;
                                     })
                                 }
                             });
-                            var ids = getDeclNames(d[0].self.declarations) ;
-                            var decls = ids.filter(function(name){ return name in duplicates }) ;
+                            var ids = getDeclNames(d[0].self.declarations);
+                            var decls = ids.filter(function (name) {
+                                return name in duplicates;
+                            });
                             if (decls.length) {
                                 d[0].append({
-                                    type:'VariableDeclaration',
-                                    kind:'let',
-                                    declarations: decls.map(function(name){
+                                    type: 'VariableDeclaration',
+                                    kind: 'let',
+                                    declarations: decls.map(function (name) {
                                         return {
-                                            type:'VariableDeclarator',
-                                            id:ident(name)
-                                        }
+                                            type: 'VariableDeclarator',
+                                            id: ident(name)
+                                        };
                                     })
-                                }) ;
+                                });
                             }
-
-                            d[0].self.kind = 'var' ;
-                            decls = ids.filter(function(name){ return name in names }) ;
+                            d[0].self.kind = 'var';
+                            decls = ids.filter(function (name) {
+                                return name in names;
+                            });
                             if (decls.length) {
-                                d[0].self.declarations = decls.map(function(name){
+                                d[0].self.declarations = decls.map(function (name) {
                                     return {
-                                        type:'VariableDeclarator',
-                                        id:ident(name)
-                                    }
+                                        type: 'VariableDeclarator',
+                                        id: ident(name)
+                                    };
                                 });
                             } else {
-                              ref.remove() ;
+                                ref.remove();
                             }
-                        }) ;
-                        vars = scopedNodes(node, isFreeVariable(['var']),false);
-                        lets = [] ;
+                        });
+                        if (isVarScope && !isLoopScope) vars = scopedNodes(node, isFreeVariable(['var']), ['isScope']);
+                        lets = [];
                     } else {
-                        lets = scopedNodes(node, isFreeVariable(['const']),true);
+                        lets = scopedNodes(node, isFreeVariable(['const']), true);
                     }
-                    lets = lets.concat(scopedNodes(node, isFreeVariable(['let']),true));
-                    directives = scopedNodes(node, function (n) { return examine(n).isDirective },true);
+                    lets = lets.concat(scopedNodes(node, isFreeVariable(['let']), true));
+                    directives = scopedNodes(node, function (n) {
+                        return examine(n).isDirective;
+                    }, true);
                     functions = scopedNodes(node, isHoistableFunction, inStrictBody);
-
-                    vars = vars?extractVars(vars,'var'):{duplicates:{},decls:[]} ;
-                    lets = lets?extractVars(lets,'let'):{duplicates:{},decls:[]} ;
-
-                    Object.keys(vars.duplicates).forEach(function(id){
+                    vars = vars ? extractVars(vars, 'var') : {
+                        duplicates: {},
+                        decls: []
+                    };
+                    lets = lets ? extractVars(lets, 'let') : {
+                        duplicates: {},
+                        decls: []
+                    };
+                    Object.keys(vars.duplicates).forEach(function (id) {
                         logger(where(vars.duplicates[id]) + "Duplicate declaration '" + printNode(vars.duplicates[id]) + "'");
-                    }) ;
-                    Object.keys(lets.duplicates).forEach(function(id){
+                    });
+                    Object.keys(lets.duplicates).forEach(function (id) {
                         logger(where(lets.duplicates[id]) + "Duplicate declaration '" + printNode(lets.duplicates[id]) + "'");
-                    }) ;
-
+                    });
                     functions = functions.map(function (path) {
                         var ref = path[0], symName;
                         // What is the name of this function (could be async, so check the expression if necessary),
@@ -2330,7 +2388,6 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         var movedFn = ref.self.type === 'FunctionDeclaration' ? ref.remove() : ref.replace(ident(symName));
                         return movedFn;
                     });
-
                     directives = directives.map(function (path) {
                         var ref = path[0];
                         return ref.remove();
@@ -2339,61 +2396,61 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                         node.body = directives.concat(vars.decls).concat(lets.decls).concat(functions).concat(node.body);
                     }
                 }
-                inStrictBody = prevScope ;
+                inStrictBody = prevScope;
             }
-
-            // Labeled blocks need to be treated as loops that exit on the first iteration if they contain awaits and labelled breaks
-            if (node.type==='LabeledStatement' && node.body.type==='BlockStatement' && containsAwait(node.body) && contains(node.body,function(m){
-		        	    return m.type === 'BreakStatement' && m.label
-	        	})) {
-          	    node.body.body.push({ type: 'BreakStatement' }) ;
-                node.body = {
-                    type: 'DoWhileStatement',
-                    test: literal(0),
-                    body: node.body
-                };
+            // Labeled breaks need to be treated as loops that always exit early, if they contain awaits
+            if (node.type === 'LabeledStatement' && node.body.type === 'BlockStatement' && containsAwait(node.body)) {
+                if (contains(node.body, function (m) {
+                    return m.type === 'BreakStatement' && m.label && m.label.name == node.label.name;
+                })) {
+                    node.body.body.push({
+                        type: 'BreakStatement'
+                    });
+                    node.body = {
+                        type: 'DoWhileStatement',
+                        test: literal(0),
+                        body: node.body
+                    };
+                }
             }
-            
             descend();
-
             // It makes life easier if labeled loops have the label to hand, so we simply reference them here with a hidden $label
             // and keep a record of how nested the for loop is (since it's transformed top to bottom and counting during
             // transformation is therefore not possible
-            if (node.type==='ForOfStatement' || node.type==='ForInStatement' || examine(node).isLoop) {
-                var depth = 0 ;
-                for (var n=0; n<path.length;n++)
-                    if (path[n].self.type==='ForOfStatement' || path[n].self.type==='ForInStatement' || examine(path[n].self).isLoop)
-                        depth += 1 ;
-                    else if (examine(path[n].self).isFunction)
-                        break ;
-
-                node.$depth = depth ;
-                if (path[0].parent.type==='LabeledStatement') {
-                    node.$label = path[0].parent.label ;
+            if (node.type === 'ForOfStatement' || node.type === 'ForInStatement' || examine(node).isLoop) {
+                var depth = 0;
+                for (var n = 0;n < path.length; n++) 
+                    if (path[n].self.type === 'ForOfStatement' || path[n].self.type === 'ForInStatement' || examine(path[n].self).isLoop) 
+                    depth += 1;
+                 else if (examine(path[n].self).isFunction) 
+                    break;
+                node.$depth = depth;
+                if (path[0].parent.type === 'LabeledStatement') {
+                    node.$label = path[0].parent.label;
                 } else {
-                    node.$label = null ;
+                    node.$label = null;
                 }
             }
             return true;
         });
         return ast;
     }
-
+    
     function mapSupers(classNode, engine) {
         function superID() {
             return classNode.$superID = classNode.$superID || ident("$super$" + generatedSymbol++);
         }
-
+        
         return function (method) {
             method = getMemberFunction(method);
-            if (method && examine(method).isAsync && (!engine || method.kind === 'get' || contains(method,function(n){
-              return (examine(n).isFunction && contains(n,function(n){
-                return n.type==='Super'
-              }) && contains(n,function(n){
-                return n.async && (n.type==='ReturnStatement' || n.type==='ThrowStatement') ;
-              }))
-            },true))) {
-                parser.treeWalker(method.body, function (node, descend, path) {
+            if (method && examine(method).isAsync && (!engine || method.kind === 'get' || contains(method, function (n) {
+                return examine(n).isFunction && contains(n, function (n) {
+                    return n.type === 'Super';
+                }) && contains(n, function (n) {
+                    return n.async && (n.type === 'ReturnStatement' || n.type === 'ThrowStatement');
+                });
+            }, true))) {
+                treeWalk(method.body, function (node, descend, path) {
                     var r;
                     if (!examine(node).isClass) {
                         descend();
@@ -2401,18 +2458,18 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                             if (path[0].parent.type === 'MemberExpression') {
                                 if (path[1].parent.type === 'CallExpression' && path[1].field === 'callee') {
                                     // super[m](...)  maps to:  this.$superid(m).call(this,...)
-                                    r = parser.part("this.$super($field).call(this,$args)",{
-                                        'super':superID(),
-                                        field:path[0].parent.computed ? path[0].parent.property:literal(path[0].parent.property.name),
-                                        args:path[1].parent.arguments
-                                    }).expr ;
+                                    r = parsePart("this.$super($field).call(this,$args)", {
+                                        'super': superID(),
+                                        field: path[0].parent.computed ? path[0].parent.property : literal(path[0].parent.property.name),
+                                        args: path[1].parent.arguments
+                                    }).expr;
                                     path[2].replace(r);
                                 } else {
                                     // super[f],    maps to:  this.$superid(f)
-                                    r = parser.part("this.$super($field)",{
-                                        'super':superID(),
-                                        field:path[0].parent.computed ?path[0].parent.property : literal(path[0].parent.property.name)
-                                    }).expr ;
+                                    r = parsePart("this.$super($field)", {
+                                        'super': superID(),
+                                        field: path[0].parent.computed ? path[0].parent.property : literal(path[0].parent.property.name)
+                                    }).expr;
                                     path[1].replace(r);
                                 }
                             } else {
@@ -2424,14 +2481,16 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             }
         };
     }
-
-    function fixSuperReferences(ast,engine) {
-        return parser.treeWalker(ast, function (node, descend, path) {
+    
+    function fixSuperReferences(ast, engine) {
+        return treeWalk(ast, function (node, descend, path) {
             descend();
             if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
-                node.body.body.forEach(mapSupers(node,engine));
+                node.body.body.forEach(mapSupers(node, engine));
                 if (node.$superID) {
-                    var method = parser.part("(function($field) { return super[$field] })",{ field:ident("$field") }).expr ;
+                    var method = parsePart("(function($field) { return super[$field] })", {
+                        field: ident("$field")
+                    }).expr;
                     if (opts.babelTree) {
                         method.type = 'ClassMethod';
                         method.key = node.$superID;
@@ -2449,11 +2508,11 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             }
         });
     }
-
+    
     function blockifyArrows(ast) {
-        parser.treeWalker(ast, function (node, descend, path) {
+        treeWalk(ast, function (node, descend, path) {
             var awaiting = containsAwait(node);
-            if (awaiting)  {
+            if (awaiting) {
                 if (node.type === 'ArrowFunctionExpression' && node.body.type !== 'BlockStatement') {
                     node.body = {
                         type: "BlockStatement",
@@ -2469,10 +2528,10 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         });
         return ast;
     }
-
+    
     function exposeCompilerOpts(ast) {
         // Expose compiler
-        parser.treeWalker(ast, function (node, descend, path) {
+        treeWalk(ast, function (node, descend, path) {
             descend();
             if (node.type === 'Identifier' && node.name === '__nodent') {
                 coerce(node, literal(opts));
@@ -2480,47 +2539,42 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         });
         return ast;
     }
-
+    
     /* Called with a Program or FunctionDeclaration.body */
     function isStrict(node) {
-        if (node.type === 'Program' && node.sourceType === 'module')
-            return true ;
-
-        var nodes ;
-        if (node.type === 'Program')
-            nodes = node.body ;
-        else if (examine(node).isFunction)
-            nodes = node.body.body ;
-        else return false ;
-
-        if (nodes) for (var i=0; i<nodes.length; i++)
-            if (examine(nodes[i]).isDirective && nodes[i].expression.value.match(/^\s*use\s+strict\s*$/))
-                return true ;
-        return false ;
+        if (node.type === 'Program' && node.sourceType === 'module') 
+            return true;
+        var nodes;
+        if (node.type === 'Program') 
+            nodes = node.body;
+         else if (examine(node).isFunction) 
+            nodes = node.body.body;
+         else 
+            return false;
+        if (nodes) 
+            for (var i = 0;i < nodes.length; i++) 
+            if (examine(nodes[i]).isDirective && nodes[i].expression.value.match(/^\s*use\s+strict\s*$/)) 
+            return true;
+        return false;
     }
-
+    
     function containsBlockScopedDeclarations(nodes) {
         for (var i = 0;i < nodes.length; i++) {
             var node = nodes[i];
-            if (node.type === 'ClassDeclaration' ||
-                (node.type === 'VariableDeclaration' && (node.kind === 'let' || node.kind === 'const')) ||
-                (node.type === 'FunctionDeclaration' && node.id && node.id.name && !node.$continuation)) {
+            if (node.type === 'ClassDeclaration' || node.type === 'VariableDeclaration' && (node.kind === 'let' || node.kind === 'const') || node.type === 'FunctionDeclaration' && node.id && node.id.name && !node.$continuation) {
                 return true;
             }
         }
         return false;
     }
-
+    
     /* Remove un-necessary nested blocks and crunch down empty function implementations */
     function cleanCode(ast) {
         // Coalese BlockStatements
-        parser.treeWalker(ast, function (node, descend, path) {
+        treeWalk(ast, function (node, descend, path) {
             descend();
-            if (node.type==='ArrowFunctionExpression'
-                && node.body.type === 'BlockStatement'
-                && node.body.body.length===1
-                && node.body.body[0].type==='ReturnStatement') {
-                node.body = node.body.body[0].argument
+            if (node.type === 'ArrowFunctionExpression' && node.body.type === 'BlockStatement' && node.body.body.length === 1 && node.body.body[0].type === 'ReturnStatement') {
+                node.body = node.body.body[0].argument;
             } else {
                 var block, child;
                 // If this node is a block with vanilla BlockStatements (no controlling entity), merge them
@@ -2529,7 +2583,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                     // For ES6, this needs more care, as blocks containing 'let/const/class' have a scope of their own
                     for (var i = 0;i < block.length; i++) {
                         if ((child = examine(block[i]).isBlockStatement) && !containsBlockScopedDeclarations(child)) {
-                            if (!containsBlockScopedDeclarations(block[i]))
+                            if (!containsBlockScopedDeclarations(block[i])) 
                                 [].splice.apply(block, [i,1].concat(child));
                         }
                     }
@@ -2537,7 +2591,7 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
             }
         });
         // Truncate BlockStatements with a Jump (break;continue;return;throw) inside
-        parser.treeWalker(ast, function (node, descend, path) {
+        treeWalk(ast, function (node, descend, path) {
             descend();
             if (examine(node).isJump) {
                 var ref = path[0];
@@ -2546,9 +2600,9 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                     var ctn = ref.parent[ref.field];
                     while (i < ctn.length) {
                         // Remove any statements EXCEPT for function/var definitions
-                        if (ctn[i].type === 'VariableDeclaration' || examine(ctn[i]).isFunction && ctn[i].id)
+                        if (ctn[i].type === 'VariableDeclaration' || examine(ctn[i]).isFunction && ctn[i].id) 
                             i += 1;
-                         else
+                         else 
                             ctn.splice(i, 1);
                     }
                 }
@@ -2556,11 +2610,11 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         });
         /* Inline continuations that are only referenced once */
         // Find any continuations that have a single reference
-        parser.treeWalker(ast, function (node, descend, path) {
+        treeWalk(ast, function (node, descend, path) {
             descend();
             if (node.$thisCall && continuations[node.name]) {
                 if (continuations[node.name].ref) {
-                    delete continuations[node.name]; //   Multiple ref
+                    delete continuations[node.name]; //    Multiple ref
                 } else {
                     continuations[node.name].ref = node.$thisCall;
                 }
@@ -2571,14 +2625,14 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         });
         if (calls.length) {
             // Replace all the calls to the continuation with the body from the continuation followed by 'return;'
-            parser.treeWalker(ast, function (node, descend, path) {
+            treeWalk(ast, function (node, descend, path) {
                 descend();
                 if (calls.indexOf(node) >= 0) {
                     if (path[1].self.type === 'ReturnStatement') {
                         var sym = node.$thisCallName;
                         var repl = cloneNode(continuations[sym].def.body.body);
                         continuations[sym].$inlined = true;
-                        if (!examine(path[1].self).isJump)
+                        if (!examine(path[1].self).isJump) 
                             repl.push({
                             type: 'ReturnStatement'
                         });
@@ -2590,55 +2644,47 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
                 return continuations[c].$inlined && continuations[c].def;
             });
             // Remove all the (now inline) declarations of the continuations
-            parser.treeWalker(ast, function (node, descend, path) {
+            treeWalk(ast, function (node, descend, path) {
                 descend();
                 if (defs.indexOf(node) >= 0) {
                     path[0].remove();
                 }
             });
         }
-
         // Hoist generated FunctionDeclarations within ES5 Strict functions (actually put them at the
         // end of the scope-block, don't hoist them, it's just an expensive operation)
-        var looksLikeES6 = (ast.type==='Program' && ast.sourceType==='module') || contains(ast,function(n){
-            return examine(n).isES6 ;
-        },true) ;
-
         if (!looksLikeES6) {
-            var useStrict = isStrict(ast) ;
-            (function(ast){
-                parser.treeWalker(ast, function (node, descend, path) {
-                    if (node.type==='Program' || node.type==='FunctionDeclaration' || node.type==='FunctionExpression') {
-                        var wasStrict = useStrict ;
-                        useStrict = useStrict || isStrict(node) ;
+            var useStrict = isStrict(ast);
+            (function (ast) {
+                treeWalk(ast, function (node, descend, path) {
+                    if (node.type === 'Program' || node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression') {
+                        var wasStrict = useStrict;
+                        useStrict = useStrict || isStrict(node);
                         if (useStrict) {
                             descend();
-
-                            var functionScope = node.type === 'Program' ? node : node.body ;
-                            var functions = scopedNodes(functionScope,function(n,path){
-                                if (n.type==='FunctionDeclaration') {
-                                    return path[0].parent !== functionScope ;
+                            var functionScope = node.type === 'Program' ? node : node.body;
+                            var functions = scopedNodes(functionScope, function (n, path) {
+                                if (n.type === 'FunctionDeclaration') {
+                                    return path[0].parent !== functionScope;
                                 }
-                            }) ;
-
+                            },['isScope']);
                             functions = functions.map(function (path) {
-                                return path[0].remove() ;
+                                return path[0].remove();
                             });
-                            [].push.apply(functionScope.body,functions) ;
+                            [].push.apply(functionScope.body, functions);
                         } else {
                             descend();
                         }
-                        useStrict = wasStrict ;
+                        useStrict = wasStrict;
                     } else {
                         descend();
                     }
-                }) ;
+                });
             })(ast);
         }
-
         /*
         function replaceSymbols(ast,from,to) {
-            parser.treeWalker(ast,function(node,descend,path){
+            treeWalk(ast,function(node,descend,path){
                 descend() ;
                 if (node.type=='Identifier' && node.name==from) {
                     node.name = to ;
@@ -2663,32 +2709,219 @@ function asynchronize(pr, __sourceMapping, opts, logger) {
         // these can be simplified to:
         //    $return
         */
-
-        // Remove all the 'hiiden' node info generated during transformation
-        parser.treeWalker(ast,function(node,descend,path){
-            descend() ;
-            Object.keys(node).filter(function(k){ return k[0]==='$'}).forEach(function(k){
-                delete node[k] ;
-            }) ;
-        }) ;
+        // Remove all the 'hidden' node info generated during transformation
+        treeWalk(ast, function (node, descend, path) {
+            descend();
+            Object.keys(node).filter(function (k) {
+                return k[0] === '$';
+            }).forEach(function (k) {
+                delete node[k];
+            });
+        });
         return ast;
     }
+    
 }
 
-module.exports = {
-    printNode:printNode,
-    babelLiteralNode: babelLiteralNode,
-    asynchronize: function (pr, __sourceMapping, opts, logger) {
-        try {
-            return asynchronize(pr, __sourceMapping, opts, logger);
-        } catch (ex) {
-            if (ex instanceof SyntaxError) {
-                var l = pr.origCode.substr(ex.pos - ex.loc.column);
-                l = l.split("\n")[0];
-                ex.message += " (nodent)\n" + l + "\n" + l.replace(/[\S ]/g, "-").substring(0, ex.loc.column) + "^";
-                ex.stack = "";
+/* AST helpers: treeWalk */
+function loc(old, repl) {
+    ['start','end','loc','range'].forEach(function (k) {
+        if (k in old && !(k in repl)) 
+            repl[k] = old[k];
+    });
+}
+
+var referencePrototypes = {
+    replace: function (newNode) {
+        if (Array.isArray(newNode) && newNode.length === 1) 
+            newNode = newNode[0];
+        if ('index' in this) {
+            loc(this.parent[this.field][this.index], newNode);
+            if (Array.isArray(newNode)) {
+                [].splice.apply(this.parent[this.field], [this.index,1].concat(newNode));
+            } else {
+                this.parent[this.field][this.index] = newNode;
             }
-            throw ex;
+        } else {
+            loc(this.parent[this.field], newNode);
+            if (Array.isArray(newNode)) {
+                this.parent[this.field] = {
+                    type: 'BlockStatement',
+                    body: newNode
+                };
+            } else {
+                this.parent[this.field] = newNode;
+            }
+        }
+        return this.self;
+    },
+    append: function (newNode) {
+        if (Array.isArray(newNode) && newNode.length === 1) 
+            newNode = newNode[0];
+        if ('index' in this) {
+            if (Array.isArray(newNode)) {
+                [].splice.apply(this.parent[this.field], [this.index + 1,0].concat(newNode));
+            } else {
+                this.parent[this.field].splice(this.index + 1, 0, newNode);
+            }
+        } else {
+            throw new Error("Cannot append Element node to non-array");
         }
+        return this.self;
+    },
+    index: function () {
+        return this.parent[this.field].indexOf(this.self);
+    },
+    removeElement: function () {
+        return this.parent[this.field].splice(this.index, 1)[0];
+    },
+    removeNode: function () {
+        var r = this.parent[this.field];
+        delete this.parent[this.field];
+        return r;
+    }
+};
+var notNodeKeys = {
+    start: true,
+    end: true,
+    loc: true,
+    range: true,
+    type: true
+};
+function forEachNodeKey(n, down) {
+    if (n && n.type) {
+        var keys = Object.keys(n).filter(function (k) {
+            return k[0] != '$' && k[0] != '_' && !(k in notNodeKeys) && typeof n[k] === 'object' && n[k] && (typeof n[k].type === 'string' || Array.isArray(n[k]));
+        });
+        keys.forEach(function (member) {
+            if (Array.isArray(n[member])) {
+                n[member].forEach(function (node, index) {
+                    down(node, member, index);
+                });
+            } else 
+                down(n[member], member, null);
+        });
+    }
+}
+
+function treeWalk(n, walker, state) {
+    if (!state) {
+        state = [{
+            self: n
+        }];
+        state.replace = function (pos, newNode) {
+            state[pos].replace(newNode);
+        };
+    }
+    function descend() {
+        forEachNodeKey(n, function down(sub, key, index) {
+            if (!sub) 
+                return;
+            var ref = {
+                replace: referencePrototypes.replace,
+                append: referencePrototypes.append,
+                self: sub,
+                parent: n,
+                field: key
+            };
+            if (index !== null) {
+                ref.index = true;
+                Object.defineProperties(ref, {
+                    index: {
+                        enumerable: true,
+                        get: referencePrototypes.index
+                    }
+                });
+                ref.remove = referencePrototypes.removeElement;
+            } else {
+                ref.remove = referencePrototypes.removeNode;
+            }
+            state.unshift(ref);
+            treeWalk(ref.self, walker, state);
+            state.shift();
+        });
+    }
+    
+    ;
+    walker(n, descend, state);
+    return n;
+}
+
+/* AST helpers: partialParser */
+function partialParser(parse) {
+    var parseCache = {};
+    return function partialParse(code, args) {
+        if (!parseCache[code]) {
+            parseCache[code] = parse(code);
+        }
+        var result = substitute(parseCache[code]);
+        return {
+            body: result.body,
+            expr: result.body[0].type === 'ExpressionStatement' ? result.body[0].expression : null
+        };
+        /* parse and substitute:
+		 * 
+		 *    $1      Substitute the specified expression. If $1 occupies a slot which is an array of expressions (e.g arguments, params)
+		 *            and the passed argument is an array, subtitute the whole set
+		 *    {$:1}   Substitute a single statement 
+		 * 
+		 */
+        function substitute(src, dest) {
+            if (Array.isArray(dest) && !Array.isArray(src)) 
+                throw new Error("Can't substitute an array for a node");
+            dest = dest || {};
+            Object.keys(src).forEach(function (k) {
+                if (!(src[k] instanceof Object)) 
+                    return dest[k] = src[k];
+                function moreNodes(v) {
+                    if (typeof v === "function") 
+                        v = v();
+                    dest = dest.concat(v);
+                    return dest;
+                }
+                
+                function copyNode(v) {
+                    if (typeof v === "function") 
+                        v = v();
+                    dest[k] = v;
+                    return dest;
+                }
+                
+                // The src is an array, so create/grow the destination
+                // It could an an array of expressions $1,$2,$3 or statements $:1;$:2;$:3;
+                if (Array.isArray(src[k])) 
+                    return dest[k] = substitute(src[k], []);
+                var p;
+                if (Array.isArray(dest)) 
+                    p = moreNodes;
+                 else 
+                    p = copyNode;
+                // Substitute a single identifier $.. with an expression (TODO: test provided arg is an expression node)
+                if (src[k].type === 'Identifier' && src[k].name[0] === '$') 
+                    return p(args[src[k].name.slice(1)]);
+                // Substitute a single labeled statement $:.. with a statement (TODO: test provided arg is a statement node)
+                if (src[k].type === 'LabeledStatement' && src[k].label.name === '$') {
+                    var spec = src[k].body.expression;
+                    return p(args[spec.name || spec.value]);
+                }
+                // Magic label to call a function to modify a statement node  $$method: <statement>
+                // The newNode = args.method(oldNode)
+                if (src[k].type === 'LabeledStatement' && src[k].label.name.slice(0, 2) === '$$') {
+                    return p(args[src[k].label.name.slice(2)](substitute(src[k]).body));
+                }
+                return p(substitute(src[k]));
+            });
+            return dest;
+        }
+    };
+}
+
+module.exports = {
+    treeWalker: treeWalk,
+    partialParser: partialParser,
+    babelLiteralNode: babelLiteralNode,
+    transform: function (pr, opts, helpers) {
+/* DEBUG USE ONLY: global.printNode = helpers.printNode ;*/
+        return asynchronize(pr, opts, helpers.logger || function(){}, partialParser(helpers.parse), helpers.printNode);
     }
 };