no message

@@ -28,9 +28,9 @@ var tokenUtil =  require('./util/tokenUtil');
 const _ = require('lodash');
 const _ = require('lodash');
 var status = require('./util/resTemplate') 
 var status = require('./util/resTemplate') 
 
 
+
 // error handler
 // error handler
 onerror(app)
 onerror(app)
-
 app.use(koaBody({ multipart: true }));
 app.use(koaBody({ multipart: true }));
 
 
 // middlewares
 // middlewares
@@ -50,7 +50,10 @@ app.use(views(__dirname + '/views', {
 app.use(async (ctx, next) => {
 app.use(async (ctx, next) => {
   try{
   try{
     const start = new Date();
     const start = new Date();
-    if(filterUrl.indexOf(ctx.request.url) != -1){
+    const url = ctx.request.url.split('?');
+    console.log(url);
+    if(filterUrl.indexOf(url[0]) != -1){
+      
           await next();
           await next();
     }else if(!ctx.header.token){
     }else if(!ctx.header.token){
       status.catchError(ctx,400,'请登录');        
       status.catchError(ctx,400,'请登录');        

-All packages installed at Tue Aug 22 2017 18:52:38 GMT+0800 (CST)
+All packages installed at Wed Sep 06 2017 18:02:21 GMT+0800 (CST)

+Wed Sep 06 2017 17:57:14 GMT+0800 (CST)

+# download-file
+
+## Install
+
+```shell
+npm install download-file --save
+```
+
+## Usage
+
+```js
+var download = require('download-file')
+
+var url = "http://i.imgur.com/G9bDaPH.jpg"
+
+var options = {
+	directory: "./images/cats/",
+	filename: "cat.gif"
+}
+
+download(url, options, function(err){
+	if (err) throw err
+	console.log("meow")
+}) 
+```
+
+## API
+
+### download(url, [options], callback(err))
+
+- __url__ string of the file URL to download 
+
+- __options__ object with options
+
+  - __directory__ string with path to directory where to save files (default: current working directory)
+  - __filename__ string for the name of the file to be saved as (default: filename in the url)
+  - __timeout__ integer of how long in ms to wait while downloading (default: 20000)
+
+- __callback__ function to run after

+var fs = require('fs')
+var url = require('url')
+var http = require('http')
+var https = require('https')
+var mkdirp = require('mkdirp')
+
+module.exports = function download(file, options, callback) {
+  if (!file) throw("Need a file url to download")
+
+  if (!callback && typeof options === 'function') {
+    callback = options
+  }
+
+  options = typeof options === 'object' ? options : {}
+  options.timeout = options.timeout || 20000
+  options.directory = options.directory ? options.directory : '.'
+
+  var uri = file.split('/')
+  options.filename = options.filename || uri[uri.length - 1]
+
+  var path = options.directory + "/" + options.filename
+
+  if (url.parse(file).protocol === null) {
+    file = 'http://' + file
+    req = http
+  } else if (url.parse(file).protocol === 'https:') {
+    req = https
+  } else {
+    req = http
+  }
+
+  var request = req.get(file, function(response) {
+
+    if (response.statusCode === 200) {
+
+      mkdirp(options.directory, function(err) { 
+        if (err) throw err
+        var file = fs.createWriteStream(path)
+        response.pipe(file)
+      })
+
+    } else {
+
+      if (callback) callback(response.statusCode)
+
+    }
+
+    response.on("end", function(){
+      if (callback) callback(false, path)
+    })
+
+    request.setTimeout(options.timeout, function () {
+      request.abort()
+      callback("Timeout")
+    })
+
+  }).on('error', function(e) {
+
+    if (callback) callback(e)
+
+  })
+
+}

+../../../_mkdirp@0.5.1@mkdirp/bin/cmd.js

+../../_mkdirp@0.5.1@mkdirp

+{
+  "name": "download-file",
+  "version": "0.1.5",
+  "description": "Generic file download utility",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "author": "Montana Flynn",
+  "license": "ISC",
+  "dependencies": {
+    "mkdirp": "^0.5.0"
+  },
+  "devDependencies": {},
+  "keywords": [
+    "download",
+    "file",
+    "url",
+    "get",
+    "http",
+    "https"
+  ],
+  "_from": "download-file@0.1.5",
+  "_resolved": "http://registry.npm.taobao.org/download-file/download/download-file-0.1.5.tgz"
+}

+var dl = require('./index.js')
+
+var url = "i.imgur.com/G9bDaPH.jpg"
+
+var opts = {
+	directory: "./images/cats/",
+	filename: "cat.gif"
+}
+
+dl(url, opts, function(err){
+	if (err) hiss(err)
+	meow("no protocol")
+}) 
+
+var url = "http://i.imgur.com/G9bDaPH.jpg"
+
+var opts = {
+  directory: "./images/cats/",
+  filename: "cat.gif"
+}
+
+dl(url, opts, function(err){
+  if (err) hiss(err)
+  meow("http protocol")
+})
+
+var url = "http://i.imgur.com/G9bDaPH.jpg"
+
+var opts = {
+  directory: "./images/cats/",
+  filename: "cat.gif"
+}
+
+dl(url, opts, function(err){
+  if (err) hiss(err)
+  meow("https protocol")
+}) 
+
+function meow(msg) {
+  console.log("\033[32m", "meow: " + msg, "\033[91m")
+}
+
+function hiss(err) {
+  console.log("\033[31m", "hiss", "\033[91m")
+  throw err
+}

+build/
+node_modules/

+Wed Sep 06 2017 17:57:15 GMT+0800 (CST)

+sudo: false
+
+language: node_js
+
+node_js:
+  - "4"
+  - "6"
+
+cache:
+  directories:
+    - node_modules
+
+install:
+  - npm install
+
+script:
+  - npm run test
+
+# Necessary to compile native modules for io.js v3 or Node.js v4
+env:
+  - CXX=g++-4.8
+
+# Necessary to compile native modules for io.js v3 or Node.js v4
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.8
+
+notifications:
+  email: false

+Copyright 2011 Marcel Laverdet
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

+fibers(1) -- Fiber support for v8 and Node
+==========================================
+
+INSTALLING
+----------
+
+### via npm
+* `npm install fibers`
+* You're done! (see "supported platforms" below if you run into errors)
+
+### from source
+* `git clone git://github.com/laverdet/node-fibers.git`
+* `cd node-fibers`
+* `npm install`
+
+Note: node-fibers uses [node-gyp](https://github.com/TooTallNate/node-gyp) for
+building. To manually invoke the build process, you can use `node-gyp rebuild`.
+This will put the compiled extension in `build/Release/fibers.node`. However,
+when you do `require('fibers')`, it will expect the module to be in, for
+example, `bin/linux-x64-v8-3.11/fibers.node`. You can manually put the module
+here every time you build, or you can use the included build script. Either
+`npm install` or `node build -f` will do this for you. If you are going to be
+hacking on node-fibers, it may be worthwhile to first do `node-gyp configure`
+and then for subsequent rebuilds you can just do `node-gyp build` which will
+be faster than a full `npm install` or `node-gyp rebuild`.
+
+### meteor users please read this
+If you're trying to get meteor running and you ended up at this page you're
+probably doing something wrong. Please uninstall all versions of NodeJS and
+Meteor, then start over. See
+[meteor#5124](https://github.com/meteor/meteor/issues/5124) for more
+information.
+
+### supported platforms
+If you are running NodeJS version 4.x, 5.x, or 6.x on Linux, OS X, or Windows
+(7 or later) then you should be able to install fibers from npm just fine. If
+you are running an older (or newer) version of node or some other operating
+system you will have to compile fibers on your system.
+
+(special thanks to [Jeroen Janssen](https://github.com/japj) for his work on
+fibers in Windows)
+
+If you do end up needing to compile fibers first make sure you have node-gyp
+installed as a global dependency (`npm install -g node-gyp`), and that you have
+setup your build enviroment by following the instructions at
+[node-gyp](https://github.com/TooTallNate/node-gyp). Ubuntu-flavored Linux users
+may need to run `sudo apt-get install g++` as well.
+
+
+EXAMPLES
+--------
+
+The examples below describe basic use of `Fiber`, but note that it is **not
+recommended** to use `Fiber` without an abstraction in between your code and
+fibers. See "FUTURES" below for additional information.
+
+### Sleep
+This is a quick example of how you can write sleep() with fibers. Note that
+while the sleep() call is blocking inside the fiber, node is able to handle
+other events.
+
+	$ cat sleep.js
+
+```javascript
+var Fiber = require('fibers');
+
+function sleep(ms) {
+	var fiber = Fiber.current;
+	setTimeout(function() {
+		fiber.run();
+	}, ms);
+	Fiber.yield();
+}
+
+Fiber(function() {
+	console.log('wait... ' + new Date);
+	sleep(1000);
+	console.log('ok... ' + new Date);
+}).run();
+console.log('back in main');
+```
+
+	$ node sleep.js
+	wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
+	back in main
+	ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)
+
+
+### Incremental Generator
+Yielding execution will resume back in the fiber right where you left off. You
+can also pass values back and forth through yield() and run(). Again, the node
+event loop is never blocked while this script is running.
+
+	$ cat generator.js
+
+```javascript
+var Fiber = require('fibers');
+
+var inc = Fiber(function(start) {
+	var total = start;
+	while (true) {
+		total += Fiber.yield(total);
+	}
+});
+
+for (var ii = inc.run(1); ii <= 10; ii = inc.run(1)) {
+	console.log(ii);
+}
+```
+
+	$ node generator.js
+	1
+	2
+	3
+	4
+	5
+	6
+	7
+	8
+	9
+	10
+
+
+### Fibonacci Generator
+Expanding on the incremental generator above, we can create a generator which
+returns a new Fibonacci number with each invocation. You can compare this with
+the [ECMAScript Harmony
+Generator](http://wiki.ecmascript.org/doku.php?id=harmony:generators) Fibonacci
+example.
+
+	$ cat fibonacci.js
+
+```javascript
+var Fiber = require('fibers');
+
+// Generator function. Returns a function which returns incrementing
+// Fibonacci numbers with each call.
+function Fibonacci() {
+	// Create a new fiber which yields sequential Fibonacci numbers
+	var fiber = Fiber(function() {
+		Fiber.yield(0); // F(0) -> 0
+		var prev = 0, curr = 1;
+		while (true) {
+			Fiber.yield(curr);
+			var tmp = prev + curr;
+			prev = curr;
+			curr = tmp;
+		}
+	});
+	// Return a bound handle to `run` on this fiber
+	return fiber.run.bind(fiber);
+}
+
+// Initialize a new Fibonacci sequence and iterate up to 1597
+var seq = Fibonacci();
+for (var ii = seq(); ii <= 1597; ii = seq()) {
+	console.log(ii);
+}
+```
+
+	$ node fibonacci.js
+	0
+	1
+	1
+	2
+	3
+	5
+	8
+	13
+	21
+	34
+	55
+	89
+	144
+	233
+	377
+	610
+	987
+	1597
+
+
+### Basic Exceptions
+Fibers are exception-safe; exceptions will continue travelling through fiber
+boundaries:
+
+	$ cat error.js
+
+```javascript
+var Fiber = require('fibers');
+
+var fn = Fiber(function() {
+	console.log('async work here...');
+	Fiber.yield();
+	console.log('still working...');
+	Fiber.yield();
+	console.log('just a little bit more...');
+	Fiber.yield();
+	throw new Error('oh crap!');
+});
+
+try {
+	while (true) {
+		fn.run();
+	}
+} catch(e) {
+	console.log('safely caught that error!');
+	console.log(e.stack);
+}
+console.log('done!');
+```
+
+	$ node error.js
+	async work here...
+	still working...
+	just a little bit more...
+	safely caught that error!
+	Error: oh crap!
+			at error.js:11:9
+	done!
+
+
+FUTURES
+-------
+
+Using the `Fiber` class without an abstraction in between your code and the raw
+API is **not recommended**. `Fiber` is meant to implement the smallest amount of
+functionality in order make possible many different programming patterns. This
+makes the `Fiber` class relatively lousy to work with directly, but extremely
+powerful when coupled with a decent abstraction. There is no right answer for
+which abstraction is right for you and your project. Included with `node-fibers`
+is an implementation of "futures" which is fiber-aware. Usage of this library
+is documented below. There are several other externally-maintained options
+which can be found on the [wiki](https://github.com/laverdet/node-fibers/wiki).
+You **should** feel encouraged to be creative with fibers and build a solution
+which works well with your project. For instance, `Future` is not a good
+abstraction to use if you want to build a generator function (see Fibonacci
+example above).
+
+Using `Future` to wrap existing node functions. At no point is the node event
+loop blocked:
+
+	$ cat ls.js
+
+```javascript
+var Future = require('fibers/future');
+var fs = Future.wrap(require('fs'));
+
+Future.task(function() {
+	// Get a list of files in the directory
+	var fileNames = fs.readdirFuture('.').wait();
+	console.log('Found '+ fileNames.length+ ' files');
+
+	// Stat each file
+	var stats = [];
+	for (var ii = 0; ii < fileNames.length; ++ii) {
+		stats.push(fs.statFuture(fileNames[ii]));
+	}
+	stats.map(function(f) {
+		f.wait()
+	});
+
+	// Print file size
+	for (var ii = 0; ii < fileNames.length; ++ii) {
+		console.log(fileNames[ii]+ ': '+ stats[ii].get().size);
+	}
+}).detach();
+```
+
+	$ node ls.js 
+	Found 11 files
+	bin: 4096
+	fibers.js: 1708
+	.gitignore: 37
+	README.md: 8664
+	future.js: 5833
+	.git: 4096
+	LICENSE: 1054
+	src: 4096
+	ls.js: 860
+	Makefile: 436
+	package.json: 684
+
+
+The future API is designed to make it easy to move between classic
+callback-style code and fiber-aware waiting code:
+
+	$ cat sleep.js
+
+```javascript
+var Future = require('fibers/future'), wait = Future.wait;
+
+// This function returns a future which resolves after a timeout. This
+// demonstrates manually resolving futures.
+function sleep(ms) {
+	var future = new Future;
+	setTimeout(function() {
+		future.return();
+	}, ms);
+	return future;
+}
+
+// You can create functions which automatically run in their own fiber and
+// return futures that resolve when the fiber returns (this probably sounds
+// confusing.. just play with it to understand).
+var calcTimerDelta = function(ms) {
+	var start = new Date;
+	sleep(ms).wait();
+	return new Date - start;
+}.future(); // <-- important!
+
+// And futures also include node-friendly callbacks if you don't want to use
+// wait()
+calcTimerDelta(2000).resolve(function(err, val) {
+	console.log('Set timer for 2000ms, waited '+ val+ 'ms');
+});
+```
+
+	$ node sleep.js
+	Set timer for 2000ms, waited 2009ms
+
+
+API DOCUMENTATION
+-----------------
+Fiber's definition looks something like this:
+
+```javascript
+/**
+ * Instantiate a new Fiber. You may invoke this either as a function or as
+ * a constructor; the behavior is the same.
+ *
+ * When run() is called on this fiber for the first time, `fn` will be
+ * invoked as the first frame on a new stack. Execution will continue on
+ * this new stack until `fn` returns, or Fiber.yield() is called.
+ *
+ * After the function returns the fiber is reset to original state and
+ * may be restarted with another call to run().
+ */
+function Fiber(fn) {
+	[native code]
+}
+
+/**
+ * `Fiber.current` will contain the currently-running Fiber. It will be
+ * `undefined` if there is no fiber (i.e. the main stack of execution).
+ *
+ * See "Garbage Collection" for more information on responsible use of
+ * `Fiber.current`.
+ */
+Fiber.current = undefined;
+
+/**
+ * `Fiber.yield()` will halt execution of the current fiber and return control
+ * back to original caller of run(). If an argument is supplied to yield(),
+ * run() will return that value.
+ *
+ * When run() is called again, yield() will return.
+ *
+ * Note that this function is a global to allow for correct garbage
+ * collection. This results in no loss of functionality because it is only
+ * valid to yield from the currently running fiber anyway.
+ *
+ * Note also that `yield` is a reserved word in Javascript. This is normally
+ * not an issue, however some code linters may complain. Rest assured that it
+ * will run fine now and in future versions of Javascript.
+ */
+Fiber.yield = function(param) {
+	[native code]
+}
+
+/**
+ * run() will start execution of this Fiber, or if it is currently yielding,
+ * it will resume execution. If an argument is supplied, this argument will
+ * be passed to the fiber, either as the first parameter to the main
+ * function [if the fiber has not been started] or as the return value of
+ * yield() [if the fiber is currently yielding].
+ *
+ * This function will return either the parameter passed to yield(), or the
+ * returned value from the fiber's main function.
+ */
+Fiber.prototype.run = function(param) {
+	[native code]
+}
+
+/**
+ * reset() will terminate a running Fiber and restore it to its original
+ * state, as if it had returned execution.
+ *
+ * This is accomplished by causing yield() to throw an exception, and any
+ * futher calls to yield() will also throw an exception. This continues
+ * until the fiber has completely unwound and returns.
+ *
+ * If the fiber returns a value it will be returned by reset().
+ *
+ * If the fiber is not running, reset() will have no effect.
+ */
+Fiber.prototype.reset = function() {
+	[native code]
+}
+
+/**
+ * throwInto() will cause a currently yielding fiber's yield() call to
+ * throw instead of return gracefully. This can be useful for notifying a
+ * fiber that you are no longer interested in its task, and that it should
+ * give up.
+ *
+ * Note that if the fiber does not handle the exception it will continue to
+ * bubble up and throwInto() will throw the exception right back at you.
+ */
+Fiber.prototype.throwInto = function(exception) {
+	[native code]
+}
+```
+
+
+Future's definition looks something like this:
+
+```javascript
+/**
+ * Returns a future-function which, when run, starts running the target
+ * function and returns a future for the result.
+ * 
+ * Example usage: 
+ * var funcy = function(arg) {
+ *   return arg+1;
+ * }.future();
+ * 
+ * funcy(1).wait(); // returns 2
+ */
+Function.prototype.future = function() { ... }
+
+/**
+ * Future object, instantiated with the new operator.
+ */
+function Future() {}
+
+/**
+ * Wrap a node-style async function to return a future in place of using a callback.
+ * 
+ * fn - the function or object to wrap
+ * array - indicates that this callback will return more than 1 argument after `err`. For example,
+ *         `child_process.exec()` returns [err, stdout, stderr]
+ * suffix - appends a string to every method that was overridden, if you passed an object
+ * 
+ * Example usage: Future.wrap(asyncFunction)(arg1).wait()
+ */
+Future.wrap = function(fn, multi, suffix) { ... }
+
+/**
+ * Invoke a function that will be run in its own fiber context and return a future to its return
+ * value.
+ *
+ * Example:
+ * Future.task(function() {
+ *   // You can safely `wait` on stuff here
+ * }).detach();
+ */
+Future.task = function(fn) { ... }
+
+/**
+ * Wait on a series of futures and then return. If the futures throw an exception this function
+ * /won't/ throw it back. You can get the value of the future by calling get() on it directly. If
+ * you want to wait on a single future you're better off calling future.wait() on the instance.
+ * 
+ * Example usage: Future.wait(aFuture, anotherFuture)
+ */
+Future.wait = function(/* ... */) { ... }
+
+/**
+ * Return the value of this future. If the future hasn't resolved yet this will throw an error.
+ */
+Future.prototype.get = function() { ... }
+
+/**
+ * Mark this future as returned. All pending callbacks will be invoked immediately.
+ * 
+ * value - the value to return when get() or wait() is called.
+ * 
+ * Example usage: aFuture.return(value)
+ */
+Future.prototype.return = function(value) { ... }
+
+/**
+ * Throw from this future as returned. All pending callbacks will be invoked immediately.
+ * Note that execution will continue normally after running this method, 
+ * so make sure you exit appropriately after running throw()
+ * 
+ * error - the error to throw when get() or wait() is called.
+ * 
+ * Example usage: aFuture.throw(new Error("Something borked"))
+ */
+Future.prototype.throw = function(error) { ... }
+
+/**
+ * "detach" this future. Basically this is useful if you want to run a task in a future, you
+ * aren't interested in its return value, but if it throws you don't want the exception to be
+ * lost. If this fiber throws, an exception will be thrown to the event loop and node will
+ * probably fall down.
+ */
+Future.prototype.detach = function() { ... }
+
+/**
+ * Returns whether or not this future has resolved yet.
+ */
+Future.prototype.isResolved = function() { ... }
+
+/**
+ * Returns a node-style function which will mark this future as resolved when called.
+ * 
+ * Example usage: 
+ *   var errback = aFuture.resolver();
+ *   asyncFunction(arg1, arg2, etc, errback)
+ *   var result = aFuture.wait();
+ */
+Future.prototype.resolver = function() { ... }
+
+/**
+ * Waits for this future to resolve and then invokes a callback.
+ *
+ * If only one argument is passed it is a standard function(err, val){} errback.
+ *
+ * If two arguments are passed, the first argument is a future which will be thrown to in the case
+ * of error, and the second is a function(val){} callback.
+ */
+Future.prototype.resolve = function(/* errback or future, callback */) { ... }
+
+/**
+ * Propogate results to another future.
+ * 
+ * Example usage: future1.proxy(future2) // future2 gets automatically resolved with however future1 resolves
+ */
+Future.prototype.proxy = function(future) { ... }
+
+/**
+ * Differs from its functional counterpart in that it actually resolves the future. Thus if the
+ * future threw, future.wait() will throw.
+ */
+Future.prototype.wait = function() { ... }
+
+/**
+ * Support for converting a Future to and from ES6 Promises.
+ */
+Future.fromPromise = function(promise) { ... }
+Future.prototype.promise = function() { ... }
+```
+
+GARBAGE COLLECTION
+------------------
+
+If you intend to build generators, iterators, or "lazy lists", you should be
+aware that all fibers must eventually unwind. This is implemented by causing
+yield() to throw unconditionally when the library is trying to unwind your
+fiber-- either because reset() was called, or all handles to the fiber were lost
+and v8 wants to delete it.
+
+Something like this will, at some point, cause an infinite loop in your
+application:
+
+```javascript
+var fiber = Fiber(function() {
+	while (true) {
+		try {
+			Fiber.yield();
+		} catch(e) {}
+	}
+});
+fiber.run();
+```
+
+If you either call reset() on this fiber, or the v8 garbage collector decides it
+is no longer in use, the fiber library will attempt to unwind the fiber by
+causing all calls to yield() to throw. However, if you catch these exceptions
+and continue anyway, an infinite loop will occur.
+
+There are other garbage collection issues that occur with misuse of fiber
+handles. If you grab a handle to a fiber from within itself, you should make
+sure that the fiber eventually unwinds. This application will leak memory:
+
+```javascript
+var fiber = Fiber(function() {
+	var that = Fiber.current;
+	Fiber.yield();
+}
+fiber.run();
+fiber = undefined;
+```
+
+There is no way to get back into the fiber that was started, however it's
+impossible for v8's garbage collector to detect this. With a handle to the fiber
+still outstanding, v8 will never garbage collect it and the stack will remain in
+memory until the application exits.
+
+Thus, you should take care when grabbing references to `Fiber.current`.

+#!/usr/bin/env node
+"use strict";
+var fs = require('fs');
+global.Fiber = require('../fibers');
+global.Future = require('../future');
+
+// Start the repl
+var vm = require('vm');
+var domain = require('domain');
+var repl = require('repl').start('node> ', null, fiberEval, true, true);
+function fiberEval(code, context, file, cb) {
+	if (/^\([ \r\n\t+]\)$/.test(code)) {
+		return cb(false, undefined);
+	}
+	// Parses?
+	try {
+		new Function(code);
+	} catch (err) {
+		return cb(err, false);
+	}
+
+	// Run in fiber
+	Future.task(function() {
+		// Save history
+		var last;
+		repl.rli.history = repl.rli.history.slice(0, 50).filter(function(item) {
+			try {
+				return item !== last;
+			} finally {
+				last = item;
+			}
+		});
+		fs.writeFile(process.env.HOME+ '/.node-history', JSON.stringify(repl.rli.history), function(){});
+
+		// Run user code
+		var d = domain.create();
+		d.run(function() {
+			cb(null, vm.runInThisContext(code, file));
+		});
+		d.on('error', function(err) {
+			console.error('\nUnhandled error: '+ err.stack);
+		});
+	}).resolve(cb);
+}
+
+// Load history
+try {
+	repl.rli.history = JSON.parse(fs.readFileSync(process.env.HOME+ '/.node-history', 'utf-8'));
+} catch (err) {}

+{
+	'target_defaults': {
+		'default_configuration': 'Release',
+		'configurations': {
+			'Release': {
+				'cflags': [ '-O3' ],
+				'xcode_settings': {
+					'GCC_OPTIMIZATION_LEVEL': '3',
+					'GCC_GENERATE_DEBUGGING_SYMBOLS': 'NO',
+				},
+				'msvs_settings': {
+					'VCCLCompilerTool': {
+						'Optimization': 3,
+						'FavorSizeOrSpeed': 1,
+					},
+				},
+			}
+		},
+	},
+	'targets': [
+		{
+			'target_name': 'fibers',
+			'sources': [
+				'src/fibers.cc',
+				'src/coroutine.cc',
+				'src/libcoro/coro.c',
+				# Rebuild on header changes
+				'src/coroutine.h',
+				'src/libcoro/coro.h',
+			],
+			'cflags!': ['-ansi'],
+			'conditions': [
+				['OS == "win"',
+					{'defines': ['CORO_FIBER', 'WINDOWS']},
+				# else
+					{
+						'defines': ['USE_CORO', 'CORO_GUARDPAGES=1'],
+						'ldflags': ['-pthread'],
+					}
+				],
+				['OS == "linux"',
+					{
+						'variables': {
+							'USE_MUSL': '<!(ldd --version 2>&1 | head -n1 | grep "musl" | wc -l)',
+						},
+						'conditions': [
+							['<(USE_MUSL) == 1',
+								{'defines': ['CORO_ASM', 'USE_V8_SYMBOLS']},
+								{'defines': ['CORO_UCONTEXT']}
+							],
+						],
+					},
+				],
+				['OS == "solaris" or OS == "sunos" or OS == "freebsd" or OS == "aix"', {'defines': ['CORO_UCONTEXT']}],
+				['OS == "mac"', {'defines': ['CORO_SJLJ']}],
+				['OS == "openbsd"', {'defines': ['CORO_ASM']}],
+				['target_arch == "arm" or target_arch == "arm64"',
+					{
+						# There's been problems getting real fibers working on arm
+						'defines': ['CORO_PTHREAD'],
+						'defines!': ['CORO_UCONTEXT', 'CORO_SJLJ', 'CORO_ASM'],
+					},
+				],
+			],
+		},
+	],
+}

+#!/usr/bin/env node
+var cp = require('child_process'),
+	fs = require('fs'),
+	path = require('path');
+
+// Parse args
+var force = false, debug = false;
+var
+	arch = process.arch,
+	platform = process.platform;
+var args = process.argv.slice(2).filter(function(arg) {
+	if (arg === '-f') {
+		force = true;
+		return false;
+	} else if (arg.substring(0, 13) === '--target_arch') {
+		arch = arg.substring(14);
+	} else if (arg === '--debug') {
+		debug = true;
+	}
+	return true;
+});
+if (!debug) {
+	args.push('--release');
+}
+if (!{ia32: true, x64: true, arm: true, arm64: true, ppc: true, ppc64: true, s390: true, s390x: true}.hasOwnProperty(arch)) {
+	console.error('Unsupported (?) architecture: `'+ arch+ '`');
+	process.exit(1);
+}
+
+// Test for pre-built library
+var modPath = platform+ '-'+ arch+ '-'+ process.versions.modules;
+if (!force) {
+	try {
+		fs.statSync(path.join(__dirname, 'bin', modPath, 'fibers.node'));
+		console.log('`'+ modPath+ '` exists; testing');
+		cp.execFile(process.execPath, ['quick-test'], function(err, stdout, stderr) {
+			if (err || stdout !== 'pass' || stderr) {
+				console.log('Problem with the binary; manual build incoming');
+				build();
+			} else {
+				console.log('Binary is fine; exiting');
+			}
+		});
+	} catch (ex) {
+		// Stat failed
+		build();
+	}
+} else {
+	build();
+}
+
+// Build it
+function build() {
+	if (process.versions.electron) {
+		args.push('--target='+ process.versions.electron,  '--dist-url=https://atom.io/download/atom-shell');
+	}
+	cp.spawn(
+		process.platform === 'win32' ? 'node-gyp.cmd' : 'node-gyp',
+		['rebuild'].concat(args),
+		{stdio: [process.stdin, process.stdout, process.stderr]})
+	.on('exit', function(err) {
+		if (err) {
+			console.error(
+				'node-gyp exited with code: '+ err+ '\n'+
+				'Please make sure you are using a supported platform and node version. If you\n'+
+				'would like to compile fibers on this machine please make sure you have setup your\n'+
+				'build environment--\n'+
+				'Windows + OS X instructions here: https://github.com/nodejs/node-gyp\n'+
+				'Ubuntu users please run: `sudo apt-get install g++ build-essential`\n'+
+				'Alpine users please run: `sudo apk add python make g++`'
+			);
+			return process.exit(err);
+		}
+		afterBuild();
+	})
+	.on('error', function(err) {
+		console.error(
+			'node-gyp not found! Please ensure node-gyp is in your PATH--\n'+
+			'Try running: `sudo npm install -g node-gyp`'
+		);
+		console.log(err.message);
+		process.exit(1);
+	});
+}
+
+// Move it to expected location
+function afterBuild() {
+	var targetPath = path.join(__dirname, 'build', debug ? 'Debug' : 'Release', 'fibers.node');
+	var installPath = path.join(__dirname, 'bin', modPath, 'fibers.node');
+
+	try {
+		fs.mkdirSync(path.join(__dirname, 'bin', modPath));
+	} catch (ex) {}
+
+	try {
+		fs.statSync(targetPath);
+	} catch (ex) {
+		console.error('Build succeeded but target not found');
+		process.exit(1);
+	}
+	fs.renameSync(targetPath, installPath);
+	console.log('Installed in `'+ installPath+ '`');
+	if (process.versions.electron) {
+		process.nextTick(function() {
+			require('electron').app.quit();
+		});
+	}
+}

+# We borrow heavily from the kernel build setup, though we are simpler since
+# we don't have Kconfig tweaking settings on us.
+
+# The implicit make rules have it looking for RCS files, among other things.
+# We instead explicitly write all the rules we care about.
+# It's even quicker (saves ~200ms) to pass -r on the command line.
+MAKEFLAGS=-r
+
+# The source directory tree.
+srcdir := ..
+abs_srcdir := $(abspath $(srcdir))
+
+# The name of the builddir.
+builddir_name ?= .
+
+# The V=1 flag on command line makes us verbosely print command lines.
+ifdef V
+  quiet=
+else
+  quiet=quiet_
+endif
+
+# Specify BUILDTYPE=Release on the command line for a release build.
+BUILDTYPE ?= Release
+
+# Directory all our build output goes into.
+# Note that this must be two directories beneath src/ for unit tests to pass,
+# as they reach into the src/ directory for data with relative paths.
+builddir ?= $(builddir_name)/$(BUILDTYPE)
+abs_builddir := $(abspath $(builddir))
+depsdir := $(builddir)/.deps
+
+# Object output directory.
+obj := $(builddir)/obj
+abs_obj := $(abspath $(obj))
+
+# We build up a list of every single one of the targets so we can slurp in the
+# generated dependency rule Makefiles in one pass.
+all_deps :=
+
+
+
+CC.target ?= $(CC)
+CFLAGS.target ?= $(CPPFLAGS) $(CFLAGS)
+CXX.target ?= $(CXX)
+CXXFLAGS.target ?= $(CPPFLAGS) $(CXXFLAGS)
+LINK.target ?= $(LINK)
+LDFLAGS.target ?= $(LDFLAGS)
+AR.target ?= $(AR)
+
+# C++ apps need to be linked with g++.
+LINK ?= $(CXX.target)
+
+# TODO(evan): move all cross-compilation logic to gyp-time so we don't need
+# to replicate this environment fallback in make as well.
+CC.host ?= gcc
+CFLAGS.host ?= $(CPPFLAGS_host) $(CFLAGS_host)
+CXX.host ?= g++
+CXXFLAGS.host ?= $(CPPFLAGS_host) $(CXXFLAGS_host)
+LINK.host ?= $(CXX.host)
+LDFLAGS.host ?=
+AR.host ?= ar
+
+# Define a dir function that can handle spaces.
+# http://www.gnu.org/software/make/manual/make.html#Syntax-of-Functions
+# "leading spaces cannot appear in the text of the first argument as written.
+# These characters can be put into the argument value by variable substitution."
+empty :=
+space := $(empty) $(empty)
+
+# http://stackoverflow.com/questions/1189781/using-make-dir-or-notdir-on-a-path-with-spaces
+replace_spaces = $(subst $(space),?,$1)
+unreplace_spaces = $(subst ?,$(space),$1)
+dirx = $(call unreplace_spaces,$(dir $(call replace_spaces,$1)))
+
+# Flags to make gcc output dependency info.  Note that you need to be
+# careful here to use the flags that ccache and distcc can understand.
+# We write to a dep file on the side first and then rename at the end
+# so we can't end up with a broken dep file.
+depfile = $(depsdir)/$(call replace_spaces,$@).d
+DEPFLAGS = -MMD -MF $(depfile).raw
+
+# We have to fixup the deps output in a few ways.
+# (1) the file output should mention the proper .o file.
+# ccache or distcc lose the path to the target, so we convert a rule of
+# the form:
+#   foobar.o: DEP1 DEP2
+# into
+#   path/to/foobar.o: DEP1 DEP2
+# (2) we want missing files not to cause us to fail to build.
+# We want to rewrite
+#   foobar.o: DEP1 DEP2 \
+#               DEP3
+# to
+#   DEP1:
+#   DEP2:
+#   DEP3:
+# so if the files are missing, they're just considered phony rules.
+# We have to do some pretty insane escaping to get those backslashes
+# and dollar signs past make, the shell, and sed at the same time.
+# Doesn't work with spaces, but that's fine: .d files have spaces in
+# their names replaced with other characters.
+define fixup_dep
+# The depfile may not exist if the input file didn't have any #includes.
+touch $(depfile).raw
+# Fixup path as in (1).
+sed -e "s|^$(notdir $@)|$@|" $(depfile).raw >> $(depfile)
+# Add extra rules as in (2).
+# We remove slashes and replace spaces with new lines;
+# remove blank lines;
+# delete the first line and append a colon to the remaining lines.
+sed -e 's|\\||' -e 'y| |\n|' $(depfile).raw |\
+  grep -v '^$$'                             |\
+  sed -e 1d -e 's|$$|:|'                     \
+    >> $(depfile)
+rm $(depfile).raw
+endef
+
+# Command definitions:
+# - cmd_foo is the actual command to run;
+# - quiet_cmd_foo is the brief-output summary of the command.
+
+quiet_cmd_cc = CC($(TOOLSET)) $@
+cmd_cc = $(CC.$(TOOLSET)) $(GYP_CFLAGS) $(DEPFLAGS) $(CFLAGS.$(TOOLSET)) -c -o $@ $<
+
+quiet_cmd_cxx = CXX($(TOOLSET)) $@
+cmd_cxx = $(CXX.$(TOOLSET)) $(GYP_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
+
+quiet_cmd_objc = CXX($(TOOLSET)) $@
+cmd_objc = $(CC.$(TOOLSET)) $(GYP_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<
+
+quiet_cmd_objcxx = CXX($(TOOLSET)) $@
+cmd_objcxx = $(CXX.$(TOOLSET)) $(GYP_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<
+
+# Commands for precompiled header files.
+quiet_cmd_pch_c = CXX($(TOOLSET)) $@
+cmd_pch_c = $(CC.$(TOOLSET)) $(GYP_PCH_CFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
+quiet_cmd_pch_cc = CXX($(TOOLSET)) $@
+cmd_pch_cc = $(CC.$(TOOLSET)) $(GYP_PCH_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
+quiet_cmd_pch_m = CXX($(TOOLSET)) $@
+cmd_pch_m = $(CC.$(TOOLSET)) $(GYP_PCH_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<
+quiet_cmd_pch_mm = CXX($(TOOLSET)) $@
+cmd_pch_mm = $(CC.$(TOOLSET)) $(GYP_PCH_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<
+
+# gyp-mac-tool is written next to the root Makefile by gyp.
+# Use $(4) for the command, since $(2) and $(3) are used as flag by do_cmd
+# already.
+quiet_cmd_mac_tool = MACTOOL $(4) $<
+cmd_mac_tool = ./gyp-mac-tool $(4) $< "$@"
+
+quiet_cmd_mac_package_framework = PACKAGE FRAMEWORK $@
+cmd_mac_package_framework = ./gyp-mac-tool package-framework "$@" $(4)
+
+quiet_cmd_infoplist = INFOPLIST $@
+cmd_infoplist = $(CC.$(TOOLSET)) -E -P -Wno-trigraphs -x c $(INFOPLIST_DEFINES) "$<" -o "$@"
+
+quiet_cmd_touch = TOUCH $@
+cmd_touch = touch $@
+
+quiet_cmd_copy = COPY $@
+# send stderr to /dev/null to ignore messages when linking directories.
+cmd_copy = rm -rf "$@" && cp -af "$<" "$@"
+
+quiet_cmd_alink = LIBTOOL-STATIC $@
+cmd_alink = rm -f $@ && ./gyp-mac-tool filter-libtool libtool $(GYP_LIBTOOLFLAGS) -static -o $@ $(filter %.o,$^)
+
+quiet_cmd_link = LINK($(TOOLSET)) $@
+cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o "$@" $(LD_INPUTS) $(LIBS)
+
+quiet_cmd_solink = SOLINK($(TOOLSET)) $@
+cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o "$@" $(LD_INPUTS) $(LIBS)
+
+quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
+cmd_solink_module = $(LINK.$(TOOLSET)) -bundle $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
+
+
+# Define an escape_quotes function to escape single quotes.
+# This allows us to handle quotes properly as long as we always use
+# use single quotes and escape_quotes.
+escape_quotes = $(subst ','\'',$(1))
+# This comment is here just to include a ' to unconfuse syntax highlighting.
+# Define an escape_vars function to escape '$' variable syntax.
+# This allows us to read/write command lines with shell variables (e.g.
+# $LD_LIBRARY_PATH), without triggering make substitution.
+escape_vars = $(subst $$,$$$$,$(1))
+# Helper that expands to a shell command to echo a string exactly as it is in
+# make. This uses printf instead of echo because printf's behaviour with respect
+# to escape sequences is more portable than echo's across different shells
+# (e.g., dash, bash).
+exact_echo = printf '%s\n' '$(call escape_quotes,$(1))'
+
+# Helper to compare the command we're about to run against the command
+# we logged the last time we ran the command.  Produces an empty
+# string (false) when the commands match.
+# Tricky point: Make has no string-equality test function.
+# The kernel uses the following, but it seems like it would have false
+# positives, where one string reordered its arguments.
+#   arg_check = $(strip $(filter-out $(cmd_$(1)), $(cmd_$@)) \
+#                       $(filter-out $(cmd_$@), $(cmd_$(1))))
+# We instead substitute each for the empty string into the other, and
+# say they're equal if both substitutions produce the empty string.
+# .d files contain ? instead of spaces, take that into account.
+command_changed = $(or $(subst $(cmd_$(1)),,$(cmd_$(call replace_spaces,$@))),\
+                       $(subst $(cmd_$(call replace_spaces,$@)),,$(cmd_$(1))))
+
+# Helper that is non-empty when a prerequisite changes.
+# Normally make does this implicitly, but we force rules to always run
+# so we can check their command lines.
+#   $? -- new prerequisites
+#   $| -- order-only dependencies
+prereq_changed = $(filter-out FORCE_DO_CMD,$(filter-out $|,$?))
+
+# Helper that executes all postbuilds until one fails.
+define do_postbuilds
+  @E=0;\
+  for p in $(POSTBUILDS); do\
+    eval $$p;\
+    E=$$?;\
+    if [ $$E -ne 0 ]; then\
+      break;\
+    fi;\
+  done;\
+  if [ $$E -ne 0 ]; then\
+    rm -rf "$@";\
+    exit $$E;\
+  fi
+endef
+
+# do_cmd: run a command via the above cmd_foo names, if necessary.
+# Should always run for a given target to handle command-line changes.
+# Second argument, if non-zero, makes it do asm/C/C++ dependency munging.
+# Third argument, if non-zero, makes it do POSTBUILDS processing.
+# Note: We intentionally do NOT call dirx for depfile, since it contains ? for
+# spaces already and dirx strips the ? characters.
+define do_cmd
+$(if $(or $(command_changed),$(prereq_changed)),
+  @$(call exact_echo,  $($(quiet)cmd_$(1)))
+  @mkdir -p "$(call dirx,$@)" "$(dir $(depfile))"
+  $(if $(findstring flock,$(word 2,$(cmd_$1))),
+    @$(cmd_$(1))
+    @echo "  $(quiet_cmd_$(1)): Finished",
+    @$(cmd_$(1))
+  )
+  @$(call exact_echo,$(call escape_vars,cmd_$(call replace_spaces,$@) := $(cmd_$(1)))) > $(depfile)
+  @$(if $(2),$(fixup_dep))
+  $(if $(and $(3), $(POSTBUILDS)),
+    $(call do_postbuilds)
+  )
+)
+endef
+
+# Declare the "all" target first so it is the default,
+# even though we don't have the deps yet.
+.PHONY: all
+all:
+
+# make looks for ways to re-generate included makefiles, but in our case, we
+# don't have a direct way. Explicitly telling make that it has nothing to do
+# for them makes it go faster.
+%.d: ;
+
+# Use FORCE_DO_CMD to force a target to run.  Should be coupled with
+# do_cmd.
+.PHONY: FORCE_DO_CMD
+FORCE_DO_CMD:
+
+TOOLSET := target
+# Suffix rules, putting all outputs into $(obj).
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.c FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cc FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cpp FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cxx FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.m FORCE_DO_CMD
+	@$(call do_cmd,objc,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.mm FORCE_DO_CMD
+	@$(call do_cmd,objcxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.S FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.s FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+
+# Try building from generated source, too.
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.c FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cc FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cpp FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cxx FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.m FORCE_DO_CMD
+	@$(call do_cmd,objc,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.mm FORCE_DO_CMD
+	@$(call do_cmd,objcxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.S FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.s FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+
+$(obj).$(TOOLSET)/%.o: $(obj)/%.c FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.cc FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.cpp FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.cxx FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.m FORCE_DO_CMD
+	@$(call do_cmd,objc,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.mm FORCE_DO_CMD
+	@$(call do_cmd,objcxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.S FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.s FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+
+
+ifeq ($(strip $(foreach prefix,$(NO_LOAD),\
+    $(findstring $(join ^,$(prefix)),\
+                 $(join ^,fibers.target.mk)))),)
+  include fibers.target.mk
+endif
+
+quiet_cmd_regen_makefile = ACTION Regenerating $@
+cmd_regen_makefile = cd $(srcdir); /usr/local/lib/node_modules/cnpm/node_modules/npminstall/node_modules/node-gyp/gyp/gyp_main.py -fmake --ignore-environment "--toplevel-dir=." -I/Users/fzy/project/koa2_Sequelize_project/node_modules/_fibers@1.0.15@fibers/build/config.gypi -I/usr/local/lib/node_modules/cnpm/node_modules/npminstall/node_modules/node-gyp/addon.gypi -I/Users/fzy/.node-gyp/8.2.1/include/node/common.gypi "--depth=." "-Goutput_dir=." "--generator-output=build" "-Dlibrary=shared_library" "-Dvisibility=default" "-Dnode_root_dir=/Users/fzy/.node-gyp/8.2.1" "-Dnode_gyp_dir=/usr/local/lib/node_modules/cnpm/node_modules/npminstall/node_modules/node-gyp" "-Dnode_lib_file=node.lib" "-Dmodule_root_dir=/Users/fzy/project/koa2_Sequelize_project/node_modules/_fibers@1.0.15@fibers" "-Dnode_engine=v8" binding.gyp
+Makefile: $(srcdir)/../../../../.node-gyp/8.2.1/include/node/common.gypi $(srcdir)/../../../../../../usr/local/lib/node_modules/cnpm/node_modules/npminstall/node_modules/node-gyp/addon.gypi $(srcdir)/build/config.gypi $(srcdir)/binding.gyp
+	$(call do_cmd,regen_makefile)
+
+# "all" is a concatenation of the "all" targets from all the included
+# sub-makefiles. This is just here to clarify.
+all:
+
+# Add in dependency-tracking rules.  $(all_deps) is the list of every single
+# target in our tree. Only consider the ones with .d (dependency) info:
+d_files := $(wildcard $(foreach f,$(all_deps),$(depsdir)/$(f).d))
+ifneq ($(d_files),)
+  include $(d_files)
+endif

+cmd_Release/fibers.node := c++ -bundle -undefined dynamic_lookup -Wl,-no_pie -Wl,-search_paths_first -mmacosx-version-min=10.7 -arch x86_64 -L./Release -stdlib=libc++  -o Release/fibers.node Release/obj.target/fibers/src/fibers.o Release/obj.target/fibers/src/coroutine.o Release/obj.target/fibers/src/libcoro/coro.o 

+cmd_Release/obj.target/fibers/src/coroutine.o := c++ '-DNODE_GYP_MODULE_NAME=fibers' '-DUSING_UV_SHARED=1' '-DUSING_V8_SHARED=1' '-DV8_DEPRECATION_WARNINGS=1' '-D_DARWIN_USE_64_BIT_INODE=1' '-D_LARGEFILE_SOURCE' '-D_FILE_OFFSET_BITS=64' '-DUSE_CORO' '-DCORO_GUARDPAGES=1' '-DCORO_SJLJ' '-DBUILDING_NODE_EXTENSION' -I/Users/fzy/.node-gyp/8.2.1/include/node -I/Users/fzy/.node-gyp/8.2.1/src -I/Users/fzy/.node-gyp/8.2.1/deps/uv/include -I/Users/fzy/.node-gyp/8.2.1/deps/v8/include  -O3 -mmacosx-version-min=10.7 -arch x86_64 -Wall -Wendif-labels -W -Wno-unused-parameter -std=gnu++0x -stdlib=libc++ -fno-rtti -fno-exceptions -fno-threadsafe-statics -fno-strict-aliasing -MMD -MF ./Release/.deps/Release/obj.target/fibers/src/coroutine.o.d.raw   -c -o Release/obj.target/fibers/src/coroutine.o ../src/coroutine.cc
+Release/obj.target/fibers/src/coroutine.o: ../src/coroutine.cc \
+  ../src/coroutine.h /Users/fzy/.node-gyp/8.2.1/include/node/node.h \
+  /Users/fzy/.node-gyp/8.2.1/include/node/v8.h \
+  /Users/fzy/.node-gyp/8.2.1/include/node/v8-version.h \
+  /Users/fzy/.node-gyp/8.2.1/include/node/v8config.h \
+  /Users/fzy/.node-gyp/8.2.1/include/node/node_version.h \
+  ../src/libcoro/coro.h ../src/v8-version.h
+../src/coroutine.cc:
+../src/coroutine.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/node.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/v8.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/v8-version.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/v8config.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/node_version.h:
+../src/libcoro/coro.h:
+../src/v8-version.h:

+cmd_Release/obj.target/fibers/src/fibers.o := c++ '-DNODE_GYP_MODULE_NAME=fibers' '-DUSING_UV_SHARED=1' '-DUSING_V8_SHARED=1' '-DV8_DEPRECATION_WARNINGS=1' '-D_DARWIN_USE_64_BIT_INODE=1' '-D_LARGEFILE_SOURCE' '-D_FILE_OFFSET_BITS=64' '-DUSE_CORO' '-DCORO_GUARDPAGES=1' '-DCORO_SJLJ' '-DBUILDING_NODE_EXTENSION' -I/Users/fzy/.node-gyp/8.2.1/include/node -I/Users/fzy/.node-gyp/8.2.1/src -I/Users/fzy/.node-gyp/8.2.1/deps/uv/include -I/Users/fzy/.node-gyp/8.2.1/deps/v8/include  -O3 -mmacosx-version-min=10.7 -arch x86_64 -Wall -Wendif-labels -W -Wno-unused-parameter -std=gnu++0x -stdlib=libc++ -fno-rtti -fno-exceptions -fno-threadsafe-statics -fno-strict-aliasing -MMD -MF ./Release/.deps/Release/obj.target/fibers/src/fibers.o.d.raw   -c -o Release/obj.target/fibers/src/fibers.o ../src/fibers.cc
+Release/obj.target/fibers/src/fibers.o: ../src/fibers.cc \
+  ../src/coroutine.h /Users/fzy/.node-gyp/8.2.1/include/node/node.h \
+  /Users/fzy/.node-gyp/8.2.1/include/node/v8.h \
+  /Users/fzy/.node-gyp/8.2.1/include/node/v8-version.h \
+  /Users/fzy/.node-gyp/8.2.1/include/node/v8config.h \
+  /Users/fzy/.node-gyp/8.2.1/include/node/node_version.h \
+  ../src/libcoro/coro.h ../src/v8-version.h
+../src/fibers.cc:
+../src/coroutine.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/node.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/v8.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/v8-version.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/v8config.h:
+/Users/fzy/.node-gyp/8.2.1/include/node/node_version.h:
+../src/libcoro/coro.h:
+../src/v8-version.h:

+cmd_Release/obj.target/fibers/src/libcoro/coro.o := cc '-DNODE_GYP_MODULE_NAME=fibers' '-DUSING_UV_SHARED=1' '-DUSING_V8_SHARED=1' '-DV8_DEPRECATION_WARNINGS=1' '-D_DARWIN_USE_64_BIT_INODE=1' '-D_LARGEFILE_SOURCE' '-D_FILE_OFFSET_BITS=64' '-DUSE_CORO' '-DCORO_GUARDPAGES=1' '-DCORO_SJLJ' '-DBUILDING_NODE_EXTENSION' -I/Users/fzy/.node-gyp/8.2.1/include/node -I/Users/fzy/.node-gyp/8.2.1/src -I/Users/fzy/.node-gyp/8.2.1/deps/uv/include -I/Users/fzy/.node-gyp/8.2.1/deps/v8/include  -O3 -mmacosx-version-min=10.7 -arch x86_64 -Wall -Wendif-labels -W -Wno-unused-parameter -fno-strict-aliasing -MMD -MF ./Release/.deps/Release/obj.target/fibers/src/libcoro/coro.o.d.raw   -c -o Release/obj.target/fibers/src/libcoro/coro.o ../src/libcoro/coro.c
+Release/obj.target/fibers/src/libcoro/coro.o: ../src/libcoro/coro.c \
+  ../src/libcoro/coro.h
+../src/libcoro/coro.c:
+../src/libcoro/coro.h:

+# This file is generated by gyp; do not edit.
+
+export builddir_name ?= ./build/.
+.PHONY: all
+all:
+	$(MAKE) fibers

+# Do not edit. File was generated by node-gyp's "configure" step
+{
+  "target_defaults": {
+    "cflags": [],
+    "default_configuration": "Release",
+    "defines": [],
+    "include_dirs": [],
+    "libraries": []
+  },
+  "variables": {
+    "asan": 0,
+    "coverage": "false",
+    "debug_devtools": "node",
+    "force_dynamic_crt": 0,
+    "host_arch": "x64",
+    "icu_data_file": "icudt59l.dat",
+    "icu_data_in": "../../deps/icu-small/source/data/in/icudt59l.dat",
+    "icu_endianness": "l",
+    "icu_gyp_path": "tools/icu/icu-generic.gyp",
+    "icu_locales": "en,root",
+    "icu_path": "deps/icu-small",
+    "icu_small": "true",
+    "icu_ver_major": "59",
+    "llvm_version": 0,
+    "node_byteorder": "little",
+    "node_enable_d8": "false",
+    "node_enable_v8_vtunejit": "false",
+    "node_install_npm": "true",
+    "node_module_version": 57,
+    "node_no_browser_globals": "false",
+    "node_prefix": "/",
+    "node_release_urlbase": "https://nodejs.org/download/release/",
+    "node_shared": "false",
+    "node_shared_cares": "false",
+    "node_shared_http_parser": "false",
+    "node_shared_libuv": "false",
+    "node_shared_openssl": "false",
+    "node_shared_zlib": "false",
+    "node_tag": "",
+    "node_use_bundled_v8": "true",
+    "node_use_dtrace": "true",
+    "node_use_etw": "false",
+    "node_use_lttng": "false",
+    "node_use_openssl": "true",
+    "node_use_perfctr": "false",
+    "node_use_v8_platform": "true",
+    "node_without_node_options": "false",
+    "openssl_fips": "",
+    "openssl_no_asm": 0,
+    "shlib_suffix": "57.dylib",
+    "target_arch": "x64",
+    "uv_parent_path": "/deps/uv/",
+    "uv_use_dtrace": "true",
+    "v8_enable_gdbjit": 0,
+    "v8_enable_i18n_support": 1,
+    "v8_enable_inspector": 1,
+    "v8_no_strict_aliasing": 1,
+    "v8_optimized_debug": 0,
+    "v8_promise_internal_field_count": 1,
+    "v8_random_seed": 0,
+    "v8_trace_maps": 0,
+    "v8_use_snapshot": "false",
+    "want_separate_host_toolset": 0,
+    "want_separate_host_toolset_mkpeephole": 0,
+    "xcode_version": "7.0",
+    "nodedir": "/Users/fzy/.node-gyp/8.2.1",
+    "copy_dev_lib": "true",
+    "standalone_static_library": 1,
+    "registry": "https://registry.npm.taobao.org",
+    "userconfig": "/Users/fzy/.cnpmrc",
+    "r": "https://registry.npm.taobao.org",
+    "disturl": "https://npm.taobao.org/mirrors/node",
+    "cache": "/Users/fzy/.npminstall_tarball"
+  }
+}

+# This file is generated by gyp; do not edit.
+
+TOOLSET := target
+TARGET := fibers
+DEFS_Debug := \
+	'-DNODE_GYP_MODULE_NAME=fibers' \
+	'-DUSING_UV_SHARED=1' \
+	'-DUSING_V8_SHARED=1' \
+	'-DV8_DEPRECATION_WARNINGS=1' \
+	'-D_DARWIN_USE_64_BIT_INODE=1' \
+	'-D_LARGEFILE_SOURCE' \
+	'-D_FILE_OFFSET_BITS=64' \
+	'-DUSE_CORO' \
+	'-DCORO_GUARDPAGES=1' \
+	'-DCORO_SJLJ' \
+	'-DBUILDING_NODE_EXTENSION' \
+	'-DDEBUG' \
+	'-D_DEBUG' \
+	'-DV8_ENABLE_CHECKS'
+
+# Flags passed to all source files.
+CFLAGS_Debug := \
+	-O0 \
+	-gdwarf-2 \
+	-mmacosx-version-min=10.7 \
+	-arch x86_64 \
+	-Wall \
+	-Wendif-labels \
+	-W \
+	-Wno-unused-parameter
+
+# Flags passed to only C files.
+CFLAGS_C_Debug := \
+	-fno-strict-aliasing
+
+# Flags passed to only C++ files.
+CFLAGS_CC_Debug := \
+	-std=gnu++0x \
+	-stdlib=libc++ \
+	-fno-rtti \
+	-fno-exceptions \
+	-fno-threadsafe-statics \
+	-fno-strict-aliasing
+
+# Flags passed to only ObjC files.
+CFLAGS_OBJC_Debug :=
+
+# Flags passed to only ObjC++ files.
+CFLAGS_OBJCC_Debug :=
+
+INCS_Debug := \
+	-I/Users/fzy/.node-gyp/8.2.1/include/node \
+	-I/Users/fzy/.node-gyp/8.2.1/src \
+	-I/Users/fzy/.node-gyp/8.2.1/deps/uv/include \
+	-I/Users/fzy/.node-gyp/8.2.1/deps/v8/include
+
+DEFS_Release := \
+	'-DNODE_GYP_MODULE_NAME=fibers' \
+	'-DUSING_UV_SHARED=1' \
+	'-DUSING_V8_SHARED=1' \
+	'-DV8_DEPRECATION_WARNINGS=1' \
+	'-D_DARWIN_USE_64_BIT_INODE=1' \
+	'-D_LARGEFILE_SOURCE' \
+	'-D_FILE_OFFSET_BITS=64' \
+	'-DUSE_CORO' \
+	'-DCORO_GUARDPAGES=1' \
+	'-DCORO_SJLJ' \
+	'-DBUILDING_NODE_EXTENSION'
+
+# Flags passed to all source files.
+CFLAGS_Release := \
+	-O3 \
+	-mmacosx-version-min=10.7 \
+	-arch x86_64 \
+	-Wall \
+	-Wendif-labels \
+	-W \
+	-Wno-unused-parameter
+
+# Flags passed to only C files.
+CFLAGS_C_Release := \
+	-fno-strict-aliasing
+
+# Flags passed to only C++ files.
+CFLAGS_CC_Release := \
+	-std=gnu++0x \
+	-stdlib=libc++ \
+	-fno-rtti \
+	-fno-exceptions \
+	-fno-threadsafe-statics \
+	-fno-strict-aliasing
+
+# Flags passed to only ObjC files.
+CFLAGS_OBJC_Release :=
+
+# Flags passed to only ObjC++ files.
+CFLAGS_OBJCC_Release :=
+
+INCS_Release := \
+	-I/Users/fzy/.node-gyp/8.2.1/include/node \
+	-I/Users/fzy/.node-gyp/8.2.1/src \
+	-I/Users/fzy/.node-gyp/8.2.1/deps/uv/include \
+	-I/Users/fzy/.node-gyp/8.2.1/deps/v8/include
+
+OBJS := \
+	$(obj).target/$(TARGET)/src/fibers.o \
+	$(obj).target/$(TARGET)/src/coroutine.o \
+	$(obj).target/$(TARGET)/src/libcoro/coro.o
+
+# Add to the list of files we specially track dependencies for.
+all_deps += $(OBJS)
+
+# CFLAGS et al overrides must be target-local.
+# See "Target-specific Variable Values" in the GNU Make manual.
+$(OBJS): TOOLSET := $(TOOLSET)
+$(OBJS): GYP_CFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE))  $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE))
+$(OBJS): GYP_CXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE))  $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE))
+$(OBJS): GYP_OBJCFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE))  $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE)) $(CFLAGS_OBJC_$(BUILDTYPE))
+$(OBJS): GYP_OBJCXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE))  $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE)) $(CFLAGS_OBJCC_$(BUILDTYPE))
+
+# Suffix rules, putting all outputs into $(obj).
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(srcdir)/%.cc FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(srcdir)/%.c FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+
+# Try building from generated source, too.
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj).$(TOOLSET)/%.cc FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj).$(TOOLSET)/%.c FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj)/%.cc FORCE_DO_CMD
+	@$(call do_cmd,cxx,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj)/%.c FORCE_DO_CMD
+	@$(call do_cmd,cc,1)
+
+# End of this set of suffix rules
+### Rules for final target.
+LDFLAGS_Debug := \
+	-undefined dynamic_lookup \
+	-Wl,-no_pie \
+	-Wl,-search_paths_first \
+	-mmacosx-version-min=10.7 \
+	-arch x86_64 \
+	-L$(builddir) \
+	-stdlib=libc++
+
+LIBTOOLFLAGS_Debug := \
+	-undefined dynamic_lookup \
+	-Wl,-no_pie \
+	-Wl,-search_paths_first
+
+LDFLAGS_Release := \
+	-undefined dynamic_lookup \
+	-Wl,-no_pie \
+	-Wl,-search_paths_first \
+	-mmacosx-version-min=10.7 \
+	-arch x86_64 \
+	-L$(builddir) \
+	-stdlib=libc++
+
+LIBTOOLFLAGS_Release := \
+	-undefined dynamic_lookup \
+	-Wl,-no_pie \
+	-Wl,-search_paths_first
+
+LIBS :=
+
+$(builddir)/fibers.node: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))
+$(builddir)/fibers.node: LIBS := $(LIBS)
+$(builddir)/fibers.node: GYP_LIBTOOLFLAGS := $(LIBTOOLFLAGS_$(BUILDTYPE))
+$(builddir)/fibers.node: TOOLSET := $(TOOLSET)
+$(builddir)/fibers.node: $(OBJS) FORCE_DO_CMD
+	$(call do_cmd,solink_module)
+
+all_deps += $(builddir)/fibers.node
+# Add target alias
+.PHONY: fibers
+fibers: $(builddir)/fibers.node
+
+# Short alias for building this executable.
+.PHONY: fibers.node
+fibers.node: $(builddir)/fibers.node
+
+# Add executable to "all" target.
+.PHONY: all
+all: $(builddir)/fibers.node
+

+#!/usr/bin/env python
+# Generated by gyp. Do not edit.
+# Copyright (c) 2012 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Utility functions to perform Xcode-style build steps.
+
+These functions are executed via gyp-mac-tool when using the Makefile generator.
+"""
+
+import fcntl
+import fnmatch
+import glob
+import json
+import os
+import plistlib
+import re
+import shutil
+import string
+import subprocess
+import sys
+import tempfile
+
+
+def main(args):
+  executor = MacTool()
+  exit_code = executor.Dispatch(args)
+  if exit_code is not None:
+    sys.exit(exit_code)
+
+
+class MacTool(object):
+  """This class performs all the Mac tooling steps. The methods can either be
+  executed directly, or dispatched from an argument list."""
+
+  def Dispatch(self, args):
+    """Dispatches a string command to a method."""
+    if len(args) < 1:
+      raise Exception("Not enough arguments")
+
+    method = "Exec%s" % self._CommandifyName(args[0])
+    return getattr(self, method)(*args[1:])
+
+  def _CommandifyName(self, name_string):
+    """Transforms a tool name like copy-info-plist to CopyInfoPlist"""
+    return name_string.title().replace('-', '')
+
+  def ExecCopyBundleResource(self, source, dest, convert_to_binary):
+    """Copies a resource file to the bundle/Resources directory, performing any
+    necessary compilation on each resource."""
+    extension = os.path.splitext(source)[1].lower()
+    if os.path.isdir(source):
+      # Copy tree.
+      # TODO(thakis): This copies file attributes like mtime, while the
+      # single-file branch below doesn't. This should probably be changed to
+      # be consistent with the single-file branch.
+      if os.path.exists(dest):
+        shutil.rmtree(dest)
+      shutil.copytree(source, dest)
+    elif extension == '.xib':
+      return self._CopyXIBFile(source, dest)
+    elif extension == '.storyboard':
+      return self._CopyXIBFile(source, dest)
+    elif extension == '.strings':
+      self._CopyStringsFile(source, dest, convert_to_binary)
+    else:
+      shutil.copy(source, dest)
+
+  def _CopyXIBFile(self, source, dest):
+    """Compiles a XIB file with ibtool into a binary plist in the bundle."""
+
+    # ibtool sometimes crashes with relative paths. See crbug.com/314728.
+    base = os.path.dirname(os.path.realpath(__file__))
+    if os.path.relpath(source):
+      source = os.path.join(base, source)
+    if os.path.relpath(dest):
+      dest = os.path.join(base, dest)
+
+    args = ['xcrun', 'ibtool', '--errors', '--warnings', '--notices',
+        '--output-format', 'human-readable-text', '--compile', dest, source]
+    ibtool_section_re = re.compile(r'/\*.*\*/')
+    ibtool_re = re.compile(r'.*note:.*is clipping its content')
+    ibtoolout = subprocess.Popen(args, stdout=subprocess.PIPE)
+    current_section_header = None
+    for line in ibtoolout.stdout:
+      if ibtool_section_re.match(line):
+        current_section_header = line
+      elif not ibtool_re.match(line):
+        if current_section_header:
+          sys.stdout.write(current_section_header)
+          current_section_header = None
+        sys.stdout.write(line)
+    return ibtoolout.returncode
+
+  def _ConvertToBinary(self, dest):
+    subprocess.check_call([
+        'xcrun', 'plutil', '-convert', 'binary1', '-o', dest, dest])
+
+  def _CopyStringsFile(self, source, dest, convert_to_binary):
+    """Copies a .strings file using iconv to reconvert the input into UTF-16."""
+    input_code = self._DetectInputEncoding(source) or "UTF-8"
+
+    # Xcode's CpyCopyStringsFile / builtin-copyStrings seems to call
+    # CFPropertyListCreateFromXMLData() behind the scenes; at least it prints
+    #     CFPropertyListCreateFromXMLData(): Old-style plist parser: missing
+    #     semicolon in dictionary.
+    # on invalid files. Do the same kind of validation.
+    import CoreFoundation
+    s = open(source, 'rb').read()
+    d = CoreFoundation.CFDataCreate(None, s, len(s))
+    _, error = CoreFoundation.CFPropertyListCreateFromXMLData(None, d, 0, None)
+    if error:
+      return
+
+    fp = open(dest, 'wb')
+    fp.write(s.decode(input_code).encode('UTF-16'))
+    fp.close()
+
+    if convert_to_binary == 'True':
+      self._ConvertToBinary(dest)
+
+  def _DetectInputEncoding(self, file_name):
+    """Reads the first few bytes from file_name and tries to guess the text
+    encoding. Returns None as a guess if it can't detect it."""
+    fp = open(file_name, 'rb')
+    try:
+      header = fp.read(3)
+    except e:
+      fp.close()
+      return None
+    fp.close()
+    if header.startswith("\xFE\xFF"):
+      return "UTF-16"
+    elif header.startswith("\xFF\xFE"):
+      return "UTF-16"
+    elif header.startswith("\xEF\xBB\xBF"):
+      return "UTF-8"
+    else:
+      return None
+
+  def ExecCopyInfoPlist(self, source, dest, convert_to_binary, *keys):
+    """Copies the |source| Info.plist to the destination directory |dest|."""
+    # Read the source Info.plist into memory.
+    fd = open(source, 'r')
+    lines = fd.read()
+    fd.close()
+
+    # Insert synthesized key/value pairs (e.g. BuildMachineOSBuild).
+    plist = plistlib.readPlistFromString(lines)
+    if keys:
+      plist = dict(plist.items() + json.loads(keys[0]).items())
+    lines = plistlib.writePlistToString(plist)
+
+    # Go through all the environment variables and replace them as variables in
+    # the file.
+    IDENT_RE = re.compile(r'[/\s]')
+    for key in os.environ:
+      if key.startswith('_'):
+        continue
+      evar = '${%s}' % key
+      evalue = os.environ[key]
+      lines = string.replace(lines, evar, evalue)
+
+      # Xcode supports various suffices on environment variables, which are
+      # all undocumented. :rfc1034identifier is used in the standard project
+      # template these days, and :identifier was used earlier. They are used to
+      # convert non-url characters into things that look like valid urls --
+      # except that the replacement character for :identifier, '_' isn't valid
+      # in a URL either -- oops, hence :rfc1034identifier was born.
+      evar = '${%s:identifier}' % key
+      evalue = IDENT_RE.sub('_', os.environ[key])
+      lines = string.replace(lines, evar, evalue)
+
+      evar = '${%s:rfc1034identifier}' % key
+      evalue = IDENT_RE.sub('-', os.environ[key])
+      lines = string.replace(lines, evar, evalue)
+
+    # Remove any keys with values that haven't been replaced.
+    lines = lines.split('\n')
+    for i in range(len(lines)):
+      if lines[i].strip().startswith("<string>${"):
+        lines[i] = None
+        lines[i - 1] = None
+    lines = '\n'.join(filter(lambda x: x is not None, lines))
+
+    # Write out the file with variables replaced.
+    fd = open(dest, 'w')
+    fd.write(lines)
+    fd.close()
+
+    # Now write out PkgInfo file now that the Info.plist file has been
+    # "compiled".
+    self._WritePkgInfo(dest)
+
+    if convert_to_binary == 'True':
+      self._ConvertToBinary(dest)
+
+  def _WritePkgInfo(self, info_plist):
+    """This writes the PkgInfo file from the data stored in Info.plist."""
+    plist = plistlib.readPlist(info_plist)
+    if not plist:
+      return
+
+    # Only create PkgInfo for executable types.
+    package_type = plist['CFBundlePackageType']
+    if package_type != 'APPL':
+      return
+
+    # The format of PkgInfo is eight characters, representing the bundle type
+    # and bundle signature, each four characters. If that is missing, four
+    # '?' characters are used instead.
+    signature_code = plist.get('CFBundleSignature', '????')
+    if len(signature_code) != 4:  # Wrong length resets everything, too.
+      signature_code = '?' * 4
+
+    dest = os.path.join(os.path.dirname(info_plist), 'PkgInfo')
+    fp = open(dest, 'w')
+    fp.write('%s%s' % (package_type, signature_code))
+    fp.close()
+
+  def ExecFlock(self, lockfile, *cmd_list):
+    """Emulates the most basic behavior of Linux's flock(1)."""
+    # Rely on exception handling to report errors.
+    fd = os.open(lockfile, os.O_RDONLY|os.O_NOCTTY|os.O_CREAT, 0o666)
+    fcntl.flock(fd, fcntl.LOCK_EX)
+    return subprocess.call(cmd_list)
+
+  def ExecFilterLibtool(self, *cmd_list):
+    """Calls libtool and filters out '/path/to/libtool: file: foo.o has no
+    symbols'."""
+    libtool_re = re.compile(r'^.*libtool: file: .* has no symbols$')
+    libtool_re5 = re.compile(
+        r'^.*libtool: warning for library: ' +
+        r'.* the table of contents is empty ' +
+        r'\(no object file members in the library define global symbols\)$')
+    env = os.environ.copy()
+    # Ref:
+    # http://www.opensource.apple.com/source/cctools/cctools-809/misc/libtool.c
+    # The problem with this flag is that it resets the file mtime on the file to
+    # epoch=0, e.g. 1970-1-1 or 1969-12-31 depending on timezone.
+    env['ZERO_AR_DATE'] = '1'
+    libtoolout = subprocess.Popen(cmd_list, stderr=subprocess.PIPE, env=env)
+    _, err = libtoolout.communicate()
+    for line in err.splitlines():
+      if not libtool_re.match(line) and not libtool_re5.match(line):
+        print >>sys.stderr, line
+    # Unconditionally touch the output .a file on the command line if present
+    # and the command succeeded. A bit hacky.
+    if not libtoolout.returncode:
+      for i in range(len(cmd_list) - 1):
+        if cmd_list[i] == "-o" and cmd_list[i+1].endswith('.a'):
+          os.utime(cmd_list[i+1], None)
+          break
+    return libtoolout.returncode
+
+  def ExecPackageFramework(self, framework, version):
+    """Takes a path to Something.framework and the Current version of that and
+    sets up all the symlinks."""
+    # Find the name of the binary based on the part before the ".framework".
+    binary = os.path.basename(framework).split('.')[0]
+
+    CURRENT = 'Current'
+    RESOURCES = 'Resources'
+    VERSIONS = 'Versions'
+
+    if not os.path.exists(os.path.join(framework, VERSIONS, version, binary)):
+      # Binary-less frameworks don't seem to contain symlinks (see e.g.
+      # chromium's out/Debug/org.chromium.Chromium.manifest/ bundle).
+      return
+
+    # Move into the framework directory to set the symlinks correctly.
+    pwd = os.getcwd()
+    os.chdir(framework)
+
+    # Set up the Current version.
+    self._Relink(version, os.path.join(VERSIONS, CURRENT))
+
+    # Set up the root symlinks.
+    self._Relink(os.path.join(VERSIONS, CURRENT, binary), binary)
+    self._Relink(os.path.join(VERSIONS, CURRENT, RESOURCES), RESOURCES)
+
+    # Back to where we were before!
+    os.chdir(pwd)
+
+  def _Relink(self, dest, link):
+    """Creates a symlink to |dest| named |link|. If |link| already exists,
+    it is overwritten."""
+    if os.path.lexists(link):
+      os.remove(link)
+    os.symlink(dest, link)
+
+  def ExecCompileXcassets(self, keys, *inputs):
+    """Compiles multiple .xcassets files into a single .car file.
+
+    This invokes 'actool' to compile all the inputs .xcassets files. The
+    |keys| arguments is a json-encoded dictionary of extra arguments to
+    pass to 'actool' when the asset catalogs contains an application icon
+    or a launch image.
+
+    Note that 'actool' does not create the Assets.car file if the asset
+    catalogs does not contains imageset.
+    """
+    command_line = [
+      'xcrun', 'actool', '--output-format', 'human-readable-text',
+      '--compress-pngs', '--notices', '--warnings', '--errors',
+    ]
+    is_iphone_target = 'IPHONEOS_DEPLOYMENT_TARGET' in os.environ
+    if is_iphone_target:
+      platform = os.environ['CONFIGURATION'].split('-')[-1]
+      if platform not in ('iphoneos', 'iphonesimulator'):
+        platform = 'iphonesimulator'
+      command_line.extend([
+          '--platform', platform, '--target-device', 'iphone',
+          '--target-device', 'ipad', '--minimum-deployment-target',
+          os.environ['IPHONEOS_DEPLOYMENT_TARGET'], '--compile',
+          os.path.abspath(os.environ['CONTENTS_FOLDER_PATH']),
+      ])
+    else:
+      command_line.extend([
+          '--platform', 'macosx', '--target-device', 'mac',
+          '--minimum-deployment-target', os.environ['MACOSX_DEPLOYMENT_TARGET'],
+          '--compile',
+          os.path.abspath(os.environ['UNLOCALIZED_RESOURCES_FOLDER_PATH']),
+      ])
+    if keys:
+      keys = json.loads(keys)
+      for key, value in keys.iteritems():
+        arg_name = '--' + key
+        if isinstance(value, bool):
+          if value:
+            command_line.append(arg_name)
+        elif isinstance(value, list):
+          for v in value:
+            command_line.append(arg_name)
+            command_line.append(str(v))
+        else:
+          command_line.append(arg_name)
+          command_line.append(str(value))
+    # Note: actool crashes if inputs path are relative, so use os.path.abspath
+    # to get absolute path name for inputs.
+    command_line.extend(map(os.path.abspath, inputs))
+    subprocess.check_call(command_line)
+
+  def ExecMergeInfoPlist(self, output, *inputs):
+    """Merge multiple .plist files into a single .plist file."""
+    merged_plist = {}
+    for path in inputs:
+      plist = self._LoadPlistMaybeBinary(path)
+      self._MergePlist(merged_plist, plist)
+    plistlib.writePlist(merged_plist, output)
+
+  def ExecCodeSignBundle(self, key, resource_rules, entitlements, provisioning):
+    """Code sign a bundle.
+
+    This function tries to code sign an iOS bundle, following the same
+    algorithm as Xcode:
+      1. copy ResourceRules.plist from the user or the SDK into the bundle,
+      2. pick the provisioning profile that best match the bundle identifier,
+         and copy it into the bundle as embedded.mobileprovision,
+      3. copy Entitlements.plist from user or SDK next to the bundle,
+      4. code sign the bundle.
+    """
+    resource_rules_path = self._InstallResourceRules(resource_rules)
+    substitutions, overrides = self._InstallProvisioningProfile(
+        provisioning, self._GetCFBundleIdentifier())
+    entitlements_path = self._InstallEntitlements(
+        entitlements, substitutions, overrides)
+    subprocess.check_call([
+        'codesign', '--force', '--sign', key, '--resource-rules',
+        resource_rules_path, '--entitlements', entitlements_path,
+        os.path.join(
+            os.environ['TARGET_BUILD_DIR'],
+            os.environ['FULL_PRODUCT_NAME'])])
+
+  def _InstallResourceRules(self, resource_rules):
+    """Installs ResourceRules.plist from user or SDK into the bundle.
+
+    Args:
+      resource_rules: string, optional, path to the ResourceRules.plist file
+        to use, default to "${SDKROOT}/ResourceRules.plist"
+
+    Returns:
+      Path to the copy of ResourceRules.plist into the bundle.
+    """
+    source_path = resource_rules
+    target_path = os.path.join(
+        os.environ['BUILT_PRODUCTS_DIR'],
+        os.environ['CONTENTS_FOLDER_PATH'],
+        'ResourceRules.plist')
+    if not source_path:
+      source_path = os.path.join(
+          os.environ['SDKROOT'], 'ResourceRules.plist')
+    shutil.copy2(source_path, target_path)
+    return target_path
+
+  def _InstallProvisioningProfile(self, profile, bundle_identifier):
+    """Installs embedded.mobileprovision into the bundle.
+
+    Args:
+      profile: string, optional, short name of the .mobileprovision file
+        to use, if empty or the file is missing, the best file installed
+        will be used
+      bundle_identifier: string, value of CFBundleIdentifier from Info.plist
+
+    Returns:
+      A tuple containing two dictionary: variables substitutions and values
+      to overrides when generating the entitlements file.
+    """
+    source_path, provisioning_data, team_id = self._FindProvisioningProfile(
+        profile, bundle_identifier)
+    target_path = os.path.join(
+        os.environ['BUILT_PRODUCTS_DIR'],
+        os.environ['CONTENTS_FOLDER_PATH'],
+        'embedded.mobileprovision')
+    shutil.copy2(source_path, target_path)
+    substitutions = self._GetSubstitutions(bundle_identifier, team_id + '.')
+    return substitutions, provisioning_data['Entitlements']
+
+  def _FindProvisioningProfile(self, profile, bundle_identifier):
+    """Finds the .mobileprovision file to use for signing the bundle.
+
+    Checks all the installed provisioning profiles (or if the user specified
+    the PROVISIONING_PROFILE variable, only consult it) and select the most
+    specific that correspond to the bundle identifier.
+
+    Args:
+      profile: string, optional, short name of the .mobileprovision file
+        to use, if empty or the file is missing, the best file installed
+        will be used
+      bundle_identifier: string, value of CFBundleIdentifier from Info.plist
+
+    Returns:
+      A tuple of the path to the selected provisioning profile, the data of
+      the embedded plist in the provisioning profile and the team identifier
+      to use for code signing.
+
+    Raises:
+      SystemExit: if no .mobileprovision can be used to sign the bundle.
+    """
+    profiles_dir = os.path.join(
+        os.environ['HOME'], 'Library', 'MobileDevice', 'Provisioning Profiles')
+    if not os.path.isdir(profiles_dir):
+      print >>sys.stderr, (
+          'cannot find mobile provisioning for %s' % bundle_identifier)
+      sys.exit(1)
+    provisioning_profiles = None
+    if profile:
+      profile_path = os.path.join(profiles_dir, profile + '.mobileprovision')
+      if os.path.exists(profile_path):
+        provisioning_profiles = [profile_path]
+    if not provisioning_profiles:
+      provisioning_profiles = glob.glob(
+          os.path.join(profiles_dir, '*.mobileprovision'))
+    valid_provisioning_profiles = {}
+    for profile_path in provisioning_profiles:
+      profile_data = self._LoadProvisioningProfile(profile_path)
+      app_id_pattern = profile_data.get(
+          'Entitlements', {}).get('application-identifier', '')
+      for team_identifier in profile_data.get('TeamIdentifier', []):
+        app_id = '%s.%s' % (team_identifier, bundle_identifier)
+        if fnmatch.fnmatch(app_id, app_id_pattern):
+          valid_provisioning_profiles[app_id_pattern] = (
+              profile_path, profile_data, team_identifier)
+    if not valid_provisioning_profiles:
+      print >>sys.stderr, (
+          'cannot find mobile provisioning for %s' % bundle_identifier)
+      sys.exit(1)
+    # If the user has multiple provisioning profiles installed that can be
+    # used for ${bundle_identifier}, pick the most specific one (ie. the
+    # provisioning profile whose pattern is the longest).
+    selected_key = max(valid_provisioning_profiles, key=lambda v: len(v))
+    return valid_provisioning_profiles[selected_key]
+
+  def _LoadProvisioningProfile(self, profile_path):
+    """Extracts the plist embedded in a provisioning profile.
+
+    Args:
+      profile_path: string, path to the .mobileprovision file
+
+    Returns:
+      Content of the plist embedded in the provisioning profile as a dictionary.
+    """
+    with tempfile.NamedTemporaryFile() as temp:
+      subprocess.check_call([
+          'security', 'cms', '-D', '-i', profile_path, '-o', temp.name])
+      return self._LoadPlistMaybeBinary(temp.name)
+
+  def _MergePlist(self, merged_plist, plist):
+    """Merge |plist| into |merged_plist|."""
+    for key, value in plist.iteritems():
+      if isinstance(value, dict):
+        merged_value = merged_plist.get(key, {})
+        if isinstance(merged_value, dict):
+          self._MergePlist(merged_value, value)
+          merged_plist[key] = merged_value
+        else:
+          merged_plist[key] = value
+      else:
+        merged_plist[key] = value
+
+  def _LoadPlistMaybeBinary(self, plist_path):
+    """Loads into a memory a plist possibly encoded in binary format.
+
+    This is a wrapper around plistlib.readPlist that tries to convert the
+    plist to the XML format if it can't be parsed (assuming that it is in
+    the binary format).
+
+    Args:
+      plist_path: string, path to a plist file, in XML or binary format
+
+    Returns:
+      Content of the plist as a dictionary.
+    """
+    try:
+      # First, try to read the file using plistlib that only supports XML,
+      # and if an exception is raised, convert a temporary copy to XML and
+      # load that copy.
+      return plistlib.readPlist(plist_path)
+    except:
+      pass
+    with tempfile.NamedTemporaryFile() as temp:
+      shutil.copy2(plist_path, temp.name)
+      subprocess.check_call(['plutil', '-convert', 'xml1', temp.name])
+      return plistlib.readPlist(temp.name)
+
+  def _GetSubstitutions(self, bundle_identifier, app_identifier_prefix):
+    """Constructs a dictionary of variable substitutions for Entitlements.plist.
+
+    Args:
+      bundle_identifier: string, value of CFBundleIdentifier from Info.plist
+      app_identifier_prefix: string, value for AppIdentifierPrefix
+
+    Returns:
+      Dictionary of substitutions to apply when generating Entitlements.plist.
+    """
+    return {
+      'CFBundleIdentifier': bundle_identifier,
+      'AppIdentifierPrefix': app_identifier_prefix,
+    }
+
+  def _GetCFBundleIdentifier(self):
+    """Extracts CFBundleIdentifier value from Info.plist in the bundle.
+
+    Returns:
+      Value of CFBundleIdentifier in the Info.plist located in the bundle.
+    """
+    info_plist_path = os.path.join(
+        os.environ['TARGET_BUILD_DIR'],
+        os.environ['INFOPLIST_PATH'])
+    info_plist_data = self._LoadPlistMaybeBinary(info_plist_path)
+    return info_plist_data['CFBundleIdentifier']
+
+  def _InstallEntitlements(self, entitlements, substitutions, overrides):
+    """Generates and install the ${BundleName}.xcent entitlements file.
+
+    Expands variables "$(variable)" pattern in the source entitlements file,
+    add extra entitlements defined in the .mobileprovision file and the copy
+    the generated plist to "${BundlePath}.xcent".
+
+    Args:
+      entitlements: string, optional, path to the Entitlements.plist template
+        to use, defaults to "${SDKROOT}/Entitlements.plist"
+      substitutions: dictionary, variable substitutions
+      overrides: dictionary, values to add to the entitlements
+
+    Returns:
+      Path to the generated entitlements file.
+    """
+    source_path = entitlements
+    target_path = os.path.join(
+        os.environ['BUILT_PRODUCTS_DIR'],
+        os.environ['PRODUCT_NAME'] + '.xcent')
+    if not source_path:
+      source_path = os.path.join(
+          os.environ['SDKROOT'],
+          'Entitlements.plist')
+    shutil.copy2(source_path, target_path)
+    data = self._LoadPlistMaybeBinary(target_path)
+    data = self._ExpandVariables(data, substitutions)
+    if overrides:
+      for key in overrides:
+        if key not in data:
+          data[key] = overrides[key]
+    plistlib.writePlist(data, target_path)
+    return target_path
+
+  def _ExpandVariables(self, data, substitutions):
+    """Expands variables "$(variable)" in data.
+
+    Args:
+      data: object, can be either string, list or dictionary
+      substitutions: dictionary, variable substitutions to perform
+
+    Returns:
+      Copy of data where each references to "$(variable)" has been replaced
+      by the corresponding value found in substitutions, or left intact if
+      the key was not found.
+    """
+    if isinstance(data, str):
+      for key, value in substitutions.iteritems():
+        data = data.replace('$(%s)' % key, value)
+      return data
+    if isinstance(data, list):
+      return [self._ExpandVariables(v, substitutions) for v in data]
+    if isinstance(data, dict):
+      return {k: self._ExpandVariables(data[k], substitutions) for k in data}
+    return data
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv[1:]))

+if (process.fiberLib) {
+	return module.exports = process.fiberLib;
+}
+var fs = require('fs'), path = require('path');
+
+// Seed random numbers [gh-82]
+Math.random();
+
+// Look for binary for this platform
+var modPath = path.join(__dirname, 'bin', process.platform+ '-'+ process.arch+ '-'+ process.versions.modules, 'fibers');
+try {
+	fs.statSync(modPath+ '.node');
+} catch (ex) {
+	// No binary!
+	console.error(
+		'## There is an issue with `node-fibers` ##\n'+
+		'`'+ modPath+ '.node` is missing.\n\n'+
+		'Try running this to fix the issue: '+ process.execPath+ ' '+ __dirname.replace(' ', '\\ ')+ '/build'
+	);
+	throw new Error('Missing binary. See message above.');
+}
+
+// Pull in fibers implementation
+process.fiberLib = module.exports = require(modPath).Fiber;

+"use strict";
+var Fiber = require('./fibers');
+var util = require('util');
+module.exports = Future;
+Function.prototype.future = function(detach) {
+	var fn = this;
+	var ret = function() {
+		var future = new FiberFuture(fn, this, arguments);
+		if (detach) {
+			future.detach();
+		}
+		return future;
+	};
+	ret.toString = function() {
+		return '<<Future '+ fn+ '.future()>>';
+	};
+	return ret;
+};
+
+function Future() {}
+
+/**
+ * Run a function(s) in a future context, and return a future to their return value. This is useful
+ * for instances where you want a closure to be able to `.wait()`. This also lets you wait for
+ * mulitple parallel opertions to run.
+ */
+Future.task = function(fn) {
+	if (arguments.length === 1) {
+		return fn.future()();
+	} else {
+		var future = new Future, pending = arguments.length, error, values = new Array(arguments.length);
+		for (var ii = 0; ii < arguments.length; ++ii) {
+			arguments[ii].future()().resolve(function(ii, err, val) {
+				if (err) {
+					error = err;
+				}
+				values[ii] = val;
+				if (--pending === 0) {
+					if (error) {
+						future.throw(error);
+					} else {
+						future.return(values);
+					}
+				}
+			}.bind(null, ii));
+		}
+		return future;
+	}
+};
+
+/**
+ * Wrap node-style async functions to instead return futures. This assumes that the last parameter
+ * of the function is a callback.
+ *
+ * If a single function is passed a future-returning function is created. If an object is passed a
+ * new object is returned with all functions wrapped.
+ *
+ * The value that is returned from the invocation of the underlying function is assigned to the
+ * property `_` on the future. This is useful for functions like `execFile` which take a callback,
+ * but also return meaningful information.
+ *
+ * `multi` indicates that this callback will return more than 1 argument after `err`. For example,
+ * `child_process.exec()`
+ *
+ * `suffix` will append a string to every method that was overridden, if you pass an object to
+ * `Future.wrap()`. Default is 'Future'.
+ *
+ * var readFileFuture = Future.wrap(require('fs').readFile);
+ * var fs = Future.wrap(require('fs'));
+ * fs.readFileFuture('example.txt').wait();
+ */
+Future.wrap = function(fnOrObject, multi, suffix, stop) {
+	if (typeof fnOrObject === 'object') {
+		var wrapped = Object.create(fnOrObject);
+		for (var ii in fnOrObject) {
+			if (wrapped[ii] instanceof Function) {
+				wrapped[suffix === undefined ? ii+ 'Future' : ii+ suffix] = Future.wrap(wrapped[ii], multi, suffix, stop);
+			}
+		}
+		return wrapped;
+	} else if (typeof fnOrObject === 'function') {
+		var fn = function() {
+			var future = new Future;
+			var args = Array.prototype.slice.call(arguments);
+			if (multi) {
+				var cb = future.resolver();
+				args.push(function(err) {
+					cb(err, Array.prototype.slice.call(arguments, 1));
+				});
+			} else {
+				args.push(future.resolver());
+			}
+			future._ = fnOrObject.apply(this, args);
+			return future;
+		}
+		// Modules like `request` return a function that has more functions as properties. Handle this
+		// in some kind of reasonable way.
+		if (!stop) {
+			var proto = Object.create(fnOrObject);
+			for (var ii in fnOrObject) {
+				if (fnOrObject.hasOwnProperty(ii) && fnOrObject[ii] instanceof Function) {
+					proto[ii] = proto[ii];
+				}
+			}
+			fn.__proto__ = Future.wrap(proto, multi, suffix, true);
+		}
+		return fn;
+	}
+};
+
+/**
+ * Wait on a series of futures and then return. If the futures throw an exception this function
+ * /won't/ throw it back. You can get the value of the future by calling get() on it directly. If
+ * you want to wait on a single future you're better off calling future.wait() on the instance.
+ */
+Future.wait = function wait(/* ... */) {
+
+	// Normalize arguments + pull out a FiberFuture for reuse if possible
+	var futures = [], singleFiberFuture;
+	for (var ii = 0; ii < arguments.length; ++ii) {
+		var arg = arguments[ii];
+		if (arg instanceof Future) {
+			// Ignore already resolved fibers
+			if (arg.isResolved()) {
+				continue;
+			}
+			// Look for fiber reuse
+			if (!singleFiberFuture && arg instanceof FiberFuture && !arg.started) {
+				singleFiberFuture = arg;
+				continue;
+			}
+			futures.push(arg);
+		} else if (arg instanceof Array) {
+			for (var jj = 0; jj < arg.length; ++jj) {
+				var aarg = arg[jj];
+				if (aarg instanceof Future) {
+					// Ignore already resolved fibers
+					if (aarg.isResolved()) {
+						continue;
+					}
+					// Look for fiber reuse
+					if (!singleFiberFuture && aarg instanceof FiberFuture && !aarg.started) {
+						singleFiberFuture = aarg;
+						continue;
+					}
+					futures.push(aarg);
+				} else {
+					throw new Error(aarg+ ' is not a future');
+				}
+			}
+		} else {
+			throw new Error(arg+ ' is not a future');
+		}
+	}
+
+	// Resumes current fiber
+	var fiber = Fiber.current;
+	if (!fiber) {
+		throw new Error('Can\'t wait without a fiber');
+	}
+
+	// Resolve all futures
+	var pending = futures.length + (singleFiberFuture ? 1 : 0);
+	function cb() {
+		if (!--pending) {
+			fiber.run();
+		}
+	}
+	for (var ii = 0; ii < futures.length; ++ii) {
+		futures[ii].resolve(cb);
+	}
+
+	// Reusing a fiber?
+	if (singleFiberFuture) {
+		singleFiberFuture.started = true;
+		try {
+			singleFiberFuture.return(
+				singleFiberFuture.fn.apply(singleFiberFuture.context, singleFiberFuture.args));
+		} catch(e) {
+			singleFiberFuture.throw(e);
+		}
+		--pending;
+	}
+
+	// Yield this fiber
+	if (pending) {
+		Fiber.yield();
+	}
+};
+
+/**
+ * Return a Future that waits on an ES6 Promise.
+ */
+Future.fromPromise = function(promise) {
+	var future = new Future;
+	promise.then(function(val) {
+		future.return(val);
+	}, function(err) {
+		future.throw(err);
+	});
+	return future;
+};
+
+Future.prototype = {
+	/**
+	 * Return the value of this future. If the future hasn't resolved yet this will throw an error.
+	 */
+	get: function() {
+		if (!this.resolved) {
+			throw new Error('Future must resolve before value is ready');
+		} else if (this.error) {
+			// Link the stack traces up
+			var error = this.error;
+			var localStack = {};
+			Error.captureStackTrace(localStack, Future.prototype.get);
+			var futureStack = Object.getOwnPropertyDescriptor(error, 'futureStack');
+			if (!futureStack) {
+				futureStack = Object.getOwnPropertyDescriptor(error, 'stack');
+				if (futureStack) {
+					Object.defineProperty(error, 'futureStack', futureStack);
+				}
+			}
+			if (futureStack && futureStack.get) {
+				Object.defineProperty(error, 'stack', {
+					get: function() {
+						var stack = futureStack.get.apply(error);
+						if (stack) {
+							stack = stack.split('\n');
+							return [stack[0]]
+								.concat(localStack.stack.split('\n').slice(1))
+								.concat('    - - - - -')
+								.concat(stack.slice(1))
+								.join('\n');
+						} else {
+							return localStack.stack;
+						}
+					},
+					set: function(stack) {
+						Object.defineProperty(error, 'stack', {
+							value: stack,
+							configurable: true,
+							enumerable: false,
+							writable: true,
+						});
+					},
+					configurable: true,
+					enumerable: false,
+				});
+			}
+			throw error;
+		} else {
+			return this.value;
+		}
+	},
+
+	/**
+	 * Mark this future as returned. All pending callbacks will be invoked immediately.
+	 */
+	"return": function(value) {
+		if (this.resolved) {
+			throw new Error('Future resolved more than once');
+		}
+		this.value = value;
+		this.resolved = true;
+
+		var callbacks = this.callbacks;
+		if (callbacks) {
+			delete this.callbacks;
+			for (var ii = 0; ii < callbacks.length; ++ii) {
+				try {
+					var ref = callbacks[ii];
+					if (ref[1]) {
+						ref[1](value);
+					} else {
+						ref[0](undefined, value);
+					}
+				} catch(ex) {
+					// console.log('Resolve cb threw', String(ex.stack || ex.message || ex));
+					process.nextTick(function() {
+						throw(ex);
+					});
+				}
+			}
+		}
+	},
+
+	/**
+	 * Throw from this future as returned. All pending callbacks will be invoked immediately.
+	 */
+	"throw": function(error) {
+		if (this.resolved) {
+			throw new Error('Future resolved more than once');
+		} else if (!error) {
+			throw new Error('Must throw non-empty error');
+		}
+		this.error = error;
+		this.resolved = true;
+
+		var callbacks = this.callbacks;
+		if (callbacks) {
+			delete this.callbacks;
+			for (var ii = 0; ii < callbacks.length; ++ii) {
+				try {
+					var ref = callbacks[ii];
+					if (ref[1]) {
+						ref[0].throw(error);
+					} else {
+						ref[0](error);
+					}
+				} catch(ex) {
+					// console.log('Resolve cb threw', String(ex.stack || ex.message || ex));
+					process.nextTick(function() {
+						throw(ex);
+					});
+				}
+			}
+		}
+	},
+
+	/**
+	 * "detach" this future. Basically this is useful if you want to run a task in a future, you
+	 * aren't interested in its return value, but if it throws you don't want the exception to be
+	 * lost. If this fiber throws, an exception will be thrown to the event loop and node will
+	 * probably fall down.
+	 */
+	detach: function() {
+		this.resolve(function(err) {
+			if (err) {
+				throw err;
+			}
+		});
+	},
+
+	/**
+	 * Returns whether or not this future has resolved yet.
+	 */
+	isResolved: function() {
+		return this.resolved === true;
+	},
+
+	/**
+	 * Returns a node-style function which will mark this future as resolved when called.
+	 */
+	resolver: function() {
+		return function(err, val) {
+			if (err) {
+				this.throw(err);
+			} else {
+				this.return(val);
+			}
+		}.bind(this);
+	},
+
+	/**
+	 * Waits for this future to resolve and then invokes a callback.
+	 *
+	 * If two arguments are passed, the first argument is a future which will be thrown to in the case
+	 * of error, and the second is a function(val){} callback.
+	 *
+	 * If only one argument is passed it is a standard function(err, val){} callback.
+	 */
+	resolve: function(arg1, arg2) {
+		if (this.resolved) {
+			if (arg2) {
+				if (this.error) {
+					arg1.throw(this.error);
+				} else {
+					arg2(this.value);
+				}
+			} else {
+				arg1(this.error, this.value);
+			}
+		} else {
+			(this.callbacks = this.callbacks || []).push([arg1, arg2]);
+		}
+		return this;
+	},
+
+	/**
+	 * Resolve only in the case of success
+	 */
+	resolveSuccess: function(cb) {
+		this.resolve(function(err, val) {
+			if (err) {
+				return;
+			}
+			cb(val);
+		});
+		return this;
+	},
+
+	/**
+	 * Propogate results to another future.
+	 */
+	proxy: function(future) {
+		this.resolve(function(err, val) {
+			if (err) {
+				future.throw(err);
+			} else {
+				future.return(val);
+			}
+		});
+	},
+
+	/**
+	 * Propogate only errors to an another future or array of futures.
+	 */
+	proxyErrors: function(futures) {
+		this.resolve(function(err) {
+			if (!err) {
+				return;
+			}
+			if (futures instanceof Array) {
+				for (var ii = 0; ii < futures.length; ++ii) {
+					futures[ii].throw(err);
+				}
+			} else {
+				futures.throw(err);
+			}
+		});
+		return this;
+	},
+
+	/**
+	 * Returns an ES6 Promise
+	 */
+	promise: function() {
+		var that = this;
+		return new Promise(function(resolve, reject) {
+			that.resolve(function(err, val) {
+				if (err) {
+					reject(err);
+				} else {
+					resolve(val);
+				}
+			});
+		});
+	},
+
+	/**
+	 * Differs from its functional counterpart in that it actually resolves the future. Thus if the
+	 * future threw, future.wait() will throw.
+	 */
+	wait: function() {
+		if (this.isResolved()) {
+			return this.get();
+		}
+		Future.wait(this);
+		return this.get();
+	},
+};
+
+/**
+ * A function call which loads inside a fiber automatically and returns a future.
+ */
+function FiberFuture(fn, context, args) {
+	this.fn = fn;
+	this.context = context;
+	this.args = args;
+	this.started = false;
+	var that = this;
+	process.nextTick(function() {
+		if (!that.started) {
+			that.started = true;
+			Fiber(function() {
+				try {
+					that.return(fn.apply(context, args));
+				} catch(e) {
+					that.throw(e);
+				}
+			}).run();
+		}
+	});
+}
+util.inherits(FiberFuture, Future);

+{
+  "name": "fibers",
+  "version": "1.0.15",
+  "description": "Cooperative multi-tasking for Javascript",
+  "keywords": [
+    "fiber",
+    "fibers",
+    "coroutine",
+    "thread",
+    "async",
+    "parallel",
+    "worker",
+    "future",
+    "promise"
+  ],
+  "homepage": "https://github.com/laverdet/node-fibers",
+  "author": "Marcel Laverdet <marcel@laverdet.com> (https://github.com/laverdet/)",
+  "main": "fibers",
+  "scripts": {
+    "install": "node build.js || nodejs build.js",
+    "test": "node test.js || nodejs test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/laverdet/node-fibers.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=0.5.2"
+  },
+  "_from": "fibers@1.0.15",
+  "_resolved": "http://registry.npm.taobao.org/fibers/download/fibers-1.0.15.tgz"
+}

+"use strict"
+var Fiber = require('./fibers');
+var fiber = Fiber(function() {
+	process.stdout.write(Fiber.yield());
+});
+fiber.run();
+fiber.run('pass');

+#include "coroutine.h"
+#include "v8-version.h"
+#include <assert.h>
+#ifndef WINDOWS
+#include <pthread.h>
+#else
+#include <windows.h>
+#include <intrin.h>
+// Stub pthreads into Windows approximations
+#define pthread_t HANDLE
+#define pthread_create(thread, attr, fn, arg) !((*thread)=CreateThread(NULL, 0, &(fn), arg, 0, NULL))
+#define pthread_join(thread, arg) WaitForSingleObject((thread), INFINITE)
+#define pthread_key_t DWORD
+#define pthread_key_create(key, dtor) (*key)=TlsAlloc()
+#define pthread_setspecific(key, val) TlsSetValue((key), (val))
+#define pthread_getspecific(key) TlsGetValue((key))
+#endif
+
+#include <stdexcept>
+#include <stack>
+#include <vector>
+using namespace std;
+
+const size_t v8_tls_keys = 3;
+static std::vector<void*> fls_data_pool;
+static pthread_key_t coro_thread_key = 0;
+static pthread_key_t isolate_key = 0x7777;
+static pthread_key_t thread_id_key = 0x7777;
+static pthread_key_t thread_data_key = 0x7777;
+
+static size_t stack_size = 0;
+static size_t coroutines_created_ = 0;
+static vector<Coroutine*> fiber_pool;
+static Coroutine* delete_me = NULL;
+size_t Coroutine::pool_size = 120;
+
+static bool can_poke(void* addr) {
+#ifdef WINDOWS
+	MEMORY_BASIC_INFORMATION mbi;
+	if (!VirtualQueryEx(GetCurrentProcess(), addr, &mbi, sizeof(mbi))) {
+		return false;
+	}
+	if (!(mbi.State & MEM_COMMIT)) {
+		return false;
+	}
+	return true;
+#else
+	// TODO: Check pointer on other OS's? Windows is the only case I've seen so far that has
+	// spooky gaps in the TLS key space
+	return true;
+#endif
+}
+
+#ifdef USE_V8_SYMBOLS
+// Some distributions of node, most notably Ubuntu, strip the v8 internal symbols and so we don't
+// have access to this stuff. In most cases we will use the more complicated `find_thread_id_key`
+// below, since it tends to work on more platforms.
+namespace v8 {
+	namespace base {
+		class Thread {
+			public: typedef int32_t LocalStorageKey;
+		};
+	}
+
+	namespace internal {
+		class Isolate {
+			public:
+				static base::Thread::LocalStorageKey isolate_key_;
+				static base::Thread::LocalStorageKey per_isolate_thread_data_key_;
+				static base::Thread::LocalStorageKey thread_id_key_;
+		};
+	}
+}
+#endif
+
+#ifndef WINDOWS
+static void* find_thread_id_key(void* arg)
+#else
+static DWORD __stdcall find_thread_id_key(LPVOID arg)
+#endif
+{
+	v8::Isolate* isolate = static_cast<v8::Isolate*>(arg);
+	assert(isolate != NULL);
+	v8::Locker locker(isolate);
+	isolate->Enter();
+
+	// First pass-- find isolate thread key
+	for (pthread_key_t ii = coro_thread_key; ii > 0; --ii) {
+		void* tls = pthread_getspecific(ii - 1);
+		if (tls == isolate) {
+			isolate_key = ii - 1;
+			break;
+		}
+	}
+	assert(isolate_key != 0x7777);
+
+	// Second pass-- find data key
+	int thread_id = 0;
+	for (pthread_key_t ii = isolate_key + 2; ii < coro_thread_key; ++ii) {
+		void* tls = pthread_getspecific(ii);
+		if (can_poke(tls) && *(void**)tls == isolate) {
+			// First member of per-thread data is the isolate
+			thread_data_key = ii;
+			// Second member is the thread id
+			thread_id = *(int*)((void**)tls + 1);
+			break;
+		}
+	}
+	assert(thread_data_key != 0x7777);
+
+	// Third pass-- find thread id key
+	for (pthread_key_t ii = isolate_key + 1; ii < thread_data_key; ++ii) {
+		int tls = static_cast<int>(reinterpret_cast<intptr_t>(pthread_getspecific(ii)));
+		if (tls == thread_id) {
+			thread_id_key = ii;
+			break;
+		}
+	}
+	assert(thread_id_key != 0x7777);
+
+	isolate->Exit();
+	return NULL;
+}
+
+/**
+ * Coroutine class definition
+ */
+void Coroutine::init(v8::Isolate* isolate) {
+	v8::Unlocker unlocker(isolate);
+	pthread_key_create(&coro_thread_key, NULL);
+	pthread_setspecific(coro_thread_key, &current());
+#ifdef USE_V8_SYMBOLS
+	isolate_key = v8::internal::Isolate::isolate_key_;
+	thread_data_key = v8::internal::Isolate::per_isolate_thread_data_key_;
+	thread_id_key = v8::internal::Isolate::thread_id_key_;
+#else
+	pthread_t thread;
+	pthread_create(&thread, NULL, find_thread_id_key, isolate);
+	pthread_join(thread, NULL);
+#endif
+}
+
+Coroutine& Coroutine::current() {
+	Coroutine* current = static_cast<Coroutine*>(pthread_getspecific(coro_thread_key));
+	if (!current) {
+		current = new Coroutine;
+		pthread_setspecific(coro_thread_key, current);
+	}
+	return *current;
+}
+
+void Coroutine::set_stack_size(unsigned int size) {
+	assert(!stack_size);
+	stack_size = size;
+}
+
+size_t Coroutine::coroutines_created() {
+	return coroutines_created_;
+}
+
+void Coroutine::trampoline(void* that) {
+#ifdef CORO_PTHREAD
+	pthread_setspecific(coro_thread_key, that);
+#endif
+#ifdef CORO_FIBER
+	// I can't figure out how to get the precise base of the stack in Windows. Since CreateFiber
+	// creates the stack automatically we don't have access to the base. We can however grab the
+	// current esp position, and use that as an approximation. Padding is added for safety since the
+	// base is slightly different.
+	static_cast<Coroutine*>(that)->stack_base = (size_t*)_AddressOfReturnAddress() - stack_size + 16;
+#endif
+	if (!fls_data_pool.empty()) {
+		pthread_setspecific(thread_data_key, fls_data_pool.back());
+		pthread_setspecific(thread_id_key, fls_data_pool.at(fls_data_pool.size() - 2));
+		pthread_setspecific(isolate_key, fls_data_pool.at(fls_data_pool.size() - 3));
+		fls_data_pool.resize(fls_data_pool.size() - 3);
+	}
+	while (true) {
+		static_cast<Coroutine*>(that)->entry(const_cast<void*>(static_cast<Coroutine*>(that)->arg));
+	}
+}
+
+Coroutine::Coroutine() :
+	fls_data(v8_tls_keys),
+	entry(NULL),
+	arg(NULL) {
+	stack.sptr = NULL;
+	coro_create(&context, NULL, NULL, NULL, 0);
+}
+
+Coroutine::Coroutine(entry_t& entry, void* arg) :
+	fls_data(v8_tls_keys),
+	entry(entry),
+	arg(arg) {
+}
+
+Coroutine::~Coroutine() {
+	if (stack.sptr) {
+		coro_stack_free(&stack);
+	}
+#ifdef CORO_FIBER
+	if (context.fiber)
+#endif
+	(void)coro_destroy(&context);
+}
+
+Coroutine* Coroutine::create_fiber(entry_t* entry, void* arg) {
+	if (!fiber_pool.empty()) {
+		Coroutine* fiber = fiber_pool.back();
+		fiber_pool.pop_back();
+		fiber->reset(entry, arg);
+		return fiber;
+	}
+	Coroutine* coro = new Coroutine(*entry, arg);
+	if (!coro_stack_alloc(&coro->stack, stack_size)) {
+		delete coro;
+		return NULL;
+	}
+	coro_create(&coro->context, trampoline, coro, coro->stack.sptr, coro->stack.ssze);
+#ifdef CORO_FIBER
+	// Stupid hack. libcoro's project structure combined with Windows's CreateFiber functions makes
+	// it difficult to catch this error. Sometimes Windows will return `ERROR_NOT_ENOUGH_MEMORY` or
+	// `ERROR_COMMITMENT_LIMIT` if it can't make any more fibers. However, `coro_stack_alloc` returns
+	// success unconditionally on Windows so we have to detect the error here, after the call to
+	// `coro_create`.
+	if (!coro->context.fiber) {
+		delete coro;
+		return NULL;
+	}
+#endif
+	++coroutines_created_;
+	return coro;
+}
+
+void Coroutine::reset(entry_t* entry, void* arg) {
+	assert(entry != NULL);
+	this->entry = entry;
+	this->arg = arg;
+}
+
+void Coroutine::transfer(Coroutine& next) {
+	assert(this != &next);
+#ifndef CORO_PTHREAD
+	fls_data[0] = pthread_getspecific(isolate_key);
+	fls_data[1] = pthread_getspecific(thread_id_key);
+	fls_data[2] = pthread_getspecific(thread_data_key);
+
+	pthread_setspecific(isolate_key, next.fls_data[0]);
+	pthread_setspecific(thread_id_key, next.fls_data[1]);
+	pthread_setspecific(thread_data_key, next.fls_data[2]);
+
+	pthread_setspecific(coro_thread_key, &next);
+#endif
+	coro_transfer(&context, &next.context);
+#ifndef CORO_PTHREAD
+	pthread_setspecific(coro_thread_key, this);
+#endif
+}
+
+void Coroutine::run() {
+	Coroutine& current = Coroutine::current();
+	assert(!delete_me);
+	assert(&current != this);
+	current.transfer(*this);
+
+	if (delete_me) {
+		// This means finish() was called on the coroutine and the pool was full so this coroutine needs
+		// to be deleted. We can't delete from inside finish(), because that would deallocate the
+		// current stack. However we CAN delete here, we just have to be very careful.
+		assert(delete_me == this);
+		assert(&current != this);
+		delete_me = NULL;
+		delete this;
+	}
+}
+
+void Coroutine::finish(Coroutine& next, v8::Isolate* isolate) {
+	{
+		assert(&next != this);
+		assert(&current() == this);
+		if (fiber_pool.size() < pool_size) {
+			fiber_pool.push_back(this);
+		} else {
+#if V8_MAJOR_VERSION > 4 || (V8_MAJOR_VERSION == 4 && V8_MINOR_VERSION >= 10)
+			// Clean up isolate data
+			isolate->DiscardThreadSpecificMetadata();
+#else
+			// If not supported, then we can mitigate v8's leakage by saving these thread locals.
+			fls_data_pool.reserve(fls_data_pool.size() + 3);
+			fls_data_pool.push_back(pthread_getspecific(isolate_key));
+			fls_data_pool.push_back(pthread_getspecific(thread_id_key));
+			fls_data_pool.push_back(pthread_getspecific(thread_data_key));
+#endif
+			// Can't delete right now because we're currently on this stack!
+			assert(delete_me == NULL);
+			delete_me = this;
+		}
+	}
+	this->transfer(next);
+}
+
+void* Coroutine::bottom() const {
+#ifdef CORO_FIBER
+	return stack_base;
+#else
+	return stack.sptr;
+#endif
+}
+
+size_t Coroutine::size() const {
+	return sizeof(Coroutine) + stack_size * sizeof(void*);
+}

+#include <node.h>
+#include <stdlib.h>
+#include <vector>
+#include "libcoro/coro.h"
+
+class Coroutine {
+	public:
+		typedef void(entry_t)(void*);
+
+	private:
+#ifdef CORO_FIBER
+		void* stack_base;
+#endif
+		coro_context context;
+		coro_stack stack;
+		std::vector<void*> fls_data;
+		entry_t* entry;
+		void* arg;
+
+		~Coroutine();
+
+		/**
+		 * Constructor for currently running "fiber". This is really just original thread, but we
+		 * need a way to get back into the main thread after yielding to a fiber. Basically this
+		 * shouldn't be called from anywhere.
+		 */
+		Coroutine();
+
+		/**
+		 * This constructor will actually create a new fiber context. Execution does not begin
+		 * until you call run() for the first time.
+		 */
+		Coroutine(entry_t& entry, void* arg);
+
+		/**
+		 * Resets the context of this coroutine from the start. Used to recyle old coroutines.
+		 */
+		void reset(entry_t* entry, void* arg);
+
+		static void trampoline(void* that);
+		void transfer(Coroutine& next);
+
+	public:
+		static size_t pool_size;
+
+		/**
+		 * Returns the currently-running fiber.
+		 */
+		static Coroutine& current();
+
+		/**
+		 * Create a new fiber.
+		 */
+		static Coroutine* create_fiber(entry_t* entry, void* arg = NULL);
+
+		/**
+		 * Initialize the library.
+		 */
+		static void init(v8::Isolate* isolate);
+
+		/**
+		 * Set the size of coroutines created by this library. Since coroutines are pooled the stack
+		 * size is global instead of per-coroutine. Stack is measured in sizeof(void*), so
+		 * set_stack_size(128) -> 512 bytes or 1kb
+		 */
+		static void set_stack_size(unsigned int size);
+
+		/**
+		 * Get the number of coroutines that have been created.
+		 */
+		static size_t coroutines_created();
+
+		/**
+		 * Start or resume execution in this fiber. Note there is no explicit yield() function,
+		 * you must manually run another fiber.
+		 */
+		void run();
+
+		/**
+		 * Finish this coroutine.. This will halt execution of this coroutine and resume execution
+		 * of `next`. If you do not call this function, and instead just return from `entry` the
+		 * application will exit. This function may or may not actually return.
+		 */
+		void finish(Coroutine& next, v8::Isolate* isolate);
+
+		/**
+		 * Returns address of the lowest usable byte in this Coroutine's stack.
+		 */
+		void* bottom() const;
+
+		/**
+		 * Returns the size this Coroutine takes up in the heap.
+		 */
+		size_t size() const;
+};

+#include "coroutine.h"
+#include "v8-version.h"
+#include <assert.h>
+#include <node.h>
+#include <node_version.h>
+
+#include <vector>
+#include <iostream>
+
+#define THROW(x, m) return uni::Return(uni::ThrowException(Isolate::GetCurrent(), x(uni::NewLatin1String(Isolate::GetCurrent(), m))), args)
+
+// Run GC more often when debugging
+#ifdef DEBUG
+#define GC_ADJUST 100
+#else
+#define GC_ADJUST 1
+#endif
+
+using namespace std;
+using namespace v8;
+
+// Handle legacy V8 API
+namespace uni {
+#if V8_MAJOR_VERSION > 5 || (V8_MAJOR_VERSION == 5 && V8_MINOR_VERSION >= 2)
+	// Actually 5.2.244
+	template <void (*F)(void*), class P>
+	void WeakCallbackShim(const WeakCallbackInfo<P>& data) {
+		F(data.GetParameter());
+	}
+
+	template <void (*F)(void*), class T, typename P>
+	void MakeWeak(Isolate* isolate, Persistent<T>& handle, P* val) {
+		handle.SetWeak(val, WeakCallbackShim<F, P>, WeakCallbackType::kFinalizer);
+	}
+#elif V8_MAJOR_VERSION > 3 || (V8_MAJOR_VERSION == 3 && V8_MINOR_VERSION >= 26)
+	template <void (*F)(void*), class T, typename P>
+	void WeakCallbackShim(const v8::WeakCallbackData<T, P>& data) {
+		F(data.GetParameter());
+	}
+
+	template <void (*F)(void*), class T, typename P>
+	void MakeWeak(Isolate* isolate, Persistent<T>& handle, P* val) {
+		handle.SetWeak(val, WeakCallbackShim<F>);
+	}
+#else
+	template <void (*F)(void*)>
+	void WeakCallbackShim(Persistent<Value> value, void* data) {
+		F(data);
+	}
+	template <void (*F)(void*), class T, typename P>
+	void MakeWeak(Isolate* isolate, Persistent<T>& handle, P* val) {
+		handle.MakeWeak(val, WeakCallbackShim<F>);
+	}
+#endif
+
+
+#if V8_MAJOR_VERSION > 3 || (V8_MAJOR_VERSION == 3 && V8_MINOR_VERSION >= 26)
+	// Node v0.11.13+
+	typedef PropertyCallbackInfo<Value> GetterCallbackInfo;
+	typedef PropertyCallbackInfo<void> SetterCallbackInfo;
+	typedef void FunctionType;
+	typedef FunctionCallbackInfo<v8::Value> Arguments;
+
+	class HandleScope {
+		v8::HandleScope scope;
+		public: HandleScope(Isolate* isolate) : scope(isolate) {}
+	};
+
+	template <class T>
+	void Reset(Isolate* isolate, Persistent<T>& persistent, Handle<T> handle) {
+		persistent.Reset(isolate, handle);
+	}
+	template <class T>
+	void Dispose(Isolate* isolate, Persistent<T>& handle) {
+		handle.Reset();
+	}
+	template <class T>
+	void ClearWeak(Isolate* isolate, Persistent<T>& handle) {
+		handle.ClearWeak(isolate);
+	}
+
+	template <class T>
+	void SetInternalPointer(Handle<T> handle, int index, void* val) {
+		handle->SetAlignedPointerInInternalField(index, val);
+	}
+	template <class T>
+	void* GetInternalPointer(Handle<T> handle, int index) {
+		return handle->GetAlignedPointerFromInternalField(index);
+	}
+
+	template <class T>
+	Handle<T> Deref(Isolate* isolate, Persistent<T>& handle) {
+		return Local<T>::New(isolate, handle);
+	}
+
+	template <class T>
+	void Return(Handle<T> handle, const Arguments& args) {
+		args.GetReturnValue().Set(handle);
+	}
+	template <class T>
+	void Return(Handle<T> handle, GetterCallbackInfo info) {
+		info.GetReturnValue().Set(handle);
+	}
+	template <class T>
+	void Return(Persistent<T>& handle, GetterCallbackInfo info) {
+		info.GetReturnValue().Set(handle);
+	}
+
+	Handle<Value> ThrowException(Isolate* isolate, Handle<Value> exception) {
+		return isolate->ThrowException(exception);
+	}
+
+	Handle<Context> GetCurrentContext(Isolate* isolate) {
+		return isolate->GetCurrentContext();
+	}
+
+	Handle<Primitive> Undefined(Isolate* isolate) {
+		return v8::Undefined(isolate);
+	}
+
+	Handle<String> NewLatin1String(Isolate* isolate, const char* string) {
+		return String::NewFromOneByte(isolate, (const uint8_t*)string);
+	}
+
+	Handle<String> NewLatin1Symbol(Isolate* isolate, const char* string) {
+		return String::NewFromOneByte(isolate, (const uint8_t*)string);
+	}
+
+	Handle<Boolean> NewBoolean(Isolate* isolate, bool value) {
+		return Boolean::New(isolate, value);
+	}
+
+	Handle<Number> NewNumber(Isolate* isolate, double value) {
+		return Number::New(isolate, value);
+	}
+
+	Handle<FunctionTemplate> NewFunctionTemplate(
+		Isolate* isolate,
+		FunctionCallback callback,
+		Handle<Value> data = Handle<Value>(),
+		Handle<Signature> signature = Handle<Signature>(),
+		int length = 0
+	) {
+		return FunctionTemplate::New(isolate, callback, data, signature, length);
+	}
+
+	Handle<Signature> NewSignature(
+		Isolate* isolate,
+		Handle<FunctionTemplate> receiver = Handle<FunctionTemplate>()
+	) {
+		return Signature::New(isolate, receiver);
+	}
+
+	class ReverseIsolateScope {
+		Isolate* isolate;
+		public:
+			explicit inline ReverseIsolateScope(Isolate* isolate) : isolate(isolate) {
+				isolate->Exit();
+			}
+			inline ~ReverseIsolateScope() {
+				isolate->Enter();
+			}
+	};
+
+	void AdjustAmountOfExternalAllocatedMemory(Isolate* isolate, int64_t change_in_bytes) {
+		isolate->AdjustAmountOfExternalAllocatedMemory(change_in_bytes);
+	}
+#else
+	// Node v0.10.x and lower
+	typedef AccessorInfo GetterCallbackInfo;
+	typedef AccessorInfo SetterCallbackInfo;
+	typedef Handle<Value> FunctionType;
+	typedef Arguments Arguments;
+
+	class HandleScope {
+		v8::HandleScope scope;
+		public: HandleScope(Isolate* isolate) {}
+	};
+
+	template <class T>
+	void Reset(Isolate* isolate, Persistent<T>& persistent, Handle<T> handle) {
+		persistent = Persistent<T>::New(handle);
+	}
+	template <class T>
+	void Dispose(Isolate* isolate, Persistent<T>& handle) {
+		handle.Dispose();
+	}
+
+	template <class T>
+	void ClearWeak(Isolate* isolate, Persistent<T>& handle) {
+		handle.ClearWeak();
+	}
+
+	template <class T>
+	void SetInternalPointer(Handle<T> handle, int index, void* val) {
+		handle->SetPointerInInternalField(index, val);
+	}
+	template <class T>
+	void* GetInternalPointer(Handle<T> handle, int index) {
+		return handle->GetPointerFromInternalField(index);
+	}
+
+	template <class T>
+	Handle<T> Deref(Isolate* isolate, Persistent<T>& handle) {
+		return Local<T>::New(handle);
+	}
+
+	Handle<Value> Return(Handle<Value> handle, GetterCallbackInfo info) {
+		return handle;
+	}
+
+	Handle<Value> Return(Handle<Value> handle, const Arguments& args) {
+		return handle;
+	}
+
+	Handle<Value> ThrowException(Isolate* isolate, Handle<Value> exception) {
+		return ThrowException(exception);
+	}
+
+	Handle<Context> GetCurrentContext(Isolate* isolate) {
+		return Context::GetCurrent();
+	}
+
+	Handle<Primitive> Undefined(Isolate* isolate) {
+		return v8::Undefined();
+	}
+
+	Handle<String> NewLatin1String(Isolate* isolate, const char* string) {
+		return String::New(string);
+	}
+
+	Handle<String> NewLatin1Symbol(Isolate* isolate, const char* string) {
+		return String::NewSymbol(string);
+	}
+
+	Handle<Boolean> NewBoolean(Isolate* isolate, bool value) {
+		return Boolean::New(value);
+	}
+
+	Handle<Number> NewNumber(Isolate* isolate, double value) {
+		return Number::New(value);
+	}
+
+	Handle<FunctionTemplate> NewFunctionTemplate(
+		Isolate* isolate,
+		InvocationCallback callback,
+		Handle<Value> data = Handle<Value>(),
+		Handle<Signature> signature = Handle<Signature>(),
+		int length = 0
+	) {
+		return FunctionTemplate::New(callback, data, signature);
+	}
+
+	Handle<Signature> NewSignature(
+		Isolate* isolate,
+		Handle<FunctionTemplate> receiver = Handle<FunctionTemplate>(),
+		int argc = 0,
+		Handle<FunctionTemplate> argv[] = 0
+	) {
+		return Signature::New(receiver, argc, argv);
+	}
+
+	class ReverseIsolateScope {
+		public: explicit inline ReverseIsolateScope(Isolate* isolate) {}
+	};
+
+	void AdjustAmountOfExternalAllocatedMemory(Isolate* isolate, int64_t change_in_bytes) {
+		V8::AdjustAmountOfExternalAllocatedMemory(change_in_bytes);
+	}
+#endif
+
+#if V8_MAJOR_VERSION > 3 || (V8_MAJOR_VERSION == 3 && V8_MINOR_VERSION >= 29)
+	// This was actually added in 3.29.67
+	void SetStackGuard(Isolate* isolate, void* guard) {
+		isolate->SetStackLimit(reinterpret_cast<uintptr_t>(guard));
+	}
+#elif V8_MAJOR_VERSION > 3 || (V8_MAJOR_VERSION == 3 && V8_MINOR_VERSION >= 26)
+	void SetStackGuard(Isolate* isolate, void* guard) {
+		ResourceConstraints constraints;
+		constraints.set_stack_limit(reinterpret_cast<uint32_t*>(guard));
+		v8::SetResourceConstraints(isolate, &constraints);
+	}
+#else
+	// Extra padding for old versions of v8. Shit's fucked.
+	void SetStackGuard(Isolate* isolate, void* guard) {
+		ResourceConstraints constraints;
+		constraints.set_stack_limit(
+			reinterpret_cast<uint32_t*>(guard) + 18 * 1024
+		);
+		v8::SetResourceConstraints(&constraints);
+	}
+#endif
+}
+
+class Fiber {
+
+	private:
+		static Locker* global_locker; // Node does not use locks or threads, so we need a global lock
+		static Persistent<FunctionTemplate> tmpl;
+		static Persistent<Function> fiber_object;
+		static Fiber* current;
+		static vector<Fiber*> orphaned_fibers;
+		static Persistent<Value> fatal_stack;
+
+		Isolate* isolate;
+		Persistent<Object> handle;
+		Persistent<Function> cb;
+		Persistent<Context> v8_context;
+		Persistent<Value> zombie_exception;
+		Persistent<Value> yielded;
+		bool yielded_exception;
+		Coroutine* entry_fiber;
+		Coroutine* this_fiber;
+		bool started;
+		bool yielding;
+		bool zombie;
+		bool resetting;
+
+		static Fiber& Unwrap(Handle<Object> handle) {
+			assert(!handle.IsEmpty());
+			assert(handle->InternalFieldCount() == 1);
+			return *static_cast<Fiber*>(uni::GetInternalPointer(handle, 0));
+		}
+
+		Fiber(Handle<Object> handle, Handle<Function> cb, Handle<Context> v8_context) :
+			isolate(Isolate::GetCurrent()),
+			started(false),
+			yielding(false),
+			zombie(false),
+			resetting(false) {
+			uni::Reset(isolate, this->handle, handle);
+			uni::Reset(isolate, this->cb, cb);
+			uni::Reset(isolate, this->v8_context, v8_context);
+
+			MakeWeak();
+			uni::SetInternalPointer(handle, 0, this);
+		}
+
+		virtual ~Fiber() {
+			assert(!this->started);
+			uni::Dispose(isolate, handle);
+			uni::Dispose(isolate, cb);
+			uni::Dispose(isolate, v8_context);
+		}
+
+		/**
+		 * Call MakeWeak if it's ok for v8 to garbage collect this Fiber.
+		 * i.e. After fiber completes, while yielded, or before started
+		 */
+		void MakeWeak() {
+			uni::MakeWeak<WeakCallback>(isolate, handle, (void*)this);
+		}
+
+		/**
+		 * And call ClearWeak if it's not ok for v8 to garbage collect this Fiber.
+		 * i.e. While running.
+		 */
+		void ClearWeak() {
+			handle.ClearWeak();
+		}
+
+		/**
+		 * Called when there are no more references to this object in Javascript. If this happens and
+		 * the fiber is currently suspended we'll unwind the fiber's stack by throwing exceptions in
+		 * order to clear all references.
+		 */
+		static void WeakCallback(void* data) {
+			Fiber& that = *static_cast<Fiber*>(data);
+			assert(that.handle.IsNearDeath());
+			assert(current != &that);
+
+			// We'll unwind running fibers later... doing it from the garbage collector is bad news.
+			if (that.started) {
+				assert(that.yielding);
+				orphaned_fibers.push_back(&that);
+				that.ClearWeak();
+				return;
+			}
+
+			delete &that;
+		}
+
+		/**
+		 * When the v8 garbage collector notifies us about dying fibers instead of unwindng their
+		 * stack as soon as possible we put them aside to unwind later. Unwinding from the garbage
+		 * collector leads to exponential time garbage collections if there are many orphaned Fibers,
+		 * there's also the possibility of running out of stack space. It's generally bad news.
+		 *
+		 * So instead we have this function to clean up all the fibers after the garbage collection
+		 * has finished.
+		 */
+		static void DestroyOrphans() {
+			if (orphaned_fibers.empty()) {
+				return;
+			}
+			vector<Fiber*> orphans(orphaned_fibers);
+			orphaned_fibers.clear();
+
+			for (vector<Fiber*>::iterator ii = orphans.begin(); ii != orphans.end(); ++ii) {
+				Fiber& that = **ii;
+				that.UnwindStack();
+
+				if (that.yielded_exception) {
+					// If you throw an exception from a fiber that's being garbage collected there's no way
+					// to bubble that exception up to the application.
+					String::Utf8Value stack(uni::Deref(that.isolate, fatal_stack));
+					cerr <<
+						"An exception was thrown from a Fiber which was being garbage collected. This error "
+						"can not be gracefully recovered from. The only acceptable behavior is to terminate "
+						"this application. The exception appears below:\n\n"
+						<<*stack <<"\n";
+					exit(1);
+				} else {
+					uni::Dispose(that.isolate, fatal_stack);
+				}
+
+				uni::Dispose(that.isolate, that.yielded);
+				that.MakeWeak();
+			}
+		}
+
+		/**
+		 * Instantiate a new Fiber object. When a fiber is created it only grabs a handle to the
+		 * callback; it doesn't create any new contexts until run() is called.
+		 */
+		static uni::FunctionType New(const uni::Arguments& args) {
+			if (args.Length() != 1) {
+				THROW(Exception::TypeError, "Fiber expects 1 argument");
+			} else if (!args[0]->IsFunction()) {
+				THROW(Exception::TypeError, "Fiber expects a function");
+			} else if (!args.IsConstructCall()) {
+				Handle<Value> argv[1] = { args[0] };
+				return uni::Return(uni::Deref(Isolate::GetCurrent(), tmpl)->GetFunction()->NewInstance(1, argv), args);
+			}
+
+			Handle<Function> fn = Handle<Function>::Cast(args[0]);
+			new Fiber(args.This(), fn, uni::GetCurrentContext(Isolate::GetCurrent()));
+			return uni::Return(args.This(), args);
+		}
+
+		/**
+		 * Begin or resume the current fiber. If the fiber is not currently running a new context will
+		 * be created and the callback will start. Otherwise we switch back into the exist context.
+		 */
+		static uni::FunctionType Run(const uni::Arguments& args) {
+			Fiber& that = Unwrap(args.Holder());
+
+			// There seems to be no better place to put this check..
+			DestroyOrphans();
+
+			if (that.started && !that.yielding) {
+				THROW(Exception::Error, "This Fiber is already running");
+			} else if (args.Length() > 1) {
+				THROW(Exception::TypeError, "run() excepts 1 or no arguments");
+			}
+
+			if (!that.started) {
+				// Create a new context with entry point `Fiber::RunFiber()`.
+				void** data = new void*[2];
+				data[0] = (void*)&args;
+				data[1] = &that;
+				that.this_fiber = Coroutine::create_fiber((void (*)(void*))RunFiber, data);
+				if (!that.this_fiber) {
+					delete[] data;
+					THROW(Exception::RangeError, "Out of memory");
+				}
+				that.started = true;
+				uni::AdjustAmountOfExternalAllocatedMemory(that.isolate, that.this_fiber->size() * GC_ADJUST);
+			} else {
+				// If the fiber is currently running put the first parameter to `run()` on `yielded`, then
+				// the pending call to `yield()` will return that value. `yielded` in this case is just a
+				// misnomer, we're just reusing the same handle.
+				that.yielded_exception = false;
+				if (args.Length()) {
+					uni::Reset(that.isolate, that.yielded, args[0]);
+				} else {
+					uni::Reset<Value>(that.isolate, that.yielded, uni::Undefined(that.isolate));
+				}
+			}
+			that.SwapContext();
+			return uni::Return(that.ReturnYielded(), args);
+		}
+
+		/**
+		 * Throw an exception into a currently yielding fiber.
+		 */
+		static uni::FunctionType ThrowInto(const uni::Arguments& args) {
+			Fiber& that = Unwrap(args.Holder());
+
+			if (!that.yielding) {
+				THROW(Exception::Error, "This Fiber is not yielding");
+			} else if (args.Length() == 0) {
+				uni::Reset<Value>(that.isolate, that.yielded, uni::Undefined(that.isolate));
+			} else if (args.Length() == 1) {
+				uni::Reset(that.isolate, that.yielded, args[0]);
+			} else {
+				THROW(Exception::TypeError, "throwInto() expects 1 or no arguments");
+			}
+			that.yielded_exception = true;
+			that.SwapContext();
+			return uni::Return(that.ReturnYielded(), args);
+		}
+
+		/**
+		 * Unwinds a currently running fiber. If the fiber is not running then this function has no
+		 * effect.
+		 */
+		static uni::FunctionType Reset(const uni::Arguments& args) {
+			Fiber& that = Unwrap(args.Holder());
+
+			if (!that.started) {
+				return uni::Return(uni::Undefined(that.isolate), args);
+			} else if (!that.yielding) {
+				THROW(Exception::Error, "This Fiber is not yielding");
+			} else if (args.Length()) {
+				THROW(Exception::TypeError, "reset() expects no arguments");
+			}
+
+			that.resetting = true;
+			that.UnwindStack();
+			that.resetting = false;
+			that.MakeWeak();
+
+			Handle<Value> val = uni::Deref(that.isolate, that.yielded);
+			uni::Dispose(that.isolate, that.yielded);
+			if (that.yielded_exception) {
+				return uni::Return(uni::ThrowException(that.isolate, val), args);
+			} else {
+				return uni::Return(val, args);
+			}
+		}
+
+		/**
+		 * Turns the fiber into a zombie and unwinds its whole stack.
+		 *
+		 * After calling this function you must either destroy this fiber or call MakeWeak() or it will
+		 * be leaked.
+		 */
+		void UnwindStack() {
+			assert(!zombie);
+			assert(started);
+			assert(yielding);
+			zombie = true;
+
+			// Setup an exception which will be thrown and rethrown from Fiber::Yield()
+			Handle<Value> zombie_exception = Exception::Error(uni::NewLatin1String(isolate, "This Fiber is a zombie"));
+			uni::Reset(isolate, this->zombie_exception, zombie_exception);
+			uni::Reset(isolate, yielded, zombie_exception);
+			yielded_exception = true;
+
+			// Swap context back to Fiber::Yield() which will throw an exception to unwind the stack.
+			// Futher calls to yield from this fiber will rethrow the same exception.
+			SwapContext();
+			assert(!started);
+			zombie = false;
+
+			// Make sure this is the exception we threw
+			if (yielded_exception && yielded == zombie_exception) {
+				yielded_exception = false;
+				uni::Dispose(isolate, yielded);
+				uni::Reset<Value>(isolate, yielded, uni::Undefined(isolate));
+			}
+			uni::Dispose(isolate, this->zombie_exception);
+		}
+
+		/**
+		 * Common logic between Run(), ThrowInto(), and UnwindStack(). This is essentially just a
+		 * wrapper around this->fiber->() which also handles all the bookkeeping needed.
+		 */
+		void SwapContext() {
+
+			entry_fiber = &Coroutine::current();
+			Fiber* last_fiber = current;
+			current = this;
+
+			// This will jump into either `RunFiber()` or `Yield()`, depending on if the fiber was
+			// already running.
+			{
+				Unlocker unlocker(isolate);
+				uni::ReverseIsolateScope isolate_scope(isolate);
+				this_fiber->run();
+			}
+
+			// At this point the fiber either returned or called `yield()`.
+			current = last_fiber;
+		}
+
+		/**
+		 * Grabs and resets this fiber's yielded value.
+		 */
+		Handle<Value> ReturnYielded() {
+			Handle<Value> val = uni::Deref(isolate, yielded);
+			uni::Dispose(isolate, yielded);
+			if (yielded_exception) {
+				return uni::ThrowException(isolate, val);
+			} else {
+				return val;
+			}
+		}
+
+		/**
+		 * This is the entry point for a new fiber, from `run()`.
+		 */
+		static void RunFiber(void** data) {
+			const uni::Arguments* args = (const uni::Arguments*)data[0];
+			Fiber& that = *(Fiber*)data[1];
+			delete[] data;
+
+			// New C scope so that the stack-allocated objects will be destroyed before calling
+			// Coroutine::finish, because that function may not return, in which case the destructors in
+			// this function won't be called.
+			{
+				Locker locker(that.isolate);
+				Isolate::Scope isolate_scope(that.isolate);
+				uni::HandleScope scope(that.isolate);
+
+				// Set the stack guard for this "thread"; allow 6k of padding past the JS limit for
+				// native v8 code to run
+				uni::SetStackGuard(that.isolate, reinterpret_cast<char*>(that.this_fiber->bottom()) + 1024 * 6);
+
+				TryCatch try_catch;
+				that.ClearWeak();
+				Handle<Context> v8_context = uni::Deref(that.isolate, that.v8_context);
+				v8_context->Enter();
+
+				// Workaround for v8 issue #1180
+				// http://code.google.com/p/v8/issues/detail?id=1180
+				Script::Compile(uni::NewLatin1String(that.isolate, "void 0;"));
+
+				Handle<Value> yielded;
+				if (args->Length()) {
+					Handle<Value> argv[1] = { (*args)[0] };
+					yielded = uni::Deref(that.isolate, that.cb)->Call(v8_context->Global(), 1, argv);
+				} else {
+					yielded = uni::Deref(that.isolate, that.cb)->Call(v8_context->Global(), 0, NULL);
+				}
+
+				if (try_catch.HasCaught()) {
+					uni::Reset(that.isolate, that.yielded, try_catch.Exception());
+					that.yielded_exception = true;
+					if (that.zombie && !that.resetting && !uni::Deref(that.isolate, that.yielded)->StrictEquals(uni::Deref(that.isolate, that.zombie_exception))) {
+						// Throwing an exception from a garbage sweep
+						uni::Reset(that.isolate, fatal_stack, try_catch.StackTrace());
+					}
+				} else {
+					uni::Reset(that.isolate, that.yielded, yielded);
+					that.yielded_exception = false;
+				}
+
+				// Do not invoke the garbage collector if there's no context on the stack. It will seg fault
+				// otherwise.
+				uni::AdjustAmountOfExternalAllocatedMemory(that.isolate, -(int)(that.this_fiber->size() * GC_ADJUST));
+
+				// Don't make weak until after notifying the garbage collector. Otherwise it may try and
+				// free this very fiber!
+				if (!that.zombie) {
+					that.MakeWeak();
+				}
+
+				// Now safe to leave the context, this stack is done with JS.
+				v8_context->Exit();
+			}
+
+			// The function returned (instead of yielding).
+			that.started = false;
+			that.this_fiber->finish(*that.entry_fiber, that.isolate);
+		}
+
+		/**
+		 * Yield control back to the function that called `run()`. The first parameter to this function
+		 * is returned from `run()`. The context is saved, to be later resumed from `run()`.
+		 * note: sigh, there is a #define Yield() in WinBase.h on Windows
+		 */
+		static uni::FunctionType Yield_(const uni::Arguments& args) {
+			if (current == NULL) {
+				THROW(Exception::Error, "yield() called with no fiber running");
+			}
+
+			Fiber& that = *current;
+
+			if (that.zombie) {
+				return uni::Return(uni::ThrowException(that.isolate, uni::Deref(that.isolate, that.zombie_exception)), args);
+			} else if (args.Length() == 0) {
+				uni::Reset<Value>(that.isolate, that.yielded, Undefined(that.isolate));
+			} else if (args.Length() == 1) {
+				uni::Reset(that.isolate, that.yielded, args[0]);
+			} else {
+				THROW(Exception::TypeError, "yield() expects 1 or no arguments");
+			}
+			that.yielded_exception = false;
+
+			// While not running this can be garbage collected if no one has a handle.
+			that.MakeWeak();
+
+			// Return control back to `Fiber::run()`. While control is outside this function we mark it as
+			// ok to garbage collect. If no one ever has a handle to resume the function it's harmful to
+			// keep the handle around.
+			{
+				Unlocker unlocker(that.isolate);
+				uni::ReverseIsolateScope isolate_scope(that.isolate);
+				that.yielding = true;
+				that.entry_fiber->run();
+				that.yielding = false;
+			}
+			// Now `run()` has been called again.
+
+			// Don't garbage collect anymore!
+			that.ClearWeak();
+
+			// Return the yielded value
+			return uni::Return(that.ReturnYielded(), args);
+		}
+
+		/**
+		 * Getters for `started`, and `current`.
+		 */
+		static uni::FunctionType GetStarted(Local<String> property, const uni::GetterCallbackInfo& info) {
+			if (info.This().IsEmpty() || info.This()->InternalFieldCount() != 1) {
+				return uni::Return(uni::Undefined(Isolate::GetCurrent()), info);
+			}
+			Fiber& that = Unwrap(info.This());
+			return uni::Return(uni::NewBoolean(that.isolate, that.started), info);
+		}
+
+		static uni::FunctionType GetCurrent(Local<String> property, const uni::GetterCallbackInfo& info) {
+			if (current) {
+				return uni::Return(current->handle, info);
+			} else {
+				return uni::Return(uni::Undefined(Isolate::GetCurrent()), info);
+			}
+		}
+
+		/**
+		 * Allow access to coroutine pool size
+		 */
+		static uni::FunctionType GetPoolSize(Local<String> property, const uni::GetterCallbackInfo& info) {
+			return uni::Return(uni::NewNumber(Isolate::GetCurrent(), Coroutine::pool_size), info);
+		}
+
+		static void SetPoolSize(Local<String> property, Local<Value> value, const uni::SetterCallbackInfo& info) {
+			Coroutine::pool_size = value->ToNumber()->Value();
+		}
+
+		/**
+		 * Return number of fibers that have been created
+		 */
+		static uni::FunctionType GetFibersCreated(Local<String> property, const uni::GetterCallbackInfo& info) {
+			return uni::Return(uni::NewNumber(Isolate::GetCurrent(), Coroutine::coroutines_created()), info);
+		}
+
+	public:
+		/**
+		 * Initialize the Fiber library.
+		 */
+		static void Init(Handle<Object> target) {
+			// Use a locker which won't get destroyed when this library gets unloaded. This is a hack
+			// to prevent v8 from trying to clean up this "thread" while the whole application is
+			// shutting down. TODO: There's likely a better way to accomplish this, but since the
+			// application is going down lost memory isn't the end of the world. But with a regular lock
+			// there's seg faults when node shuts down.
+			Isolate* isolate = Isolate::GetCurrent();
+			global_locker = new Locker(isolate);
+			current = NULL;
+
+			// Fiber constructor
+			Handle<FunctionTemplate> tmpl = uni::NewFunctionTemplate(isolate, New);
+			uni::Reset(isolate, Fiber::tmpl, tmpl);
+			tmpl->SetClassName(uni::NewLatin1Symbol(isolate, "Fiber"));
+
+			// Guard which only allows these methods to be called on a fiber; prevents
+			// `fiber.run.call({})` from seg faulting.
+			Handle<Signature> sig = uni::NewSignature(isolate, tmpl);
+			tmpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+			// Fiber.prototype
+			Handle<ObjectTemplate> proto = tmpl->PrototypeTemplate();
+			proto->Set(uni::NewLatin1Symbol(isolate, "reset"),
+				uni::NewFunctionTemplate(isolate, Reset, Handle<Value>(), sig));
+			proto->Set(uni::NewLatin1Symbol(isolate, "run"),
+				uni::NewFunctionTemplate(isolate, Run, Handle<Value>(), sig));
+			proto->Set(uni::NewLatin1Symbol(isolate, "throwInto"),
+				uni::NewFunctionTemplate(isolate, ThrowInto, Handle<Value>(), sig));
+			proto->SetAccessor(uni::NewLatin1Symbol(isolate, "started"), GetStarted);
+
+			// Global yield() function
+			Handle<Function> yield = uni::NewFunctionTemplate(isolate, Yield_)->GetFunction();
+			Handle<String> sym_yield = uni::NewLatin1Symbol(isolate, "yield");
+			target->Set(sym_yield, yield);
+
+			// Fiber properties
+			Handle<Function> fn = tmpl->GetFunction();
+			fn->Set(sym_yield, yield);
+			fn->SetAccessor(uni::NewLatin1Symbol(isolate, "current"), GetCurrent);
+			fn->SetAccessor(uni::NewLatin1Symbol(isolate, "poolSize"), GetPoolSize, SetPoolSize);
+			fn->SetAccessor(uni::NewLatin1Symbol(isolate, "fibersCreated"), GetFibersCreated);
+
+			// Global Fiber
+			target->Set(uni::NewLatin1Symbol(isolate, "Fiber"), fn);
+			uni::Reset(isolate, fiber_object, fn);
+		}
+};
+
+Persistent<FunctionTemplate> Fiber::tmpl;
+Persistent<Function> Fiber::fiber_object;
+Locker* Fiber::global_locker;
+Fiber* Fiber::current = NULL;
+vector<Fiber*> Fiber::orphaned_fibers;
+Persistent<Value> Fiber::fatal_stack;
+bool did_init = false;
+
+#if !NODE_VERSION_AT_LEAST(0,10,0)
+extern "C"
+#endif
+void init(Handle<Object> target) {
+	Isolate* isolate = Isolate::GetCurrent();
+	if (did_init || !target->Get(uni::NewLatin1Symbol(isolate, "Fiber"))->IsUndefined()) {
+		// Oh god. Node will call init() twice even though the library was loaded only once. See Node
+		// issue #2621 (no fix).
+		return;
+	}
+	did_init = true;
+	uni::HandleScope scope(isolate);
+	Coroutine::init(isolate);
+	Fiber::Init(target);
+	// Default stack size of either 512k or 1M. Perhaps make this configurable by the run time?
+	Coroutine::set_stack_size(128 * 1024);
+}
+
+NODE_MODULE(fibers, init)

+Copyright (c) 2000-2009 Marc Alexander Lehmann <schmorp@schmorp.de>
+
+Redistribution and use in source and binary forms, with or without modifica-
+tion, are permitted provided that the following conditions are met:
+
+  1.  Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+  2.  Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
+CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
+EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
+CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
+ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Alternatively, the following files carry an additional notice that
+explicitly allows relicensing under the GPLv2: coro.c, coro.h.
+

+Configuration, documentation etc. is provided in the coro.h file.  Please
+note that the file conftest.c in this distribution is under the GPL. It is
+not needed for proper operation of this library though, for that, coro.h
+and coro.c suffice.
+
+Marc Lehmann <schmorp@schmorp.de>

+/*
+ *  This file was taken from pth-1.40/aclocal.m4
+ *  The original copyright is below.
+ *
+ *  GNU Pth - The GNU Portable Threads
+ *  Copyright (c) 1999-2001 Ralf S. Engelschall <rse@engelschall.com>
+ *
+ *  This file is part of GNU Pth, a non-preemptive thread scheduling
+ *  library which can be found at http://www.gnu.org/software/pth/.
+ *
+ *  This file is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This file is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this file; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ *  USA, or contact Marc Lehmann <schmorp@schmorp.de>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(TEST_sigstack) || defined(TEST_sigaltstack)
+#include <sys/types.h>
+#include <signal.h>
+#include <unistd.h>
+#endif
+#if defined(TEST_makecontext)
+#include <ucontext.h>
+#endif
+union alltypes {
+    long   l;
+    double d;
+    void  *vp;
+    void (*fp)(void);
+    char  *cp;
+};
+static volatile char *handler_addr = (char *)0xDEAD;
+#if defined(TEST_sigstack) || defined(TEST_sigaltstack)
+static volatile int handler_done = 0;
+void handler(int sig)
+{
+    char garbage[1024];
+    int i;
+    auto int dummy;
+    for (i = 0; i < 1024; i++)
+        garbage[i] = 'X';
+    handler_addr = (char *)&dummy;
+    handler_done = 1;
+    return;
+}
+#endif
+#if defined(TEST_makecontext)
+static ucontext_t uc_handler;
+static ucontext_t uc_main;
+void handler(void)
+{
+    char garbage[1024];
+    int i;
+    auto int dummy;
+    for (i = 0; i < 1024; i++)
+        garbage[i] = 'X';
+    handler_addr = (char *)&dummy;
+    swapcontext(&uc_handler, &uc_main);
+    return;
+}
+#endif
+int main(int argc, char *argv[])
+{
+    FILE *f;
+    char *skaddr;
+    char *skbuf;
+    int sksize;
+    char result[1024];
+    int i;
+    sksize = 32768;
+    skbuf = (char *)malloc(sksize*2+2*sizeof(union alltypes));
+    if (skbuf == NULL)
+        exit(1);
+    for (i = 0; i < sksize*2+2*sizeof(union alltypes); i++)
+        skbuf[i] = 'A';
+    skaddr = skbuf+sizeof(union alltypes);
+#if defined(TEST_sigstack) || defined(TEST_sigaltstack)
+    {
+        struct sigaction sa;
+#if defined(TEST_sigstack)
+        struct sigstack ss;
+#elif defined(TEST_sigaltstack) && defined(HAVE_STACK_T)
+        stack_t ss;
+#else
+        struct sigaltstack ss;
+#endif
+#if defined(TEST_sigstack)
+        ss.ss_sp      = (void *)(skaddr + sksize);
+        ss.ss_onstack = 0;
+        if (sigstack(&ss, NULL) < 0)
+            exit(1);
+#elif defined(TEST_sigaltstack)
+        ss.ss_sp    = (void *)(skaddr + sksize);
+        ss.ss_size  = sksize;
+        ss.ss_flags = 0;
+        if (sigaltstack(&ss, NULL) < 0)
+            exit(1);
+#endif
+        memset((void *)&sa, 0, sizeof(struct sigaction));
+        sa.sa_handler = handler;
+        sa.sa_flags = SA_ONSTACK;
+        sigemptyset(&sa.sa_mask);
+        sigaction(SIGUSR1, &sa, NULL);
+        kill(getpid(), SIGUSR1);
+        while (!handler_done)
+            /*nop*/;
+    }
+#endif
+#if defined(TEST_makecontext)
+    {
+        if (getcontext(&uc_handler) != 0)
+            exit(1);
+        uc_handler.uc_link = NULL;
+        uc_handler.uc_stack.ss_sp    = (void *)(skaddr + sksize);
+        uc_handler.uc_stack.ss_size  = sksize;
+        uc_handler.uc_stack.ss_flags = 0;
+        makecontext(&uc_handler, handler, 1);
+        swapcontext(&uc_main, &uc_handler);
+    }
+#endif
+    if (handler_addr == (char *)0xDEAD)
+        exit(1);
+    if (handler_addr < skaddr+sksize) {
+        /* stack was placed into lower area */
+        if (*(skaddr+sksize) != 'A')
+             sprintf(result, "(skaddr)+(sksize)-%d,(sksize)-%d",
+                     sizeof(union alltypes), sizeof(union alltypes));
+        else
+             strcpy(result, "(skaddr)+(sksize),(sksize)");
+    }
+    else {
+        /* stack was placed into higher area */
+        if (*(skaddr+sksize*2) != 'A')
+            sprintf(result, "(skaddr),(sksize)-%d", sizeof(union alltypes));
+        else
+            strcpy(result, "(skaddr),(sksize)");
+    }
+    printf("%s\n", result);
+    exit(0);
+}
+