minor comsetic logging fix. vbump to v0.4.1

fix second run issues with --flag enabled. better error handling
package: finally got around to adding contrib
2015-08-09 08:42:18 -07:00 · 2015-08-09 08:32:18 -07:00 · 2015-06-29 10:41:16 -07:00 · 2015-06-26 18:36:26 -07:00 · 2015-06-26 18:30:35 -07:00 · 2015-06-26 18:27:26 -07:00
70 changed files with 1458 additions and 5317 deletions
@@ -0,0 +1,4 @@
+[commands]
+proj = subl .
+.DS_Store
+
@@ -1,9 +0,0 @@
-root = true
-[*]
-end_of_line = lf
-charset = utf-8
-indent_style = space
-indent_size = 2
-#https://github.com/Microsoft/vscode/issues/23983#event-1087502108
-#trim_trailing_whitespace = true
-insert_final_newline = true
@@ -1,10 +1,9 @@
-.DS_Store
-temp/
-coverage
 node_modules
-*.log
-*.exe
-.idea
-.nexe
-lib
-
+.DS_Store
+*.nex
+src
+nexe.exe
+nexe
+npm-debug.log
+examples/**/src
+examples/**/out.nex
@@ -1,9 +0,0 @@
-os: osx
-language: node_js
-node_js:
- '6'
-script: npm run nexe-build
-env:
-  - secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
-notifications:
-  email: false
@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-      "esbenp.prettier-vscode"
-    ]
-}
@@ -1,19 +0,0 @@
-{
-  "typescript.tsdk": "./node_modules/typescript/lib",
-  "prettier.semi": false,
-  "prettier.singleQuote": true,
-  "prettier.typescriptEnable": ["typescript"],
-  "editor.trimAutoWhitespace": true,
-  "files.exclude": {
-    "**/.git": true,
-    "**/.svn": true,
-    "**/.hg": true,
-    "**/CVS": true,
-    "**/.DS_Store": true
-  },
-  "search.exclude": {
-    "lib/**/*": true,
-    "**/node_modules": true,
-    "**/bower_components": true
-  }
-}
@@ -1,64 +1,51 @@
 # Nexe ChangeLog

-## 2017-05-29, Version v2.0.0-beta.1, @calebboyd
-
-Nexe 2.0 is a rewrite to enable some new features. These include:
-  * Quick Builds!
-  * Userland build patches
-  * Resource storage/access rewrite
-  * stdin interface
-  * Optional, pluggable bundling
-
-### Breaking Changes
-  * New options -- Please see the [readme](README.md#options)
-  * Bundling is no longer enabled by default
-  * To access included resources `fs.readFile` and `fs.readFileSync` should be used
-
 ## 2015-02-20, Version v0.3.7, @jaredallard

 ### Noteable Changes

-  * Fixed #103.
-  * Made not-available require not a fatal error.
-  * Stub and system to ignore certain requires.
-  * Added 'sys' to ignore list.
-  * We have a gitter!
-  * Gave win32 a 100 length progress bar.
+   * Fixed #103.
+   * Made not-available require not a fatal error.
+   * Stub and system to ignore certain requires.
+   * Added 'sys' to ignore list.
+   * We have a gitter!
+   * Gave win32 a 100 length progress bar.

 ### Commits
-
-  * [**2cacd83**] Update README.md (@crcn)
-  * [**0e90ac9**] Update README.md (@crcn)
-  * [**54967d1**] Added Gitter badge (@jaredallard)
-  * [**bb489a3**] Fixes #98 by giving win32 a 100 length progress bar. (@jaredallard)
-  * [**39665a8**] Lighter weight way to accomplish the exclusion of the sys module (@CKarper)
-  * [**5aca22d**] This handles embedding 'bin' scripts with shebang interpreter... (@CKarper)
-  * [**e79b0fb**] Stub to ignore require('sys') (@CKarper)
+  
+   * [**2cacd83**] Update README.md (@crcn)
+   * [**0e90ac9**] Update README.md (@crcn)
+   * [**54967d1**] Added Gitter badge (@jaredallard)
+   * [**bb489a3**] Fixes #98 by giving win32 a 100 length progress bar. (@jaredallard)
+   * [**39665a8**] Lighter weight way to accomplish the exclusion of the sys module (@CKarper)
+   * [**5aca22d**] This handles embedding 'bin' scripts with shebang interpreter... (@CKarper)
+   * [**e79b0fb**] Stub to ignore require('sys') (@CKarper)

 ## 2015-02-15, Version v0.3.6, @jaredallard

 ### Noteable Changes

-  * Now support .json in require.
-  * Fixed a major --python flag bug.
+   * Now support .json in require.
+   * Fixed a major --python flag bug.

 ### Commits

-  * [**cac6986**] V bump to solve critical error. (@jaredallard)
-  * [**b040337**] Fixes #99, resolves #97 by warning on missing file. New examples... (@jaredallard)
-  * [**ad4da1d**] Support .json extensions in require() resolution (@CKarper)
+   * [**cac6986**] V bump to solve critical error. (@jaredallard)
+   * [**b040337**] Fixes #99, resolves #97 by warning on missing file. New examples... (@jaredallard)
+   * [**ad4da1d**] Support .json extensions in require() resolution (@CKarper)

 ## 2015-02-14, Version v0.3.5, @jaredallard

+
 ### Noteable Changes

-  * Added new flag: `--python </path/to/python>`
-  * Added resourceFiles option which allows embedding files and getting them via embed.js
-  * Updated a bunch of the dependencies.
-  * `process.argv` is now consistent in a child fork case.
-  * Added `child_process.fork` support.
-  * Added new collaborators:
-    * Jared Allard (@jaredallard)
+   * Added new flag: `--python </path/to/python>`
+   * Added resourceFiles option which allows embedding files and getting them via embed.js
+   * Updated a bunch of the dependencies.
+   * `process.argv` is now consistent in a child fork case.
+   * Added `child_process.fork` support.
+   * Added new collaborators:
+      * Jared Allard (@jaredallard)

 ### Commits

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2017 Nexe Contributors
+Copyright (c) 2013 Craig Condon

 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -1,193 +1,177 @@
-<p align="center"><img src="https://cloud.githubusercontent.com/assets/2391349/23598327/a17bb68a-01ee-11e7-8f55-88a5fc96e997.png" /></p>
+### Nexe

-<p align="center">
-  <a href="https://circleci.com/gh/nexe/nexe"><img src="https://img.shields.io/circleci/project/nexe/nexe.svg" alt="Build Status"></a>
-  <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/dt/nexe.svg" alt="Downloads"></a>
-  <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/v/nexe.svg" alt="Version"></a>
-  <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/l/nexe.svg" alt="License"></a>
-</p>
+[![Join the chat at https://gitter.im/crcn/nexe](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/crcn/nexe?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Dependency Status](https://david-dm.org/crcn/nexe.svg)](https://david-dm.org/crcn/nexe)
+[![Stories in Ready](https://badge.waffle.io/crcn/nexe.svg?label=ready&title=Ready)](http://waffle.io/crcn/nexe)

-<p align="center"><code>npm i nexe -g</code></p>
-<p align="center">Nexe is a command-line utility that compiles your Node.js application into a single executable file.</p>
+Nexe is a command-line utility that compiles your Node.js application into a single executable file.

-<p align="center">
-  <img src="https://cloud.githubusercontent.com/assets/5818726/26533446/ce19ee5a-43de-11e7-9540-caf7ebd93370.gif"/>
-</p>
+![screen shot 2014-02-28 at 10 32 54 am](https://f.cloud.github.com/assets/757408/2296993/c276f7b6-a0a6-11e3-86d3-e6c5feba2a85.png)

-## Motivation and Features

- Self contained applications
+### Motivation
+
 - Ability to run multiple applications with *different* node.js runtimes.
- Distribute binaries without needing node / npm.
- Idempotent builds
- Start and deploy faster.
+- Distributable binaries without needing node / npm.
+- Starts faster.
 - Lockdown specific application versions, and easily rollback.
- Flexible build pipeline
- Cross platform builds
+- Faster deployments.

-## Usage
+## Building Requirements

- Application entrypoint:
+- Linux / Mac / BSD / Windows
+- Python 2.6 or 2.7 (use --python if not in PATH)
+- Windows: Visual Studio 2010+

-  `nexe my-app.js`
+## Caveats

- stdin interface
+### Doesn't support native modules

-  `rollup -c | nexe --resource "./public/**/*" -o my-app.exe`
+- Use the techniques below for working around dynamic require statements to exclude the module from the bundling, and deploy along side the executable in a node_module folder so your app can find it. Note: On windows you may need to have your app be named node.exe if .node file depends on node.

-For more CLI options see: `nexe --help`
+### Doesn't support dynamic require statements

-# Advanced
-
-## Resources
-
-Additional files or resources can be added to the binary by passing `-r "glob/pattern/**/*"`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`
-
-## Compiling Node
-
-By default `nexe` will attempt to download a pre-built executable. However, It may be unavailable ([github releases](https://github.com/nexe/nexe/releases))
-or you may want to customize what is built. See `nexe --help` for a list of options available when passing the `--build` option. You will also need to ensure your environment is setup to [build node](https://github.com/nodejs/node/blob/master/BUILDING.md)
-
-## Node.js API
-
-#### Example
+Such As:

 ```javascript
-const { compile } = require('nexe')
-
-compile({
-  input: './my-app.js',
-  build: true, //required to use patches
-  patches: [
-    async (compiler, next) => {
-      await compiler.setFileContentsAsync(
-        'lib/new-native-module.js',
-        'module.exports = 42'
-      )
-      return next()
-    }
-  ]
-}).then(() => {
-  console.log('success')
-})
+var x = require(someVar);
 ```
-## NexeOptions

-### `options: object`
+In this case nexe won't bundle the file

- - #### `input: string`
-    - Input bundle file path
-    - default: stdin or the current directory's main file (package.json)
- - #### `output: string`
-    - Output executable file path
-    - default: same as `name` with an OS specific extension.
- - #### `target: string | object`
-    - Combination of platform-arch-version. e.g. `'win32-ia32-6.10.3'`
-      - each segment is optional, and will be merged with the current environment
-    - default: `process`
- #### `bundle: string | boolean`
-    - If a string is provided it must be a valid relative module path
-    and should provide an export with the following signature:
-    ```typescript
-    export function createBundle (options: NexeOptions): Promise<string>
-    ```
-    - default: true
- - #### `name: string`
-    - Module friendly name of the application
-    - default: basename of the input file, or `nexe_${Date.now()}`
- - #### `cwd: string`
-    - Directory nexe will operate on as though it is the cwd
-    - default: process.cwd()
- - #### `build: boolean`
-    - Build node from source
- - #### `python: string`
-    - On Linux this is the path pointing to your python2 executable
-    - On Windows this is the directory where `python` can be accessed
-    - default: `null`
- - #### `flags: string[]`
-    - Array of node runtime flags to build node with.
-    - Example: `['--expose-gc']`
-    - default: `[]`
- - #### `configure: string[]`
-    - Array of arguments for the node build configure step
-    - Example: `['--with-dtrace', '--dest-cpu=x64']`
-    - default: `[]`
- - #### `make: string[]`
-    - Array of arguments for the node build make step, on windows this step recieves options for vcBuild.bat
-    - default: `[]` or `['nosign', 'release']` for non windows systems
- - #### `make: string[]`
-    - Alias for `make` option
- - #### `snapshot: string`
-    - path to a file to be used as the warmup snapshot for the build
-    - default: `null`
- - #### `resources: string[]`
-    - Array of globs with files to include in the build
-    - Example: `['./public/**/*']`
-    - default: `[]`
- - #### `temp: string`
-    - Path to use for storing nexe's build files
-    - Override in the env with `NEXE_TEMP`
-    - default: `./.nexe` in the cwd
- - #### `ico: string`
-    - Path to a user provided icon to be used (Windows only).
- - #### `rc: object`
-    - Settings for patching the [node.rc](https://github.com/nodejs/node/blob/master/src/res/node.rc) configuration file (Windows only).
-    - Example: `{ CompanyName: "ACME Corp" }`
-    - default: `{}`
- - #### `clean: boolean`
-    - If included, nexe will remove temporary files for the accompanying configuration and exit
- - #### `enableNodeCli: boolean`
-    - Enable the original Node CLI (will prevent application cli from working)
-    - default: `false`
-  - #### `fakeArgv: boolean`
-    - fake the entry point file name (`process.argv[1]`). If nexe was used with stdin this will be `'[stdin]'`. 
- - #### `sourceUrl: string`
-    - Provide an alternate url for the node source code
-    - Note: temporary files will still be created for this under the specified version
- - #### `loglevel: string`
-    - Set the loglevel, info, silent, or verbose
-    - default: `'info'`
- - #### `patches: NexePatch[]`
-    - Userland patches for patching or modifying node source
-    - default: `[]`
+```javascript
+	var x;
+	if (someCheck) {
+		x = require("./ver1.js");
+	} else {
+		x = require("./var2.js");
+	}
+```

-### `NexePatch: (compiler: NexeCompiler, next: () => Promise<void>) => Promise<void>`
+In this case nexe will bundle both files.

-A patch is just a middleware function that takes two arguments, the `compiler`, and `next`. The compiler is described below, and `next` ensures that the pipeline continues. Its invocation should always be awaited or returned to ensure correct behavior.
+Workarounds:
+1) for dynamic requires that you want bundled add the following into your project

-For examples, see the built in patches: [src/patches](src/patches)
+```javascript
+	var dummyToForceIncludeForBundle = false;
+	if (dummyToForceIncludeForBundle) {
+		require("./loadedDynamicallyLater.js");
+		// ...
+	}
+```
+this will trick the bundler into including them.

-### `NexeCompiler`
+2) for dynamic files getting included that you don't want to be

- - `setFileContentsAsync(filename: string, contents: string): Promise<void>`
-    - Quickly set a file's contents within the downloaded Node.js source.
- - `replaceInFileAsync(filename: string, ...replaceArgs): Promise<void>`
-    - Quickly perform a replace in a file within the downloaded Node.js source. The rest arguments are passed along to `String.prototype.replace`
- - `readFileAsync(filename: string): Promise<NexeFile>`
-    - Access (or create) a file within the downloaded Node.js source.
- - `files: NexeFile[]`
-    - The cache of the currently read, modified, or created files within the downloaded Node.js source.
+```javascript
+	var moduleName = "./ver2.js";
+	if (someCheck) {
+		moduleName = "./ver1.js";
+	}
+	var x = require(moduleName);
+```
+Note: neither file will be bundled.

-#### `NexeFile`
-  - `contents: string`
-  - `absPath: string`
-  - `filename: string`
+Using these two techniques you can change your application code so modules are not bundles, and generate a includes.js file as part of your build process so that the right files get bundled for your build configuration.

-Any modifications made to `NexeFile#contents` will be maintained in the cache _without_ the need to explicitly write them back out, e.g. using `NexeCompiler#setFileContentsAsync`.
+### &#95;&#95;dirname

-## Native Modules
+Once the module is bundled it is part of the executable. &#95;&#95;dirname is therefore the executable dir (process.execPath). Thus if you put resources on a relative path from the the executable your app will be able to access them.

-Nexe has a plugin built for use with [fuse-box](http://fuse-box.org) > 2.2.1. This plugin currently supports modules that require `.node` files and those that use the `bindings` module.
-Take a look at the (windows) [example](examples/native-build/build.js)
+If you had a data file at `/dev/myNodeApp/stateManager/handler/data/some.csv`
+and a file at `/dev/myNodeApp/stateManager/handler/loader.js`

- [ ] Implement support `node-pre-gyp#find`.
+```javascript
+	module.exports = fw.readFileSync(path.join(__dirname, "./data/some.csv"));
+```
+You would need to deploy some.csv in a sub dir `data/` along side your executable
+
+There are potential use cases for &#95;&#95;dirname where the executable path is not the correct substitution, and could result in a silent error (possibly even in a dependency that you are unaware of).
+
+Note: &#95;&#95;filename will be 'undefined'
+
+### child_process.fork
+
+child_process.spawn works is unmodified, but child_process.fork will make an attempt to launch a new instance of your executable and run the bundled module.
+
+## Installation
+
+Via NPM:
+
+```bash
+	npm install nexe [-g]
+```
+
+Or git:
+
+```bash
+	git clone https://github.com/crcn/nexe.git
+```
+
+### CLI Usage
+
+```text
+
+Usage: nexe -i [sources] -o [binary] [options]
+
+Options:
+	-i, --input    The entry javascript files         [default: cwd]
+	-o, --output   The output binary                  [default: out.nex]
+	-r, --runtime  The node.js runtime to use         [default: "latest"]
+	-t, --temp     The path to store node.js sources  [default: ./tmp/nexe]
+	-f, --flags    Don't parse node and v8 flags, pass through app flags  [default: false]
+	-v, --version  Display version number
+	-p, --python   Set path of python to use.         [default: "python"]
+	-F, --framework Set the framework to use.          [default: "nodejs"]
+
+```
+
+
+### Code Usage
+
+```javascript
+
+var nexe = require('nexe');
+
+nexe.compile({
+	input: 'input.js',
+	output: 'path/to/bin',
+	nodeVersion: '0.12.5',
+	nodeTempDir: 'src',
+	python: 'path/to/python',
+	resourceFiles: [ 'path/to/a/file' ],
+	flags: true,
+	framework: "nodejs"
+}, function(err) {
+	console.log(err);
+});
+
+```
+
+### package.json inclusion
+
+As of 0.4.0 you can now embed nexe options into package.json. Note that this Format
+is still in works, so it is likely to change.
+
+```
+"nexe": {
+	"input": "./bin/nexe",
+	"output": "nexe^$",
+	"temp": "src",
+	"runtime": {
+		"framework": "iojs",
+		"version": "2.3.1",
+		"ignoreFlags": true
+	}
+}
+```
+
+Notes:
+
+* output: can use ^$ for platform specific file extension

 ## Maintainers

-[![Jared Allard](https://avatars.githubusercontent.com/u/2391349?s=130)](https://jaredallard.me/) | [![Caleb Boyd](https://avatars.githubusercontent.com/u/5818726?s=130)](https://github.com/calebboyd) | [![Christopher Karper](https://avatars.githubusercontent.com/u/653156?s=130)](https://github.com/ckarper) | [![Dustin Greif](https://avatars.githubusercontent.com/u/3026298?s=130)](https://github.com/dgreif) |
---|---|---|---
-[Jared Allard](https://github.com/jaredallard) | [Caleb Boyd](http://github.com/calebboyd) | [Christopher Karper](https://github.com/ckarper) | [Dustin Greif](https://github.com/dgreif) |
-
-### Former
-
- [Craig Condon](http://crcn.codes/)
+* __Jared Allard__ ([@jaredallard](https://github.com/jaredallard)) &lt;[jaredallard@outlook.com](mailto:jaredallard@outlook.com)&gt; (Active)
+* __Christopher Karper__ ([@ckarper](https://github.com/CKarper)) &lt;[Christopher.Karper@gmail.com](mailto:Christopher.Karper@gmail.com)&gt; (Active)
+* __Craig Jefferds__ ([@crcn](https://github.com/crcn)) &lt;[craig.j.condon@gmail.com](mailto:craig.j.condon@gmail.com)&gt; (Not Active)
@@ -1,21 +0,0 @@
-environment:
-  CIRCLE_TOKEN:
-    secure: TQKcepXmTzCNt4+tUBtYpwEQkdSPwFr9A8ugtoMhNbKu/SW1WM1EpjEu6kYXxpQ4
-  TRAVIS_TOKEN:
-    secure: tR7HXYv3x97q90uvPrjUxKZh7R1+uqKct0HdEcqTbsg=
-  GITHUB_TOKEN:
-    secure: 3wuEGJsppSKFvdwhp3jprUA9Zkc3WINlc/9oFXjhAR6J05lYMXP7Fl7lXTKpkGZx
-branches:
-  except:
-    - master
-install:
-  - ps: Install-Product node 6
-  - npm i
-build: off
-test: off
-build_script:
-  - npm run nexe-build
-artifacts:
-  - path: .nexe\**\node.exe
-cache:
-  - node_modules
@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+var path = require('path'),
+    fs   = require('fs'),
+		nexe = require('../lib'),
+		_log = require("../lib/log"),
+    cli = require('yargs').
+usage('Usage: $0 -i [sources] -o [binary]').
+options('i', {
+	demand: true,
+	alias: 'input',
+	desc: 'The entry javascript files',
+	default: process.cwd()
+}).
+options('o', {
+	demand: true,
+	alias: 'output',
+	desc: 'The output binary',
+	default: "out.nex"
+}).
+options('r', {
+	alias: 'runtime',
+	default: 'latest',
+	description: 'The node.js runtime to use'
+}).
+options('t', {
+	alias: 'temp',
+	default: './tmp/nexe',
+	description: 'The path to store node.js sources'
+}).
+options('f', {
+	alias: 'flags',
+	description: 'Don\'t parse node and v8 flags, pass through app flags',
+	default: false
+}).
+options('v', {
+	alias: 'version',
+	description: 'Display version number'
+}).
+options('p', {
+	alias: 'python',
+	description: 'Set path of python to use.',
+	default: 'python'
+}).
+options('F', {
+	alias: 'framework',
+	description: 'Set the framework to use',
+	default: 'nodejs'
+});
+
+var argv = cli.argv;
+if(argv.h || argv.help) {
+	cli.showHelp();
+	process.exit();
+} else if (argv.v || argv.version) {
+	var pkginfo = require('../package.json');
+	console.log(pkginfo.version);
+	process.exit();
+}
+
+/**
+ * TODO: Support network shares?
+ **/
+function toAbsolute(pt) {
+	if(pt.substr(0, 1) == "/") return pt;
+	if(pt.substr(1, 3) == ":/") return pt; // for windows "c:/" 
+	return path.join(process.cwd(), pt);
+}
+
+if(fs.lstatSync(argv.i).isDirectory()) {
+	opts = nexe.package(path.join(argv.i, "package.json"), argv);
+	nexe.compile(opts, function(error) {
+		if(error) {
+			console.log(error.message);
+		}
+	});
+} else {
+ /**
+ 	* Call the core
+ 	**/
+	nexe.compile({
+			input       : require.resolve(toAbsolute(argv.i)),
+			output      : toAbsolute(argv.o),
+			flags       : argv.f,
+			nodeVersion : argv.r,
+			python      : argv.python,
+			nodeTempDir : toAbsolute(argv.t),
+			framework   : argv.F
+		},
+		function(error) {
+  		if(error) {
+				console.log(error.message);
+			}
+		}
+	);
+}
@@ -1,8 +0,0 @@
-machine:
-  node:
-    version: 6.11.2
-  services:
-    - docker
-test:
-  override:
-    - npm run nexe-build
@@ -0,0 +1 @@
+console.log("hello browser!");
@@ -0,0 +1,19 @@
+var nexe = require('../..');
+
+nexe.compile(
+  {
+    input: "./index.js",
+    output: "./out.nex",
+    nodeVersion: "3.0.0",
+    framework: "iojs",
+    nodeTempDir: "src",
+    python: "python",
+    flags: true,
+    resourceFiles: ["./message.txt"]
+  },
+  function (err) {
+    if (err) {
+      console.log(err);
+    }
+  }
+);
@@ -0,0 +1 @@
+Hello World!!!
@@ -0,0 +1,23 @@
+var http = require("http"),
+fs = require("fs"),
+path = require("path"),
+nexeres = require("nexeres"),
+childProc = require("child_process"),
+port = 1337;
+
+//Fork a new process to execute the broser.js
+childProc.fork(path.join(__dirname, "browser.js"));
+if (false) {
+  require("./browser.js"); //force the bundler to include the .js file
+}
+
+//start a web server on specified port (or default if not given)
+console.log("started HTTP server on port %d", port = Number(process.argv.concat().pop()) || port);
+
+http.createServer(function(req, res) {
+  //return the embeded file in response to any request
+  
+res.write(nexeres.get("message.txt"));
+
+  res.end();
+}).listen(port);
@@ -0,0 +1 @@
+hello world!
@@ -0,0 +1,4 @@
+{
+  "main": "./index.js",
+  "browser": "./index.js"
+}
@@ -0,0 +1 @@
+console.log("hello browser!");
@@ -0,0 +1,18 @@
+var nexe = require('../..');
+
+nexe.compile(
+  {
+    input: "./index.js",
+    output: "./out.nex",
+    nodeVersion: "3.0.0",
+    nodeTempDir: "./src",
+    framework: "iojs",
+    python: 'python',
+    flags: true
+  },
+  function (err) {
+    if (err) {
+      console.log(err);
+    }
+  }
+);
@@ -0,0 +1,23 @@
+var http = require("http"),
+fs = require("fs"),
+path = require("path"),
+nexeres = require("nexeres"),
+childProc = require("child_process"),
+port = 1337;
+
+//Fork a new process to execute the broser.js
+childProc.fork(path.join(__dirname, "browser.js"));
+if (false) {
+  require("./browser.js"); //force the bundler to include the .js file
+}
+
+//start a web server on specified port (or default if not given)
+console.log("started HTTP server on port %d", port = Number(process.argv.concat().pop()) || port);
+
+http.createServer(function(req, res) {
+  //return the embeded file in response to any request
+
+res.write("Hello, world!");
+
+  res.end();
+}).listen(port);
@@ -0,0 +1 @@
+hello world!
@@ -0,0 +1,4 @@
+{
+  "main": "./index.js",
+  "browser": "./index.js"
+}
@@ -1,13 +0,0 @@
-const nexe = require('../..')
-nexe.compile({
-  output: 'native-build',
-  silent: true,
-  native: {
-    zmq: {
-      additionalFiles: [
-        '../../windows/lib/x64/libzmq-v100-mt-4_0_4.dll'
-      ]
-    }
-  }
-})
-
@@ -1,18 +0,0 @@
-var zmq = require('zmq')
-var pub = zmq.socket('pub')
-
-pub.bindSync('tcp://127.0.0.1:3000')
-console.log('Publisher bound to port 3000')
-
-setInterval(function(){
-  console.log('sending a multipart message envelope')
-  pub.send(['kitty cats', 'meow!'])
-}, 2500)
-var sub = zmq.socket('sub')
-sub.connect('tcp://127.0.0.1:3000')
-sub.subscribe('kitty cats')
-console.log('Subscriber connected to port 3000')
-
-sub.on('message', function(topic, message) {
-  console.log('received a message related to:', topic.toString(), 'containing message:', message.toString())
-})
@@ -1,16 +0,0 @@
-{
-  "name": "native-build",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "build": "node build"
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "sqlite3": "^3.1.10",
-    "zmq": "^2.15.3"
-  },
-  "devDependencies": {}
-}
@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-const nexe = require('./lib/nexe')
-const eol = require('os').EOL
-
-module.exports = nexe
-
-if (require.main === module) {
-  nexe.compile(nexe.argv).catch((e) => {
-    process.stderr.write(eol + e.stack, () => process.exit(1))
-  })
-}
@@ -1,21 +0,0 @@
-This is a
- - [ ] Bug Report
- - [ ] Feature Request
- - [ ] Other
-
-<br/>
-If this is a bug report, What are the steps to reproduce?
-
-```
-//provide configuration here
-```
-
-<br/><br/>
-Please also provide:
-
- Platform(OS/Version):
- Host Node Version:
- Target Node Version:
- Nexe version:
- Python Version:
-
@@ -0,0 +1,185 @@
+/**
+ * Copyright (c) 2013 Craig Condon
+ *
+ * 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.
+ *
+ **/
+var mdeps = require("module-deps"),
+through   = require("through"),
+async     = require("async"),
+builtins = require("builtins");
+
+var _log     = require("./log");
+
+function bundle (input, complete) {
+
+  async.waterfall([
+
+    /**
+    * first we resolve all of the deps
+     */
+
+    function resolveDeps (next) {
+
+
+      var deps = [];
+
+
+      var md = mdeps({
+        xtransform: function (tr, file) {
+
+          var buffer = [];
+          console.log(tr);
+
+
+          return through(write, end);
+
+          var self = this;
+
+
+          function write (chunk) {
+            buffer.push(chunk.toString());
+            // console.log(chunk.toString(""))
+            console.log(tr);
+          }
+
+          function end() {
+            var content = buffer.join("");
+            // console.log(content);
+            /*
+            // TODO add uglify flag
+            var source = uglify.parse(content, {
+              strict: false
+            });
+            source.figure_out_scope();
+            source.compute_char_frequency();
+            source.mangle_names();
+
+            // TODO - production
+            content = source.print_to_string({
+              ascii_only: true,
+              quote_keys: true
+            });*/
+
+            this.queue(content);
+            this.queue(null);
+          }
+
+        },
+        filter: function (id) {
+          if ([ 'nexeres', 'sys', 'readline' ].indexOf(id) > -1) { return false; }
+          return !~builtins.indexOf(id);
+        },
+        extensions: [ '.js', '.json' ],
+        ignoreMissing: true
+      });
+
+      /** event for missing packages, fixes conditional requires **/
+      md.on('missing', function(id, parent) {
+        _log("warn", "couldn't find require '" + id + "', errors may occur.");
+      });
+
+      md.pipe(through(function (chunk) {
+        deps.push(chunk);
+      }, function () {
+        next(null, deps);
+      }));
+
+      md.end({ file: input })
+
+    },
+
+    function bundleScript (deps, next) {
+      var buffer = [loader.toString()];
+      var dbuffer = [];
+
+      for (var i = deps.length; i--;) {
+        var dep = deps[i];
+
+        var req = "function (require, module, exports, __dirname) { \n"
+        if (dep.id.toLowerCase().indexOf(".json", dep.id.length - 5) !== -1) {
+          //this is the result of require("someFile.json"), so we need to export it from the function
+          req += "module.exports = "
+        }
+        if ((/^\#\!/).test(dep.source)) {
+          dep.source = '//' + dep.source;
+        }
+
+        req += dep.source + "}";
+
+        dbuffer.push(JSON.stringify(dep.id) + ": ["+req+", "+!!dep.entry+", "+JSON.stringify(dep.deps)+"]")
+      }
+
+      buffer = ["(" + loader.toString() + ").call(null, {"+dbuffer.join(",")+"}," + JSON.stringify(deps[deps.length-1].id) + ")"].toString();
+
+      next(null, buffer);
+    }
+  ], complete)
+}
+
+
+var loader = function (deps, key) {
+  var pathModule = global.require("path");
+  var darr = [];
+  var dir = global.require("path").dirname(process.execPath);
+
+  var argv3 = process.argv[3];
+  if (argv3) {
+    argv3 = pathModule.relative(pathModule.dirname(process.execPath), argv3);
+    argv3 = pathModule.resolve(pathModule.dirname(key), argv3);
+  }
+  if (process.argv[2] == "--child_process" && deps[argv3]) {
+    //we've been forked and should run the module specified by argv3[3] instead of the start up module
+    key = argv3;
+    process.argv.splice(2, 2); //restore the argv to [0] = executable, [1] = nexejs
+  }
+  else if (process.argv[2] == "--child_process") {
+    //fork called, but for a module not bundled.
+    argv3 = process.argv[3];
+    process.argv.splice(1, 2); //restore the argv to [0] = executable, [1] = script
+    global.require(argv3);
+    return;
+  }
+  darr.push(deps[key]); //start up module.
+
+  function initModule (dep) {
+    if (dep.module) return dep.module.exports;
+    dep.module = { exports: {} };
+
+    dep[0](function (path) {
+      var rdep = deps[dep[2][path]];
+      var exports = rdep ? rdep.module ? rdep.module.exports : initModule(rdep) : global.require(path);
+      return exports;
+    }, dep.module, dep.module.exports, dir);
+
+    return dep.module.exports;
+  }
+
+  //run the startup module
+  darr.forEach(initModule);
+
+  return darr.filter(function (dep) {
+    return dep[1];
+  }).map(function (dep) {
+    return dep.module || {};
+  }).pop();
+}
+
+module.exports = bundle;
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2013 Craig Condon
+ *
+ * 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.
+ *
+ **/
+ 
+var path = require("path"),
+    fs = require("fs");
+
+/**
+ * TODO: Optimize this code. (more like document it so I understand it better.)
+ **/
+function embed(resourceFiles, resourceRoot, complete) {
+  function encode(filePath) {
+    return fs.readFileSync(filePath).toString('base64');
+  }
+
+  resourceFiles = resourceFiles || [];
+  resourceRoot = resourceRoot || "";
+
+  if (!Array.isArray(resourceFiles)) {
+    throw new Error("Bad Argument: resourceFiles is not an array");
+  }
+
+  var buffer = "var embeddedFiles = {\n";
+  for (var i = 0; i < resourceFiles.length; ++i) {
+    buffer += JSON.stringify(path.relative(resourceRoot, resourceFiles[i])) + ': "';
+    buffer += encode(resourceFiles[i]) + '",\n';
+  }
+
+  buffer += "\n};\n\nmodule.exports.keys = function () { return Object.keys(embeddedFiles); }\n\nmodule.exports.get = ";
+  buffer += accessor.toString();
+  complete(null, buffer);
+}
+
+var accessor = function (key) {
+  if (embeddedFiles.hasOwnProperty(key)) {
+    return new Buffer(embeddedFiles[key], 'base64');
+  }
+  else {
+    //file was not embedded, throw err.
+    throw new Error('Embedded file not found');
+  }
+}
+
+module.exports = embed;
@@ -0,0 +1,674 @@
+/**
+ * Copyright (c) 2013 Craig Condon
+ *
+ * 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.
+ *
+ **/
+var async         = require("async"),
+    outcome       = require("outcome"),
+    mkdirp        = require("mkdirp"),
+    request       = require("request"),
+    path          = require("path"),
+    fs            = require("fs"),
+    ncp           = require("ncp").ncp,
+    ProgressBar   = require("progress"),
+    child_process = require("child_process"),
+    glob          = require("glob"),
+    bundle        = require("./bundle"),
+    embed         = require("./embed"),
+    os            = require("os"),
+    targz         = require('tar.gz'),
+    _log          = require("./log"),
+    _monkeypatch  = require("./monkeypatch"),
+    spawn         = child_process.spawn;
+
+var isWin = /^win/.test(process.platform);
+var isPy;
+var framework;
+var version;
+
+var option_list = [
+	"python",
+	"input",
+	"output",
+	"nodeTempDir",
+	"flags",
+	"framework",
+	"nodeVersion"
+]
+
+/**
+ * Compiliation process.
+ */
+
+exports.compile = function (options, complete) {
+
+	var nodeCompiler, nexeEntryPath;
+
+	async.waterfall([
+		/**
+		 *check relevant options
+		 */
+		function checkOpts (next) {
+			/* failsafe */
+			if(options === undefined) {
+				_log("error", "no options given to .compile()");
+				process.exit()
+			}
+
+			option_list.forEach(function(v) {
+				if(options[v] === undefined) {
+					_log("error", "option "+v+" was empty")
+					process.exit();
+				}
+			});
+
+            /**
+             * Have we been given a custom flag for python executable?
+			 **/
+			if(options.python!=='python' && options.python!==""
+             && options.python!==undefined) {
+				if(isWin) {
+					isPy=options.python.replace(/\//gm, "\\"); // use windows file paths, batch is sensitive.
+				} else {
+					isPy=options.python;
+				}
+
+				_log("set python as "+isPy);
+			} else {
+				isPy="python";
+			}
+
+			// remove dots
+			options.framework = options.framework.replace(/\./g, "");
+
+			// set outter-scope framework variable.
+			framework = options.framework;
+			_log("framework => "+framework);
+
+			version = options.nodeVersion; // better framework vc
+
+			// check iojs version
+			if (framework === "iojs" && version === "latest" ) {
+				_log("fetching iojs versions");
+				mkdirp(options.nodeTempDir); // make temp dir, probably repetive.
+
+				// create write stream so we have control over events
+				var output = fs.createWriteStream(path.join(options.nodeTempDir,
+					"iojs-versions.json"));
+
+				request.get("https://iojs.org/dist/index.json")
+				.pipe(output);
+
+				output.on('close', function() {
+					_log("done");
+					var f = fs.readFileSync(path.join(options.nodeTempDir,
+						"iojs-versions.json"));
+					f = JSON.parse(f);
+					version = f[0].version.replace("v", "");
+
+					_log("iojs latest => "+version);
+
+					// continue down along the async road
+					next();
+				})
+			} else {
+				next();
+			}
+		},
+
+		/**
+		 * first download node
+		 */
+		function downloadNode (next) {
+			_downloadNode(version, options.nodeTempDir, next);
+		},
+
+		/**
+		 * bundle the application into one script
+		 */
+
+		function combineProject (nc, next) {
+			nodeCompiler = nc;
+			_log("bundle %s", options.input);
+			bundle(options.input, next);
+		},
+
+		/**
+		 * write the bundle to the lib directory of the target node version
+		 */
+
+		function writeBundle (source, next) {
+			bundlePath = path.join(nodeCompiler.dir, "lib", "nexe.js");
+			_log("bundle -> %s", bundlePath);
+
+			//Remove all non-ascii code from sources
+			source = source.replace(/[^\x00-\x7F]/g, "");
+			// same path as all the other JS files
+			fs.writeFile(bundlePath, source, next);
+		},
+
+		function embedResources(next) {
+			_log("embedResources %s", options.resourceFiles);
+			embed(options.resourceFiles, options.resourceRoot, next);
+		},
+
+		function writeResources (resources, next) {
+			resourcePath = path.join(nodeCompiler.dir, "lib", "nexeres.js");
+			_log("resource -> %s", resourcePath);
+
+			fs.writeFile(resourcePath, resources, next);
+		},
+
+		/**
+		 * monkeypatch some files so that the nexe.js file is loaded when the app runs
+		 */
+
+		function monkeyPatchNodeConfig (next) {
+			_monkeyPatchNodeConfig(nodeCompiler, next);
+		},
+
+		/**
+		 * monkeypatch node.cc to prevent v8 and node from processing CLI flags
+		 */
+		function monkeyPatchNodeCc (next) {
+			if (options.flags) {
+				_monkeyPatchMainCc(nodeCompiler, next);
+			} else {
+				next();
+			}
+		},
+
+        /**
+         * monkeypatch child_process.js so nexejs knows when it is a forked process
+         */
+        function monkeyPatchChildProc(next) {
+            _monkeyPatchChildProcess(nodeCompiler, next);
+        },
+
+		/**
+		 * compile the node application
+		 */
+
+		function makeExe (next) {
+			if(isWin) {
+				_log("vcbuild [make stage]");
+			} else {
+				_log("make");
+			}
+			nodeCompiler.make(next);
+		},
+
+		/**
+		 * we create the output directory if needed
+		 */
+
+		function makeOutputDirectory (next) {
+			mkdirp(path.dirname(options.output), function(){ next(); });
+		},
+
+		/**
+		 * Copy the compilied binary to the output specified.
+		 */
+
+		function copyBinaryToOutput (next) {
+			_log("cp %s %s", nodeCompiler.releasePath, options.output);
+			ncp(nodeCompiler.releasePath, options.output, function (err) {
+				if (err) {
+					_log("error", "Couldn't copy binary.");
+					throw err; // dump raw error object
+				}
+				_log('copied');
+
+				next();
+			});
+		}
+	], complete);
+}
+
+/**
+ * Download a version of node
+ *
+ * @param {string} version, version of node to download
+ * @param {string} directory, where to store the downloaded src
+ * @param {function} complete, callback
+ */
+
+function _downloadNode (version, directory, complete) {
+
+	var nodeFileDir = path.resolve(path.join(directory, framework, version)), // fixes #107, was process.cwd(), + rest.
+	nodeFilePath    = path.resolve(path.join(nodeFileDir, framework + "-" + version + ".tar.gz"));
+
+
+	// might already be downloaded, and unzipped
+	if (_getNodeCompiler(nodeFileDir, complete)) {
+		return;
+	}
+
+
+	async.waterfall([
+
+		/**
+		 * first make the directory where the zip file will live
+		 */
+
+		function makeDirectory (next) {
+			mkdirp.sync(path.dirname(nodeFilePath));
+			next();
+		},
+
+		/**
+		 * download node into the target directory
+		 */
+
+		function downloadNode (next) {
+			if (fs.existsSync(nodeFilePath)) return next();
+
+			var type = global.type;
+			var url, prefix = "https://"+framework+".org/dist";
+
+			// pick which url depending on the version
+			if(framework==="nodejs") framework = "node"; // cmon node why can't you stay the same
+
+			if (version === "latest") {
+				url = prefix + "/" + framework + "-" + version + ".tar.gz";
+			} else {
+				url = prefix + "/v" + version + "/"+framework+"-v" + version + ".tar.gz";
+			}
+
+			_log("downloading %s", url);
+
+			var output = fs.createWriteStream(nodeFilePath, { "flags": "w+" });
+
+			// need to set user-agent to bypass some corporate firewalls
+			var requestOptions = {
+				url: url,
+				headers: {
+					"User-Agent": "Node.js"
+				}
+			}
+
+			_logProgress(request(requestOptions)).pipe(output);
+
+			output.on("close", function () { next(); });
+		},
+
+		/**
+		 * unzip in the same directory
+		 */
+
+		function unzipNodeTarball (next) {
+			if(isWin) {
+				_log("Extracting the .tar.gz.");
+				new targz().extract(nodeFilePath, nodeFileDir, next);
+			} else {
+				var cmd = ["tar", "-xf", nodeFilePath, "-C", nodeFileDir];
+				_log(cmd.join(" "));
+
+				var tar = spawn(cmd.shift(), cmd);
+				tar.stdout.pipe(process.stdout);
+				tar.stderr.pipe(process.stderr);
+
+				tar.on("close", function () { next(); })
+			}
+		},
+
+		/**
+		 * return the compiler object for the node version
+		 */
+
+		function (next, type) {
+			_getNodeCompiler(nodeFileDir, next, type)
+		},
+
+	], complete);
+}
+
+/**
+ * Get the compilier we will use for whatever platform we may be on and configure
+ * it.
+ */
+
+function _getNodeCompiler (nodeFileDir, complete, type) {
+	var dir = _getFirstDirectory(nodeFileDir);
+
+	// standard
+	var executable = "node.exe";
+	var binary     = "node";
+
+	// iojs specifics.
+	if(framework === "iojs") {
+		executable = "iojs.exe";
+		binary = "iojs";
+	}
+
+	if (dir) {
+		if(isWin) {
+			complete(null, {
+				dir: dir,
+				version: path.basename(nodeFileDir),
+				releasePath: path.join(dir, "Release", executable),
+				make: function(next) {
+					// create a new env with minimal impact on old one
+					var newEnv = process.env
+
+					if(isPy!=="python") {
+						// add the dir of the suposed python exe to path
+						newEnv.path = process.env.PATH+";"+path.dirname(isPy)
+					}
+
+					// spawn a vcbuild process with our custom enviroment.
+					var vcbuild = spawn("vcbuild.bat", ["nosign", "release"], {
+						cwd: dir,
+						env: newEnv
+					});
+					vcbuild.stdout.pipe(process.stdout);
+					vcbuild.stderr.pipe(process.stderr);
+					vcbuild.on("close", function() {
+						next();
+					});
+				}
+			});
+		} else {
+			complete(null, {
+				dir: dir,
+				version: path.basename(nodeFileDir),
+				releasePath: path.join(dir, "out", "Release", binary),
+				make: function (next) {
+					var cfg = "./configure", configure;
+					if(isPy !== "python") {
+						configure = spawn(isPy, [cfg], { cwd: dir });
+					} else {
+						configure = spawn(cfg, [], { cwd: dir });
+					}
+
+					// local function, move to top eventually
+					function _loop(dir) {
+						/* eventually try every python file */
+						var pdir = fs.readdirSync(dir);
+
+						pdir.forEach(function(v, i) {
+							var stat = fs.statSync(dir+"/"+v);
+							if(stat.isFile()) {
+								// only process Makefiles and .mk targets.
+								if(v !== "Makefile" && path.extname(v) !== ".mk") {
+									return;
+								}
+
+								_log("patching "+v);
+
+								/* patch the file */
+								var py = fs.readFileSync(dir+"/"+v, {encoding: 'utf8'});
+								py = py.replace(/([a-z]|\/)*python(\w|)/gm, isPy); // this is definently needed
+								fs.writeFileSync(dir+"/"+v, py, {encoding: 'utf8'}); // write to file
+
+								delete pv;
+							} else if(stat.isDirectory()) {
+								// must be dir?
+								// skip tests because we don't need them here
+								if(v !== "test") {
+									_loop(dir+"/"+v)
+								}
+							}
+						});
+					}
+
+					configure.stdout.pipe(process.stdout);
+					configure.stderr.pipe(process.stderr);
+					configure.on("close", function () {
+						if(isPy !== "python") {
+						  /**
+							 * Originally I thought this only applied to io.js,
+							 * however I soon found out this affects node.js,
+							 * so it is now mainstream.
+							 */
+							_log("preparing python");
+
+							// loop over depends
+							_loop(dir);
+						}
+						var platformMake = "make";
+						if (os.platform().match(/bsd$/) != null) {
+							platformMake = "gmake";
+						}
+						var make = spawn(platformMake, [], { cwd: dir });
+						make.stdout.pipe(process.stdout);
+						make.stderr.pipe(process.stderr);
+						make.on("close", function () {
+							next();
+						});
+					})
+				}
+			});
+		}
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ */
+
+function _monkeyPatchNodeConfig (compiler, complete) {
+	async.waterfall([
+		/**
+		 * monkeypatch the gyp file to include the nexe.js and nexeres.js files
+		 */
+		function (next) {
+			_monkeyPatchGyp(compiler, next)
+		},
+
+		/**
+		 * monkeypatch main entry point
+		 */
+		function (next) {
+			_monkeyPatchMainJs(compiler, next)
+		}
+	], complete);
+}
+
+/**
+ * patch the gyp file to allow our custom includes
+ */
+
+function _monkeyPatchGyp (compiler, complete) {
+
+	var gypPath = path.join(compiler.dir, "node.gyp");
+
+	_monkeypatch(
+		gypPath,
+		function (content) {
+			return ~content.indexOf("nexe.js");
+		},
+		function (content, next) {
+			next(null, content.replace("'lib/fs.js',", "'lib/fs.js', 'lib/nexe.js', 'lib/nexeres.js', "))
+		},
+		complete
+	)
+}
+
+/**
+ */
+
+function _monkeyPatchMainJs (compiler, complete) {
+	var mainPath = path.join(compiler.dir, "src", "node.js");
+
+	_monkeypatch(
+		mainPath,
+		function (content) {
+			return ~content.indexOf("nexe");
+		},
+		function (content, next) {
+			next(null, content.replace(/\(function\(process\) \{/,'(function(process) {\n  process._eval = \'require("nexe");\';\n  process.argv.splice(1, 0, "nexe.js");\n'))
+		},
+		complete
+	);
+}
+
+/**
+ */
+function _monkeyPatchChildProcess(compiler, complete) {
+    var childProcPath = path.join(compiler.dir, "lib", "child_process.js");
+
+    _monkeypatch(
+        childProcPath,
+        function (content) {
+            return ~content.indexOf("--child_process");
+        },
+        function (content, next) {
+            next(null, content.replace(/return spawn\(/, 'args.unshift("--child_process");\n  return spawn('));
+        },
+        complete
+    );
+}
+
+/**
+ * Patch node.cc to not check the internal arguments.
+ */
+
+function _monkeyPatchMainCc(compiler, complete) {
+	var mainPath = path.join(compiler.dir, "src", "node.cc");
+	_monkeypatch(
+		mainPath,
+		function (content) {
+			return ~content.indexOf('//  // TODO use parse opts');
+		},
+		function (content, next) {
+			var lines = content.split('\n');
+			var endLine = lines.indexOf('  option_end_index = i;'); // pre node 0.11.6 compat
+			
+			if(endLine !== -1) { // check if it succedded or not.
+			  lines[endLine] = '  option_end_index = 1;';
+			  _log("patched node.cc")
+			}
+
+			/**
+			 * This is the new method of passing the args. Tested on node.js 0.12.5
+			 * and iojs 2.3.1
+			 **/
+			if(endLine === -1) { // only if the pre-0.12.5 failed.
+        var startLine = lines.indexOf('  while (index < nargs && argv[index][0] == \'-\') {'); // beginning of the function
+        endLine = lines.indexOf('  // Copy remaining arguments.');
+        endLine = endLine-1; // space, then it's at the }
+
+        // remove the offending lines
+        if(startLine !== -1) {
+          for (var i = startLine; i < endLine; i++) {
+            lines[i] = undefined; // set the value to undefined so it's skipped by the join
+          }
+          _log('patched node.cc');
+        }
+			}
+
+			lines = lines.join('\n');
+			next(null, lines);
+		},
+		complete
+	);
+}
+
+/**
+ */
+
+function _getFirstDirectory (dir) {
+	var files = glob.sync(dir + "/*");
+
+	for (var i = files.length; i--;) {
+		var file = files[i];
+		if (fs.statSync(file).isDirectory()) return file;
+	}
+
+	return false;
+}
+
+/**
+ */
+
+function _logProgress (req) {
+
+	req.on("response", function (resp) {
+
+		var len = parseInt(resp.headers["content-length"], 10),
+		bar     = new ProgressBar("[:bar]", {
+			complete: "=",
+			incomplete: " ",
+			total: len,
+			width: ((isWin) ? 100 : process.stdout.columns - 2) // windows doesn't output colums correctly
+		});
+
+		req.on("data", function (chunk) {
+			bar.tick(chunk.length);
+		});
+	});
+
+	return req;
+}
+
+/**
+ * Attempt to parse the package.json for nexe information.
+ *
+ * @param {string} path - path to package.json
+ * @param {object} options - fallback options
+ * 
+ * @todo implement options overriding package defaults.
+ *
+ * @return {object} nexe.compile options object
+**/
+exports.package = function(path, options) {
+	var _package; // scope
+
+	// check if the file exists
+	if(fs.existsSync(path)===false) {
+		_log("warn", "no package.json found.");
+	} else {
+		_package = require(path);
+	}
+
+	// replace ^$ w/ os specific extension on output
+	if(isWin) {
+		_package.nexe.output = _package.nexe.output.replace(/\^\$/, '.exe') // exe
+	} else {
+		_package.nexe.output = _package.nexe.output.replace(/\^\$/, '') // none
+	}
+
+	// construct the object
+	var obj = {
+		input: (_package.nexe.input || options.i),
+		output: (_package.nexe.output || options.o),
+		flags: (_package.nexe.runtime.ignoreFlags || options.f),
+		resourceFiles: (_package.nexe.resourceFiles),
+		nodeVersion: (_package.nexe.runtime.version || options.r),
+		python: (_package.nexe.python || options.p),
+		nodeTempDir: (_package.nexe.temp || options.t),
+		framework: (_package.nexe.runtime.framework || options.f)
+	}
+
+	Object.keys(_package.nexe).forEach(function(v,i) {
+		if(v!=="runtime") {
+			_log("log", v+" => '"+_package.nexe[v]+"'");
+		}
+	});
+	Object.keys(_package.nexe.runtime).forEach(function(v,i) {
+		_log("log", "runtime."+v+" => '"+_package.nexe.runtime[v]+"'");
+	});
+
+	return obj;
+}
@@ -0,0 +1 @@
+module.exports = require("./exe");
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2013 Craig Condon
+ *
+ * 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.
+ *
+ **/
+
+/**
+ * standard output, takes 3 different types.
+ * log, error, and warn
+ *
+ * @param {any} arguments - Text to output.
+ * @return undefined
+ **/
+function _log () {
+
+  var colors = require('colors');
+
+  var args = Array.prototype.slice.call(arguments, 0),
+  level = args.shift();
+
+  if (!~["log", "error", "warn"].indexOf(level)) {
+    args.unshift(level);
+    level = "log";
+  }
+
+  if(level == "log") {
+    args[0] = "----> " + args[0];
+  } else if(level == "error") {
+    args[0] = "....> " + colors.red("ERROR: ") + args[0]
+  } else if(level == "warn") {
+    args[0] = "....> " + colors.yellow("WARNING: ") + args[0]
+  }
+
+  console[level].apply(console, args);
+}
+
+// export the log function, for require()
+module.exports = _log;
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2013 Craig Condon
+ *
+ * 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.
+ *
+ **/
+ 
+var async = require("async"),
+    fs    = require("fs"),
+   _log   = require("./log");
+
+/**
+ * Monkey patch a file.
+ *
+ * @param {string} filePath - path to file.
+ * @param {function} monkeyPatched - function to process contents
+ * @param {function} processor - TODO: detail what this is
+ * @param {function} complete - callback
+ *
+ * @return undefined
+ */
+function _monkeypatch (filePath, monkeyPatched, processor, complete) {
+
+  async.waterfall([
+
+    function read (next) {
+      fs.readFile(filePath, "utf8", next);
+    },
+
+    // TODO - need to parse gyp file - this is a bit hacker
+    function monkeypatch (content, next) {
+
+      if (monkeyPatched(content)) return complete();
+
+      _log("monkey patch %s", filePath);
+      processor(content, next);
+    },
+
+    function write (content, next) {
+      fs.writeFile(filePath, content, "utf8", next);
+    }
+  ], complete);
+}
+
+// export the function for require()
+module.exports = _monkeypatch;
@@ -1,64 +1,50 @@
 {
+  "author": "Jared Allard <jaredallard@outlook.com>",
  "name": "nexe",
-  "description": "Create a single executable out of your Node.js application",
+  "description": "create single executables out of your [node/io].js applications",
  "license": "MIT",
-  "version": "2.0.0-rc.6",
+  "version": "0.4.1",
  "contributors": [
-    "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
-    "Jared Allard <jaredallard@outlook.com>",
-    "Caleb Boyd <caleb.boyd@hotmail.com>"
+    {
+      "name": "Criag Condon",
+      "email": "craig.j.condon@gmail.com",
+      "url": "http://crcn.io/"
+    }
  ],
-  "scripts": {
-    "nexe-build": "ts-node tasks/build",
-    "prebuild": "rimraf lib && npm run lint",
-    "prepublish": "npm test && npm run build",
-    "test": "mocha test/**/*.spec.ts",
-    "lint": "prettier --parser typescript --no-semi --print-width 100 --single-quote --write \"src/**/*.ts\"",
-    "build": "tsc --declaration"
-  },
  "repository": {
    "type": "git",
-    "url": "git://github.com/nexe/nexe.git"
-  },
-  "files": [
-    "lib",
-    "source-map-support.js"
-  ],
-  "main": "index.js",
-  "bin": {
-    "nexe": "index.js"
-  },
-  "engines": {
-    "node": ">=6"
+    "url": "git://github.com/jaredallard/nexe.git"
  },
+  "main": "./lib/index.js",
  "dependencies": {
-    "app-builder": "^5.1.0",
-    "chalk": "^1.1.3",
-    "download": "^6.2.0",
-    "fuse-box": "2.2.31",
-    "globby": "^6.1.0",
-    "minimist": "^1.2.0",
-    "mkdirp": "^0.5.1",
-    "ora": "^1.2.0",
-    "pifi": "1.0.0",
-    "rimraf": "^2.6.1",
-    "uglify-js": "3.0.28"
+    "async": "1.2.1",
+    "builtins": "1.0.1",
+    "colors": "^1.0.3",
+    "glob": "^5.0.5",
+    "mkdirp": "^0.5.0",
+    "module-deps": "^3.6.4",
+    "ncp": "^2.0.0",
+    "outcome": "0.0.18",
+    "progress": "^1.1.8",
+    "request": "^2.53.0",
+    "sprintf": "~0.1.5",
+    "step": "0.0.x",
+    "tar.gz": "0.1.1",
+    "through": "^2.3.6",
+    "yargs": "^3.2.1"
  },
-  "devDependencies": {
-    "@types/chai": "^4.0.4",
-    "@types/chalk": "^0.4.31",
-    "@types/globby": "^0.6.0",
-    "@types/minimist": "^1.2.0",
-    "@types/mkdirp": "^0.3.29",
-    "@types/mocha": "^2.2.42",
-    "@types/ora": "^0.3.31",
-    "@types/pify": "0.0.28",
-    "@types/rimraf": "0.0.28",
-    "chai": "^4.1.2",
-    "got": "^7.1.0",
-    "mocha": "^3.5.0",
-    "prettier": "^1.6.1",
-    "ts-node": "3.3.0",
-    "typescript": "^2.4.1"
+  "nexe": {
+    "input": "./bin/nexe",
+    "output": "nexe^$",
+    "temp": "src",
+    "runtime": {
+      "framework": "iojs",
+      "version": "2.3.1",
+      "ignoreFlags": true
+    }
+  },
+  "preferGlobal": "true",
+  "bin": {
+    "nexe": "./bin/nexe"
  }
 }
@@ -1,161 +0,0 @@
-import * as fs from 'fs'
-import * as path from 'path'
-import * as child from 'child_process'
-import { createHash } from 'crypto'
-
-export interface ExtractNodeModuleOptions {
-  [key: string]: { additionalFiles: string[] } | true
-}
-
-function hashName(name: string | Buffer) {
-  return createHash('md5')
-    .update(name)
-    .digest('hex')
-    .toString()
-    .slice(0, 8)
-}
-
-export function embedDotNode(
-  options: ExtractNodeModuleOptions,
-  file: { contents: string; absPath: string }
-) {
-  const contents = fs.readFileSync(file.absPath)
-  const modulePathParts = file.absPath.split(path.sep).reverse()
-  const module = modulePathParts[modulePathParts.findIndex(x => x === 'node_modules') - 1]
-  const bindingName = path.basename(file.absPath)
-  const settings = options[module]
-  const moduleDir = hashName(contents)
-  file.contents = `
-  var fs=require('fs');var path=require('path');var binding='${contents.toString(
-    'base64'
-  )}';function mkdirp(r,t){t=t||null,r=path.resolve(r);try{fs.mkdirSync(r),t=t||r}catch(c){if("ENOENT"===c.code)t=mkdirp(path.dirname(r),t),mkdirp(r,t);else{var i;try{i=fs.statSync(r)}catch(r){throw c}if(!i.isDirectory())throw c}}return t};`
-
-  if (!settings || settings === true) {
-    file.contents += `
-      mkdirp('${moduleDir}');
-      var bindingPath = path.join(process.cwd(), '${moduleDir}', '${bindingName}')
-      require('fs').writeFileSync(bindingPath, Buffer.from(binding, 'base64'))
-      process.dlopen(module, bindingPath)
-    `.trim()
-    return
-  }
-
-  let depth = 0
-  settings.additionalFiles.forEach(file => {
-    let ownDepth = 0
-    file.split('/').forEach(x => x === '..' && ownDepth++)
-    depth = ownDepth > depth ? ownDepth : depth
-  })
-  let segments = [moduleDir]
-  while (depth--) {
-    segments.push(hashName(moduleDir + depth))
-  }
-  segments.push(bindingName)
-
-  file.contents += `
-    var cwd = process.cwd()
-    var bindingFileParts = ${JSON.stringify(segments)};
-    var bindingFile = path.join.apply(path, [cwd].concat(bindingFileParts));
-    mkdirp(path.dirname(bindingFile));
-    fs.writeFileSync(bindingFile, Buffer.from(binding, 'base64'));
-    ${settings.additionalFiles.reduce((code, filename, i) => {
-      const contents = fs.readFileSync(path.join(path.dirname(file.absPath), filename))
-      return (code += `
-        var file${i} = '${contents.toString('base64')}';
-        var filePath${i} = path.join(cwd, bindingFileParts[0], '${filename.split('../').join('')}');
-        mkdirp(path.dirname(filePath${i}));
-        fs.writeFileSync(filePath${i}, Buffer.from(file${i}, 'base64'));
-      `)
-    }, '')};
-    process.dlopen(module, bindingFile)
-  `
-}
-
-function findNativeModulePath(filePath: string, bindingsArg: string) {
-  const dirname = path.dirname(filePath)
-  const tempFile = Math.random() * 100 + '.js'
-  const tempFilePath = path.join(dirname, tempFile)
-  fs.writeFileSync(
-    tempFilePath,
-    `
-    var bindings = require('bindings');
-    var Module = require('module');
-    var originalRequire = Module.prototype.require;
-    Module.prototype.require = function(path) {
-      const mod = originalRequire.apply(this, arguments);
-      process.stdout.write(path)
-      return mod
-    };
-    bindings('${bindingsArg}')
-  `
-  )
-  //using exec because it can be done sync
-  const nativeFileName = child.execSync('node ' + tempFile, { cwd: dirname }).toString()
-  fs.unlinkSync(tempFilePath)
-  const relativePath = './' + path.relative(dirname, nativeFileName).replace(/\\/g, '/')
-  return relativePath
-}
-/**
- * Traverse all nodes in a file and evaluate usages of the bindings module
- * handles two common cases
- */
-export class BindingsRewrite {
-  private bindingsIdNodes: any[] = []
-  public nativeModulePaths: string[] = []
-  public rewrite = false
-
-  isRequire(node: any, moduleName: string) {
-    return node.callee.name === 'require' && node.arguments[0].value === moduleName
-  }
-
-  onNode(absolutePath: string, node: any, parent: any) {
-    if (node.type === 'CallExpression') {
-      if (this.isRequire(node, 'bindings') && parent.type === 'VariableDeclarator') {
-        /**
-         * const loadBindings = require('bindings');
-         *   -> const loadBindings = String('');
-         */
-        this.bindingsIdNodes.push(parent.id)
-        node.callee.name = 'String'
-        node.arguments[0].value = ''
-        this.rewrite = true
-        return
-      }
-
-      if (this.isRequire(node, 'bindings') && parent.type === 'CallExpression') {
-        /**
-         *const bindings = require('bindings')('native-module')....
-         *  -> const bindings = require('./path/to/native/module.node').....
-         */
-        const bindingsArgNode = parent.arguments[0]
-        if (bindingsArgNode.type === 'Literal') {
-          parent.callee = { type: 'Identifier', name: 'require' }
-          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
-          this.nativeModulePaths.push(bindingsArgNode.value)
-          this.rewrite = true
-          return
-        }
-      }
-
-      const bindingsInvocationIdx = this.bindingsIdNodes.findIndex(x => node.callee.name === x.name)
-
-      if (this.bindingsIdNodes[bindingsInvocationIdx]) {
-        /**
-         * const bindings = loadBindings('native-module')
-         *   -> const bindings = require('./path/to/native/module.node')
-         */
-        const bindingsIdNode = this.bindingsIdNodes[bindingsInvocationIdx]
-        const bindingsArgNode = node.arguments[0]
-        this.bindingsIdNodes.splice(bindingsInvocationIdx, 1)
-
-        if (bindingsArgNode.type === 'Literal') {
-          node.callee.name = 'require'
-          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
-          this.nativeModulePaths.push(bindingsArgNode.value)
-          this.rewrite = true
-          return
-        }
-      }
-    }
-  }
-}
@@ -1,69 +0,0 @@
-import { BindingsRewrite, embedDotNode, ExtractNodeModuleOptions } from './bindings-rewrite'
-
-export interface FuseBoxFile {
-  info: { absPath: string }
-  absPath: string
-  contents: string
-  analysis: {
-    dependencies: string[]
-    requiresRegeneration: boolean
-  }
-  consume(): void
-  loadContents(): void
-  makeAnalysis(
-    parsingOptions?: any,
-    traversalPlugin?: {
-      plugins: Array<{
-        onNode(file: FuseBoxFile, node: any, parent: any): void
-        onEnd(file: FuseBoxFile): void
-      }>
-    }
-  ): void
-}
-
-export default function(options: ExtractNodeModuleOptions = {}) {
-  return new NativeModulePlugin(options)
-}
-
-export class NativeModulePlugin {
-  public test = /node_modules.*(\.js|\.node)$|\.node$/
-  public limit2Project = false
-  private modules: (keyof ExtractNodeModuleOptions)[]
-
-  constructor(public options = {}) {}
-
-  init(context: any) {
-    context.allowExtension('.node')
-  }
-
-  transform(file: FuseBoxFile) {
-    file.loadContents()
-
-    if (file.absPath.endsWith('.node')) {
-      embedDotNode(this.options, file)
-      return
-    }
-
-    const bindingsRewrite = new BindingsRewrite()
-
-    file.makeAnalysis(null, {
-      plugins: [
-        {
-          onNode(file, node, parent) {
-            bindingsRewrite.onNode(file.absPath, node, parent)
-          },
-          onEnd(file) {
-            if (bindingsRewrite.rewrite) {
-              const index = file.analysis.dependencies.indexOf('bindings')
-              if (~index) {
-                file.analysis.dependencies.splice(index, 1)
-              }
-              file.analysis.dependencies.push(...bindingsRewrite.nativeModulePaths)
-              file.analysis.requiresRegeneration = true
-            }
-          }
-        }
-      ]
-    })
-  }
-}
@@ -1 +0,0 @@
-export * from './fuse-native-module-plugin'
@@ -1,231 +0,0 @@
-import { dirname, normalize, join } from 'path'
-import { Buffer } from 'buffer'
-import { createHash } from 'crypto'
-import { createReadStream } from 'fs'
-import { Readable } from 'stream'
-import { spawn } from 'child_process'
-import { Logger } from './logger'
-import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows } from './util'
-import { NexeOptions, nexeVersion } from './options'
-import { NexeTarget } from './target'
-import download = require('download')
-import { getLatestGitRelease } from './releases'
-import { IncomingMessage } from 'http'
-
-const isBsd = Boolean(~process.platform.indexOf('bsd'))
-const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
-const configure = isWindows ? 'configure' : './configure'
-
-export interface NexeFile {
-  filename: string
-  absPath: string
-  contents: string
-}
-
-interface NexeHeader {
-  resources: { [key: string]: number[] }
-  version: string
-}
-
-export class NexeCompiler {
-  private start = Date.now()
-  private env = { ...process.env }
-  private compileStep: { modify: Function; log: Function }
-  public log = new Logger(this.options.loglevel)
-  public src: string
-  public files: NexeFile[] = []
-  public input: string
-  public bundledInput?: string
-  public output: string | null
-  public targets: NexeTarget[]
-  public target: NexeTarget
-  public resources: { bundle: string; index: { [key: string]: number[] } } = {
-    index: {},
-    bundle: ''
-  }
-  public readFileAsync: (file: string) => Promise<NexeFile>
-  public writeFileAsync: (file: string, contents: Buffer | string) => Promise<void>
-  public replaceInFileAsync: (file: string, replacer: any, replaceValue: string) => Promise<void>
-  public setFileContentsAsync: (file: string, contents: string | Buffer) => Promise<void>
-  private nodeSrcBinPath: string
-
-  constructor(public options: NexeOptions) {
-    const { python } = (this.options = options)
-    this.targets = options.targets as NexeTarget[]
-    this.target = this.targets[0]
-    this.src = join(this.options.temp, this.target.version)
-    this.nodeSrcBinPath = isWindows
-      ? join(this.src, 'Release', 'node.exe')
-      : join(this.src, 'out', 'Release', 'node')
-    this.log.step('nexe ' + nexeVersion, 'info')
-    if (python) {
-      if (isWindows) {
-        this.env.PATH = '"' + dequote(normalize(python)) + '";' + this.env.PATH
-      } else {
-        this.env.PYTHON = python
-      }
-    }
-
-    this.readFileAsync = async (file: string) => {
-      let cachedFile = this.files.find(x => normalize(x.filename) === normalize(file))
-      if (!cachedFile) {
-        const absPath = join(this.src, file)
-        cachedFile = {
-          absPath,
-          filename: file,
-          contents: await readFileAsync(absPath, 'utf-8').catch(x => {
-            if (x.code === 'ENOENT') return ''
-            throw x
-          })
-        }
-        this.files.push(cachedFile)
-      }
-      return cachedFile
-    }
-    this.writeFileAsync = (file, contents) => writeFileAsync(join(this.src, file), contents)
-    this.replaceInFileAsync = async (file, replace: string | RegExp, value: string) => {
-      const entry = await this.readFileAsync(file)
-      entry.contents = entry.contents.replace(replace, value)
-    }
-    this.setFileContentsAsync = async (file: string, contents: string) => {
-      const entry = await this.readFileAsync(file)
-      entry.contents = contents
-    }
-  }
-
-  quit() {
-    const time = Date.now() - this.start
-    this.log.write(`Finsihed in ${time / 1000}s`)
-    return this.log.flush()
-  }
-
-  public getNodeExecutableLocation(target?: NexeTarget) {
-    if (target) {
-      return join(this.options.temp, target.toString())
-    }
-    return this.nodeSrcBinPath
-  }
-
-  private _runBuildCommandAsync(command: string, args: string[]) {
-    return new Promise((resolve, reject) => {
-      spawn(command, args, {
-        cwd: this.src,
-        env: this.env,
-        stdio: 'ignore'
-      })
-        .once('error', reject)
-        .once('close', resolve)
-    })
-  }
-
-  private _configureAsync() {
-    return this._runBuildCommandAsync(this.env.PYTHON || 'python', [
-      configure,
-      ...this.options.configure
-    ])
-  }
-
-  private async _buildAsync() {
-    this.compileStep.log(
-      `Configuring node build${this.options.configure.length
-        ? ': ' + this.options.configure
-        : '...'}`
-    )
-    await this._configureAsync()
-    const buildOptions = this.options.make
-    this.compileStep.log(
-      `Compiling Node${buildOptions.length ? ' with arguments: ' + buildOptions : '...'}`
-    )
-    await this._runBuildCommandAsync(make, buildOptions)
-    return createReadStream(this.getNodeExecutableLocation())
-  }
-
-  private async _fetchPrebuiltBinaryAsync(target: NexeTarget) {
-    const downloadOptions: any = {
-      headers: {
-        'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
-      }
-    }
-    const githubRelease = await getLatestGitRelease(downloadOptions)
-    const assetName = target.toString()
-    const asset = githubRelease.assets.find(x => x.name === assetName)
-
-    if (!asset) {
-      throw new Error(`${assetName} not available, create it using the --build flag`)
-    }
-    const filename = this.getNodeExecutableLocation(target)
-    await download(
-      asset.browser_download_url,
-      dirname(filename),
-      downloadOptions
-    ).on('response', (res: IncomingMessage) => {
-      const total = +res.headers['content-length']!
-      let current = 0
-      res.on('data', data => {
-        current += data.length
-        this.compileStep.modify(`Downloading...${(current / total * 100).toFixed()}%`)
-      })
-    })
-    return createReadStream(filename)
-  }
-
-  private _generateHeader() {
-    const version =
-      ['configure', 'vcBuild', 'make'].reduce((a, c) => {
-        return (a += (this.options as any)[c]
-          .slice()
-          .sort()
-          .join())
-      }, '') + this.options.enableNodeCli
-    const header = {
-      resources: this.resources.index,
-      version: createHash('md5')
-        .update(version)
-        .digest('hex')
-    }
-    const serializedHeader = this._serializeHeader(header)
-    return header
-  }
-
-  private _serializeHeader(header: NexeHeader) {
-    return `process.__nexe=${JSON.stringify(header)};`
-  }
-
-  async compileAsync(target: NexeTarget) {
-    const step = (this.compileStep = this.log.step('Compiling result'))
-    const build = this.options.build
-    const location = this.getNodeExecutableLocation(build ? undefined : target)
-    let binary = (await pathExistsAsync(location)) ? createReadStream(location) : null
-    const header = this._generateHeader()
-    if (!build && !binary) {
-      step.modify('Fetching prebuilt binary')
-      binary = await this._fetchPrebuiltBinaryAsync(target)
-    }
-    if (!binary) {
-      binary = await this._buildAsync()
-      step.log('Node binary compiled')
-    }
-    return this._assembleDeliverable(header, binary)
-  }
-
-  private _assembleDeliverable(header: NexeHeader, binary: NodeJS.ReadableStream) {
-    if (this.options.empty) {
-      return binary
-    }
-    const artifact = new Readable({ read() {} })
-    binary.on('data', (chunk: Buffer) => {
-      artifact.push(chunk)
-    })
-    binary.on('close', () => {
-      const content = this._serializeHeader(header) + this.input
-      artifact.push(content)
-      artifact.push(this.resources.bundle)
-      const lengths = Buffer.from(Array(16))
-      lengths.writeDoubleLE(Buffer.byteLength(content), 0)
-      lengths.writeDoubleLE(Buffer.byteLength(this.resources.bundle), 8)
-      artifact.push(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths]))
-      artifact.push(null)
-    })
-    return artifact
-  }
-}
@@ -1,68 +0,0 @@
-import colors = require('chalk')
-import ora = require('ora')
-
-const frameLength = 120
-
-export interface LogStep {
-  modify(text: string, color?: string): void
-  log(text: string, color?: string): void
-}
-
-export class Logger {
-  private verbose: boolean
-  private silent: boolean
-  private ora: any
-  private modify: Function
-  public write: (text: string, color?: string) => void
-
-  constructor(level: 'verbose' | 'silent' | 'info') {
-    this.verbose = level === 'verbose'
-    this.silent = level === 'silent'
-    if (!this.silent) {
-      this.ora = ora({
-        text: 'Starting...',
-        color: 'blue',
-        spinner: 'dots'
-      })
-      this.ora.stop()
-    }
-    const noop = () => {}
-    this.modify = this.silent ? noop : this._modify.bind(this)
-    this.write = this.silent ? noop : this._write.bind(this)
-  }
-
-  flush() {
-    !this.silent && this.ora.succeed()
-    return new Promise(resolve => setTimeout(resolve, frameLength))
-  }
-
-  _write(update: string, color = 'green') {
-    this.ora.succeed().text = (colors as any)[color](update)
-    this.ora.start()
-  }
-
-  _modify(update: string, color = this.ora.color) {
-    this.ora.text = update
-    this.ora.color = color
-  }
-
-  step(text: string, method: string = 'succeed'): LogStep {
-    if (this.silent) {
-      return { modify() {}, log() {} }
-    }
-    if (!this.ora.id) {
-      this.ora.start().text = text
-      if (method !== 'succeed') {
-        this.ora[method]()
-      }
-    } else {
-      this.ora[method]().text = text
-      this.ora.start()
-    }
-
-    return {
-      modify: this.modify,
-      log: this.verbose ? this.write : this.modify
-    } as LogStep
-  }
-}
@@ -1,55 +0,0 @@
-import { compose, PromiseConfig, Middleware } from 'app-builder'
-import resource from './steps/resource'
-import { NexeCompiler } from './compiler'
-import {
-  argv,
-  nexeVersion as version,
-  normalizeOptionsAsync,
-  NexeOptions,
-  NexePatch
-} from './options'
-import cli from './steps/cli'
-import bundle from './steps/bundle'
-import download from './steps/download'
-import shim from './steps/shim'
-import artifacts from './steps/artifacts'
-import patches from './patches'
-import { rimrafAsync } from './util'
-import { NexeTarget } from './target'
-
-async function compile(
-  compilerOptions?: Partial<NexeOptions>,
-  callback?: (err: Error | null) => void
-) {
-  const options = await normalizeOptionsAsync(compilerOptions)
-  const compiler = new NexeCompiler(options)
-  const build = compiler.options.build
-
-  if (options.clean) {
-    let path = compiler.src
-    if (!options.build) {
-      path = compiler.getNodeExecutableLocation(compiler.options.targets[0] as NexeTarget)
-    }
-    const step = compiler.log.step('Cleaning up nexe build artifacts...')
-    step.log(`Deleting contents at: ${path}`)
-    await rimrafAsync(path)
-    step.log(`Deleted contents at: ${path}`)
-    return compiler.quit()
-  }
-
-  const buildSteps = build
-    ? [download, artifacts, ...patches, ...(options.patches as NexePatch[])]
-    : []
-  const nexe = compose(resource, bundle, cli, buildSteps, shim)
-  return callback
-    ? void nexe(compiler).then(
-        () => callback && callback(null),
-        (e: Error) => {
-          if (callback) callback(e)
-          else throw e
-        }
-      )
-    : nexe(compiler)
-}
-
-export { argv, compile, version }
@@ -1,246 +0,0 @@
-import * as parseArgv from 'minimist'
-import { NexeCompiler } from './compiler'
-import { isWindows, padRight } from './util'
-import { basename, extname, join, isAbsolute, relative, dirname } from 'path'
-import { getTarget, NexeTarget } from './target'
-import { EOL } from 'os'
-import * as c from 'chalk'
-
-export const nexeVersion = '2.0.0-rc.6'
-
-export interface NexePatch {
-  (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
-}
-
-export interface NexeOptions {
-  build: boolean
-  input: string
-  output: string
-  targets: (string | NexeTarget)[]
-  name: string
-  cwd: string
-  flags: string[]
-  configure: string[]
-  vcBuild: string[]
-  make: string[]
-  snapshot?: string
-  resources: string[]
-  temp: string
-  rc: { [key: string]: string }
-  enableNodeCli: boolean
-  bundle: boolean | string
-  patches: (string | NexePatch)[]
-  native: any
-  empty: boolean
-  sourceUrl?: string
-  python?: string
-  loglevel: 'info' | 'silent' | 'verbose'
-  silent?: boolean
-  fakeArgv?: boolean
-  verbose?: boolean
-  info?: boolean
-  ico?: string
-  debugBundle?: boolean
-  warmup?: string
-  compress?: boolean
-  clean?: boolean
-  /**
-   * Api Only
-   */
-  downloadOptions: any
-}
-
-const defaults = {
-  flags: [],
-  cwd: process.cwd(),
-  configure: [],
-  make: [],
-  targets: [],
-  vcBuild: isWindows ? ['nosign', 'release'] : [],
-  enableNodeCli: false,
-  compress: false,
-  build: false,
-  bundle: true,
-  patches: []
-}
-const alias = {
-  i: 'input',
-  o: 'output',
-  v: 'version',
-  t: 'target',
-  b: 'build',
-  n: 'name',
-  r: 'resource',
-  a: 'resource',
-  p: 'python',
-  f: 'flag',
-  c: 'configure',
-  m: 'make',
-  h: 'help',
-  l: 'loglevel',
-  'fake-argv': 'fakeArgv'
-}
-const argv = parseArgv(process.argv, { alias, default: defaults })
-const g = c.gray
-let help = `
-${c.bold('nexe <entry-file> [options]')}
-
-   ${c.underline.bold('Options:')}
-
-  -i   --input        ${g('=index.js')}       -- application entry point
-  -o   --output       ${g('=my-app.exe')}     -- path to output file
-  -t   --target       ${g('=8.4.0-x64')}      -- node version description
-  -n   --name         ${g('=my-app')}         -- main app module name
-
-  -r   --resource                     -- *embed files (glob) within the binary
-
-   ${c.underline.bold('Building from source:')}
-
-  -b   --build                        -- build from source
-  -p   --python                       -- python2 (as python) executable path
-  -f   --flag                         -- *v8 flags to include during compilation
-  -c   --configure                    -- *arguments to the configure step
-  -m   --make                         -- *arguments to the make/build step
-       --snapshot                     -- path to a warmup snapshot
-       --ico                          -- file name for alternate icon file (windows)
-       --rc-*                         -- populate rc file options (windows)
-       --sourceUrl                    -- pass an alternate source (node.tar.gz) url
-       --enableNodeCli                -- enable node cli enforcement (blocks app cli)
-
-   ${c.underline.bold('Other options:')}
-
-       --bundle                       -- custom bundling module with 'createBundle' export
-       --temp                         -- temp file storage default './nexe'
-       --cwd                          -- set the current working directory for the command
-       --fake-argv       TODO         -- fake argv[1] with entry file
-       --clean                        -- force download of sources
-       --silent                       -- disable logging
-       --verbose                      -- set logging to verbose
-
-       -* variable key name           * option can be used more than once`.trim()
-help = EOL + help + EOL
-
-function flatten(...args: any[]): string[] {
-  return ([] as string[]).concat(...args).filter(x => x)
-}
-
-/**
- * Extract keys such as { "rc-CompanyName": "Node.js" } to
- * { CompanyName: "Node.js" }
- * @param {*} match
- * @param {*} options
- */
-function extractCliMap(match: RegExp, options: any) {
-  return Object.keys(options)
-    .filter(x => match.test(x))
-    .reduce((map: { [key: string]: string }, option: keyof NexeOptions) => {
-      const key = option.split('-')[1]
-      map[key] = options[option]
-      delete options[option]
-      return map
-    }, {})
-}
-
-function tryResolveMainFileName(cwd: string) {
-  let filename
-  try {
-    const file = require.resolve(cwd)
-    filename = basename(file).replace(extname(file), '')
-  } catch (_) {}
-
-  if (filename === 'index' && basename(cwd)) {
-    return basename(cwd)
-  }
-
-  return filename ? filename : 'nexe_' + Date.now()
-}
-
-function extractLogLevel(options: NexeOptions) {
-  if (options.loglevel) return options.loglevel
-  if (options.silent) return 'silent'
-  if (options.verbose) return 'verbose'
-  return 'info'
-}
-
-function extractName(options: NexeOptions) {
-  let name = options.name
-  if (!name && typeof options.input === 'string') {
-    name = basename(options.input).replace(extname(options.input), '')
-  }
-  name = name === 'index' ? tryResolveMainFileName(options.cwd) : name
-
-  return name.replace(/\.exe$/, '')
-}
-
-function isEntryFile(filename: string) {
-  return filename && !isAbsolute(filename) && filename !== 'node' && /\.(tsx?|jsx?)$/.test(filename)
-}
-
-function findInput(input: string, cwd: string) {
-  const maybeInput = argv._.slice().pop() || ''
-  if (input) {
-    return input
-  }
-  if (isEntryFile(maybeInput)) {
-    return maybeInput
-  }
-  if (!process.stdin.isTTY) {
-    return ''
-  }
-  try {
-    const main = require.resolve(cwd)
-    return './' + relative(cwd, main)
-  } catch (e) {
-    void e
-  }
-  return ''
-}
-
-function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOptions | never> {
-  if (argv.help || argv._.some((x: string) => x === 'version') || argv.version === true) {
-    return new Promise(() => {
-      process.stderr.write(argv.help ? help : nexeVersion + EOL, () => process.exit(0))
-    })
-  }
-  const options = Object.assign({}, defaults, input) as NexeOptions
-  const opts = options as any
-
-  options.temp = process.env.NEXE_TEMP || join(options.cwd, '.nexe')
-  options.input = findInput(options.input, options.cwd)
-  options.name = extractName(options)
-  options.loglevel = extractLogLevel(options)
-  options.flags = flatten(opts.flag, options.flags)
-  options.targets = flatten(opts.target, options.targets).map(getTarget)
-  options.make = flatten(options.vcBuild, options.make)
-  options.configure = flatten(options.configure)
-  options.resources = flatten(opts.resource, options.resources)
-  options.rc = options.rc || extractCliMap(/^rc-.*/, options)
-
-  if (!options.targets.length) {
-    options.targets.push(getTarget())
-  }
-
-  if (options.build) {
-    const { arch } = options.targets[0] as NexeTarget
-    if (isWindows) {
-      options.make = Array.from(new Set(options.make.concat(arch)))
-    } else {
-      options.configure = Array.from(new Set(options.configure.concat([`--dest-cpu=${arch}`])))
-    }
-  }
-
-  options.patches = options.patches.map(x => {
-    if (typeof x === 'string') {
-      return require(x).default
-    }
-    return x
-  })
-
-  Object.keys(alias)
-    .filter(k => k !== 'rc')
-    .forEach(x => delete opts[x])
-
-  return Promise.resolve(options)
-}
-
-export { argv, normalizeOptionsAsync }
@@ -1,17 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function buildFixes(compiler: NexeCompiler, next: () => Promise<void>) {
-  if (!compiler.target.version.startsWith('8.2')) {
-    return next()
-  }
-
-  const file = await compiler.readFileAsync('./tools/msvs/find_python.cmd')
-
-  await compiler.replaceInFileAsync(
-    './tools/msvs/find_python.cmd',
-    '%p%python.exe -V 2>&1',
-    '"%p%python.exe" -V 2>&1'
-  )
-
-  return next()
-}
@@ -1,12 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function disableNodeCli(compiler: NexeCompiler, next: () => Promise<void>) {
-  if (compiler.options.enableNodeCli) {
-    return next()
-  }
-
-  const nodeccMarker = "argv[index][0] == '-'"
-
-  await compiler.replaceInFileAsync('src/node.cc', nodeccMarker, nodeccMarker.replace('-', ']'))
-  return next()
-}
@@ -1,16 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function flags(compiler: NexeCompiler, next: () => Promise<void>) {
-  const nodeflags = compiler.options.flags
-  if (!nodeflags.length) {
-    return next()
-  }
-
-  await compiler.replaceInFileAsync(
-    'node.gyp',
-    "'node_v8_options%': ''",
-    `'node_v8_options%': '${nodeflags.join(' ')}'`
-  )
-
-  return next()
-}
@@ -1,21 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function nodeGyp(
-  { files, replaceInFileAsync }: NexeCompiler,
-  next: () => Promise<void>
-) {
-  await next()
-
-  const nodeGypMarker = "'lib/fs.js',"
-  await replaceInFileAsync(
-    'node.gyp',
-    nodeGypMarker,
-    `
-    ${nodeGypMarker}
-    ${files
-      .filter(x => x.filename.startsWith('lib'))
-      .map(x => `'${x.filename}'`)
-      .toString()},
-  `.trim()
-  )
-}
@@ -1,12 +0,0 @@
-import { normalize } from 'path'
-import { readFileAsync } from '../util'
-import { NexeCompiler } from '../compiler'
-
-export default async function ico(compiler: NexeCompiler, next: () => Promise<void>) {
-  const iconFile = compiler.options.ico
-  if (!iconFile) {
-    return next()
-  }
-  await compiler.setFileContentsAsync('src/res/node.ico', await readFileAsync(normalize(iconFile)))
-  return next()
-}
@@ -1,12 +0,0 @@
-import gyp from './gyp'
-import nexePatches from './third-party-main'
-import buildFixes from './build-fixes'
-import cli from './disable-node-cli'
-import flags from './flags'
-import ico from './ico'
-import rc from './node-rc'
-import { NexeCompiler } from '../compiler'
-
-const patches = [gyp, nexePatches, buildFixes, cli, flags, ico, rc]
-
-export default patches
@@ -1,27 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function nodeRc(compiler: NexeCompiler, next: () => Promise<void>) {
-  const options = compiler.options.rc
-  if (!options) {
-    return next()
-  }
-
-  const file = await compiler.readFileAsync('src/res/node.rc')
-
-  Object.keys(options).forEach(key => {
-    let value = options[key]
-    const isVar = /^[A-Z_]+$/.test(value)
-    value = isVar ? value : `"${value}"`
-    file.contents = file.contents.replace(
-      new RegExp(`VALUE "${key}",*`),
-      `VALUE "${key}", ${value}`
-    )
-  })
-  ;['PRODUCTVERSION', 'FILEVERSION'].forEach(x => {
-    if (options[x]) {
-      file.contents = file.contents.replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`)
-    }
-  })
-
-  return next()
-}
@@ -1,19 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function snapshot(compiler: NexeCompiler, next: () => Promise<void>) {
-  const snapshotFile = compiler.options.snapshot
-  const warmupScript = compiler.options.warmup
-
-  if (!snapshotFile) {
-    return next()
-  }
-
-  await compiler.replaceInFileAsync(
-    'configure',
-    'def configure_v8(o):',
-    `def configure_v8(o):\n  o['variables']['embed_script'] = '${snapshotFile}'\n  o['variables']['warmup_script'] = '${warmupScript ||
-      snapshotFile}'`
-  )
-
-  return next()
-}
@@ -1,126 +0,0 @@
-import { NexeCompiler } from '../compiler'
-import { readFileSync } from 'fs'
-import { join } from 'path'
-
-export default async function main(compiler: NexeCompiler, next: () => Promise<void>) {
-  await compiler.setFileContentsAsync(
-    'lib/_third_party_main.js',
-    `
-const fs = require('fs')
-const path = require('path')
-const Buffer = require('buffer').Buffer
-const isString = x => typeof x === 'string' || x instanceof String
-
-const fd = fs.openSync(process.execPath, 'r')
-const size = fs.statSync(process.execPath).size
-const footer = Buffer.from(Array(32))
-fs.readSync(fd, footer, 0, 32, size - 32)
-
-if (!footer.slice(0, 16).equals(Buffer.from('<nexe~~sentinel>'))) {
-  throw 'Invalid Nexe binary'
-}
-
-const contentSize = footer.readDoubleLE(16)
-const resourceSize = footer.readDoubleLE(24)
-const contentStart = size - 32 - resourceSize - contentSize
-const resourceStart = contentStart + contentSize
-
-Object.defineProperty(process, '__nexe', (function () {
-  let nexeHeader = null
-  return {
-    get: function () {
-      return nexeHeader
-    },
-    set: function (value) {
-      if (nexeHeader) {
-        throw new Error('__nexe cannot be reconfigured')
-      }
-      nexeHeader = value
-      Object.freeze(nexeHeader)
-    },
-    enumerable: false,
-    configurable: false
-  }
-})());
-
-if (resourceSize) {
-  const originalReadFile = fs.readFile
-  const originalReadFileSync = fs.readFileSync
-  let setupManifest = () => {
-    const manifest = process.__nexe && process.__nexe.resources
-    if (!manifest) {
-      return
-    }
-    Object.keys(manifest).forEach((key) => {
-      const absolutePath = path.resolve(key)
-      if (!manifest[absolutePath]) {
-        manifest[absolutePath] = manifest[key]
-      }
-      const normalizedPath = path.normalize(key)
-      if (!manifest[normalizedPath]) {
-        manifest[normalizedPath] = manifest[key]
-      }
-    })
-    normalizeManifest = () => {}
-  };
-  fs.readFile = function readFile (file, options, callback) {
-    setupManifest()
-    const manifest = process.__nexe
-    const entry = manifest && manifest.resources[file]
-    if (!manifest || !entry || !isString(file)) {
-      return originalReadFile.apply(fs, arguments)
-    }
-    const [offset, length] = entry
-    const resourceOffset = resourceStart + offset
-    const encoding = isString(options) ? options : null
-    callback = typeof options === 'function' ? options : callback
-
-    fs.open(process.execPath, 'r', function (err, fd) {
-      if (err) return callback(err, null)
-      fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function (error, bytesRead, buffer) {
-        if (error) {
-          return fs.close(fd, function () {
-            callback(error, null)
-          })
-        }
-        fs.close(fd, function (err) {
-          if (err) {
-            return callback(err, buffer)
-          }
-          const result = Buffer.from(buffer.toString(), 'base64')
-          callback(err, encoding ? result.toString(encoding) : result)
-        })
-      })
-    })
-  }
-
-  fs.readFileSync = function readFileSync (file, options) {
-    setupManifest()
-    const manifest = process.__nexe
-    const entry = manifest && manifest.resources[file]
-    if (!manifest || !entry || !isString(file)) {
-      return originalReadFileSync.apply(fs, arguments)
-    }
-    const [offset, length] = entry
-    const resourceOffset = resourceStart + offset
-    const encoding = isString(options) ? options : null
-    const fd = fs.openSync(process.execPath, 'r')
-    const result = Buffer.alloc(length)
-    fs.readSync(fd, result, 0, length, resourceOffset)
-    fs.closeSync(fd)
-    const contents = Buffer.from(result.toString(), 'base64')
-    return encoding ? contents.toString(encoding) : contents
-  }
-}
-
-const contentBuffer = Buffer.from(Array(contentSize));
-fs.readSync(fd, contentBuffer, 0, contentSize, contentStart);
-fs.closeSync(fd);
-const Module = require('module');
-process.mainModule = new Module(process.execPath, null);
-process.mainModule.loaded = true;
-process.mainModule._compile(contentBuffer.toString(), process.execPath);
-`.trim()
-  )
-  return next()
-}
@@ -1,68 +0,0 @@
-import got = require('got')
-import download = require('download')
-import {
-  NodePlatform,
-  NodeArch,
-  platforms,
-  architectures,
-  NexeTarget,
-  getTarget,
-  targetsEqual
-} from './target'
-export { NexeTarget }
-
-export interface GitAsset {
-  name: string
-  url: string
-  browser_download_url: string
-}
-
-export interface GitRelease {
-  tag_name: string
-  assets_url: string
-  upload_url: string
-  assets: GitAsset[]
-}
-
-interface NodeRelease {
-  version: string
-}
-
-async function getJson<T>(url: string, options?: any) {
-  return JSON.parse((await got(url, options)).body) as T
-}
-
-//TODO only build the latest of each major...?
-function isBuildableVersion(version: string) {
-  const major = +version.split('.')[0]
-  return !~[0, 1, 2, 3, 4, 5, 7].indexOf(major) || version === '4.8.4'
-}
-
-export function getLatestGitRelease(options?: any) {
-  return getJson<GitRelease>('https://api.github.com/repos/nexe/nexe/releases/latest', options)
-}
-
-export async function getUnBuiltReleases(options?: any) {
-  const nodeReleases = await getJson<NodeRelease[]>(
-    'https://nodejs.org/download/release/index.json'
-  )
-  const existingVersions = (await getLatestGitRelease(options)).assets.map(x => getTarget(x.name))
-
-  const versionMap: { [key: string]: true } = {}
-  return nodeReleases
-    .reduce((versions: NexeTarget[], { version }) => {
-      version = version.replace('v', '').trim()
-      if (!isBuildableVersion(version) || versionMap[version]) {
-        return versions
-      }
-      versionMap[version] = true
-      platforms.forEach(platform => {
-        architectures.forEach(arch => {
-          if (arch === 'x86' && platform === 'mac') return
-          versions.push(getTarget({ platform, arch, version }))
-        })
-      })
-      return versions
-    }, [])
-    .filter(x => !existingVersions.some(t => targetsEqual(t, x)))
-}
@@ -1,70 +0,0 @@
-import { join, dirname } from 'path'
-import { readdir, unlink } from 'fs'
-import { readFileAsync, writeFileAsync, isDirectoryAsync } from '../util'
-import * as mkdirp from 'mkdirp'
-import { NexeCompiler } from '../compiler'
-import pify = require('pify')
-
-const mkdirpAsync = pify(mkdirp)
-const unlinkAsync = pify(unlink)
-const readdirAsync = pify(readdir)
-
-function readDirAsync(dir: string): Promise<string[]> {
-  return readdirAsync(dir).then(paths => {
-    return Promise.all(
-      paths.map((file: string) => {
-        const path = join(dir, file)
-        return isDirectoryAsync(path).then(x => (x ? readDirAsync(path) : path as any))
-      })
-    ).then(result => {
-      return [].concat(...(result as any))
-    })
-  })
-}
-
-function maybeReadFileContentsAsync(file: string) {
-  return readFileAsync(file, 'utf-8').catch(e => {
-    if (e.code === 'ENOENT') {
-      return ''
-    }
-    throw e
-  })
-}
-
-/**
- * The artifacts step is where source patches are committed, or written as "artifacts"
- * Steps:
- *  - A temporary directory is created in the downloaded source
- *  - On start, any files in that directory are restored into the source tree
- *  - After the patch functions have run, the temporary directory is emptied
- *  - Original versions of sources to be patched are written to the temporary directory
- *  - Finally, The patched files are written into source.
- *
- */
-export default async function artifacts(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { src } = compiler
-  const temp = join(src, 'nexe')
-  await mkdirpAsync(temp)
-  const tmpFiles = await readDirAsync(temp)
-
-  await Promise.all(
-    tmpFiles.map(async path => {
-      return compiler.writeFileAsync(path.replace(temp, ''), await readFileAsync(path, 'utf-8'))
-    })
-  )
-
-  await next()
-
-  await Promise.all(tmpFiles.map(x => unlinkAsync(x)))
-  return Promise.all(
-    compiler.files.map(async file => {
-      const sourceFile = join(src, file.filename)
-      const tempFile = join(temp, file.filename)
-      const fileContents = await maybeReadFileContentsAsync(sourceFile)
-
-      await mkdirpAsync(dirname(tempFile))
-      await writeFileAsync(tempFile, fileContents)
-      await compiler.writeFileAsync(file.filename, file.contents)
-    })
-  )
-}
@@ -1,60 +0,0 @@
-import { NexeCompiler } from '../compiler'
-import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } from 'fuse-box'
-import { readFileAsync, writeFileAsync } from '../util'
-import { resolve } from 'path'
-import NativeModulePlugin from '../bundling/fuse-native-module-plugin'
-import { NexeOptions } from '../options'
-
-function createBundle(options: NexeOptions) {
-  const plugins: any = [JSONPlugin(), CSSPlugin(), HTMLPlugin(), NativeModulePlugin(options.native)]
-  if (options.compress) {
-    plugins.push(
-      QuantumPlugin({
-        target: 'server',
-        uglify: true,
-        bakeApiIntoBundle: options.name
-      })
-    )
-  }
-  const fuse = FuseBox.init({
-    cache: false,
-    log: Boolean(process.env.NEXE_BUNDLE_LOG) || false,
-    homeDir: options.cwd,
-    sourceMaps: false,
-    writeBundles: false,
-    output: '$name.js',
-    target: 'server',
-    plugins
-  })
-  fuse.bundle(options.name).instructions(`> ${options.input}`)
-  return fuse.run().then(x => {
-    let output = ''
-    x.bundles.forEach(y => (output = y.context.output.lastPrimaryOutput.content!.toString()))
-    return output
-  })
-}
-
-export default async function bundle(compiler: NexeCompiler, next: any) {
-  if (!compiler.options.bundle) {
-    compiler.input = await readFileAsync(compiler.options.input, 'utf-8')
-    return next()
-  }
-
-  if (compiler.options.empty || !compiler.options.input) {
-    compiler.input = ''
-    return next()
-  }
-
-  let producer = createBundle
-  if (typeof compiler.options.bundle === 'string') {
-    producer = require(resolve(compiler.options.cwd, compiler.options.bundle)).createBundle
-  }
-
-  compiler.input = await producer(compiler.options)
-
-  if ('string' === typeof compiler.options.debugBundle) {
-    await writeFileAsync(compiler.options.debugBundle, compiler.input)
-  }
-
-  return next()
-}
@@ -1,67 +0,0 @@
-import { normalize } from 'path'
-import { Readable } from 'stream'
-import { createWriteStream, chmodSync } from 'fs'
-import { readFileAsync, dequote, isWindows } from '../util'
-import { NexeCompiler } from '../compiler'
-import { NexeTarget } from '../target'
-
-function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
-  return new Promise(resolve => {
-    let input = ''
-    stream.setEncoding('utf-8')
-    stream.on('data', (x: string) => {
-      input += x
-    })
-    stream.once('end', () => resolve(dequote(input)))
-    stream.resume && stream.resume()
-  })
-}
-
-/**
- * The "cli" step detects the appropriate input. If no input options are passed,
- * the package.json#main file is used.
- * After all the build steps have run, the output (the executable) is written to a file or piped to stdout.
- *
- * Configuration:
- *   - compiler.options.input - file path to the input bundle.
- *     - fallbacks: stdin, package.json#main
- *   - compiler.options.output - file path to the output executable.
- *     - fallbacks: stdout, nexe_ + epoch + ext
- *
- * @param {*} compiler
- * @param {*} next
- */
-export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { output } = compiler.options
-  const { log, input: bundledInput } = compiler
-
-  if (!process.stdin.isTTY) {
-    log.step('Using stdin as input')
-    compiler.input = await readStreamAsync(process.stdin)
-  }
-
-  await next()
-
-  compiler.output = isWindows
-    ? `${(output || compiler.options.name).replace(/\.exe$/, '')}.exe`
-    : `${output || compiler.options.name}`
-
-  const target = compiler.options.targets.shift() as NexeTarget
-  const deliverable = await compiler.compileAsync(target)
-
-  return new Promise((resolve, reject) => {
-    const step = log.step('Writing result to file')
-    deliverable
-      .pipe(createWriteStream(normalize(compiler.output!)))
-      .on('error', reject)
-      .once('close', (e: Error) => {
-        if (e) {
-          reject(e)
-        } else if (compiler.output) {
-          chmodSync(compiler.output, '755')
-          step.log(`Executable written to: ${compiler.output}`)
-          resolve(compiler.quit())
-        }
-      })
-  })
-}
@@ -1,45 +0,0 @@
-import download = require('download')
-import { pathExistsAsync } from '../util'
-import { LogStep } from '../logger'
-import { IncomingMessage } from 'http'
-import { NexeCompiler } from '../compiler'
-import { NexeTarget } from '../target'
-
-function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options = {}) {
-  const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
-  return download(url, dest, Object.assign(options, { extract: true, strip: 1 }))
-    .on('response', (res: IncomingMessage) => {
-      const total = +res.headers['content-length']!
-      let current = 0
-      res.on('data', data => {
-        current += data.length
-        setText(current / total * 100)
-        if (current === total) {
-          step.log('Extracting Node...')
-        }
-      })
-    })
-    .then(() => step.log(`Node source extracted to: ${dest}`))
-}
-
-/**
- * Downloads the node source to the configured temporary directory
- * @param {*} compiler
- * @param {*} next
- */
-export default async function downloadNode(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { src, log, targets: [{ version }] } = compiler
-  const { sourceUrl, downloadOptions } = compiler.options
-  const url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`
-  const step = log.step(`Downloading Node.js source from: ${url}`)
-  if (await pathExistsAsync(src)) {
-    step.log('Source already downloaded')
-    return next()
-  }
-
-  if (compiler.options.build) {
-    await fetchNodeSourceAsync(src, url, step, downloadOptions)
-  }
-
-  return next()
-}
@@ -1,32 +0,0 @@
-import { readFileAsync, isDirectoryAsync, each } from '../util'
-import { Buffer } from 'buffer'
-import * as globs from 'globby'
-import { NexeCompiler } from '../compiler'
-
-export default async function resource(compiler: NexeCompiler, next: () => Promise<void>) {
-  const resources = compiler.resources
-
-  if (!compiler.options.resources.length) {
-    return next()
-  }
-  const step = compiler.log.step('Bundling Resources...')
-  let count = 0
-  await each(globs(compiler.options.resources), async file => {
-    if (await isDirectoryAsync(file)) {
-      return
-    }
-    count++
-    step.log(`Including file: ${file}`)
-    const contents = await readFileAsync(file)
-    const commentSafeContents = contents.toString('base64')
-    resources.index[file] = [
-      Buffer.byteLength(resources.bundle),
-      Buffer.byteLength(commentSafeContents)
-    ]
-    resources.bundle += commentSafeContents
-  })
-  step.log(
-    `Included ${count} file(s). ${(Buffer.byteLength(resources.bundle) / 1e6).toFixed(3)} MB`
-  )
-  return next()
-}
@@ -1,18 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default function(compiler: NexeCompiler, next: () => Promise<void>) {
-  if (!compiler.options.fakeArgv) {
-    return next()
-  }
-
-  const nty = !process.stdin.isTTY
-  const input = nty ? '[stdin]' : compiler.options.input
-
-  compiler.input =
-    `!(() => {
-    var r = require('path').resolve;
-    process.argv.splice(1,0, ${nty ? `'${input}'` : `r("${input}")`});
-  })();` + compiler.input
-
-  return next()
-}
@@ -1,90 +0,0 @@
-export type NodePlatform = 'windows' | 'mac' | 'alpine' | 'linux'
-export type NodeArch = 'x86' | 'x64'
-
-const platforms: NodePlatform[] = ['windows', 'mac', 'alpine', 'linux'],
-  architectures: NodeArch[] = ['x86', 'x64']
-
-export { platforms, architectures }
-
-export interface NexeTarget {
-  version: string
-  platform: NodePlatform | string
-  arch: NodeArch | string
-}
-
-//TODO bsd
-const prettyPlatform: { [key: string]: NodePlatform } = {
-  win32: 'windows',
-  windows: 'windows',
-  win: 'windows',
-  darwin: 'mac',
-  macos: 'mac',
-  mac: 'mac',
-  linux: 'linux',
-  static: 'alpine',
-  alpine: 'alpine'
-}
-
-//TODO arm
-const prettyArch: { [key: string]: NodeArch } = {
-  x86: 'x86',
-  ia32: 'x86',
-  x32: 'x86',
-  x64: 'x64'
-}
-
-function isVersion(x: string) {
-  if (!x) {
-    return false
-  }
-  return /^[\d]+$/.test(x.replace(/v|\.|\s+/g, ''))
-}
-
-function isPlatform(x: string): x is NodePlatform {
-  return x in prettyPlatform
-}
-
-function isArch(x: string): x is NodeArch {
-  return x in prettyArch
-}
-
-class Target implements NexeTarget {
-  constructor(public arch: NodeArch, public platform: NodePlatform, public version: string) {}
-  toJSON() {
-    return this.toString()
-  }
-  toString() {
-    return `${this.platform}-${this.arch}-${this.version}`
-  }
-}
-
-export function targetsEqual(a: NexeTarget, b: NexeTarget) {
-  return a.arch === b.arch && a.platform === b.platform && a.version === b.version
-}
-
-export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget {
-  let arch = process.arch as NodeArch,
-    platform = prettyPlatform[process.platform],
-    version = process.version.slice(1)
-
-  if (typeof target !== 'string') {
-    target = `${target.platform}-${target.arch}-${target.version}`
-  }
-
-  target
-    .toLowerCase()
-    .split('-')
-    .forEach(x => {
-      if (isVersion(x)) {
-        version = x.replace(/v/g, '')
-      }
-      if (isPlatform(x)) {
-        platform = prettyPlatform[x]
-      }
-      if (isArch(x)) {
-        arch = prettyArch[x]
-      }
-    })
-
-  return new Target(arch, platform, version)
-}
@@ -1,23 +0,0 @@
-declare module 'got' {
-  interface GotFn {
-    (url: string, options?: any): Promise<{ body: string }>
-    stream(url: string, optoins?: any): any
-  }
-  function got(url: string, options?: any): Promise<{ body: string }>
-  export = got as GotFn
-}
-declare module 'download' {
-  import { Duplex } from 'stream'
-  interface DownloadOptions {
-    extract?: boolean
-    strip?: number
-    filename?: string
-    proxy?: string
-  }
-  function download(
-    url: string,
-    destination?: string | DownloadOptions,
-    options?: DownloadOptions
-  ): PromiseLike<Buffer> & Duplex
-  export = download
-}
@@ -1,73 +0,0 @@
-import { readFile, writeFile, stat } from 'fs'
-import { execFile } from 'child_process'
-import pify = require('pify')
-import rimraf = require('rimraf')
-
-const rimrafAsync = pify(rimraf)
-
-export async function each<T>(
-  list: T[] | Promise<T[]>,
-  action: (item: T, index: number, list: T[]) => Promise<any>
-) {
-  const l = await list
-  for (let i = 0; i < l.length; i++) {
-    await action(l[i], i, l)
-  }
-}
-
-function falseOnEnoent(e: any) {
-  if (e.code === 'ENOENT') {
-    return false
-  }
-  throw e
-}
-
-function padRight(str: string, l: number) {
-  return (str + ' '.repeat(l)).substr(0, l)
-}
-
-function dequote(input: string) {
-  input = input.trim()
-  const singleQuote = input.startsWith("'") && input.endsWith("'")
-  const doubleQuote = input.startsWith('"') && input.endsWith('"')
-  if (singleQuote || doubleQuote) {
-    return input.slice(1).slice(0, -1)
-  }
-  return input
-}
-
-export interface ReadFileAsync {
-  (path: string): Promise<Buffer>
-  (path: string, encoding: string): Promise<string>
-}
-
-const readFileAsync = pify(readFile)
-const writeFileAsync = pify(writeFile)
-const statAsync = pify(stat)
-const execFileAsync = pify(execFile)
-const isWindows = process.platform === 'win32'
-
-function pathExistsAsync(path: string) {
-  return statAsync(path)
-    .then(x => true)
-    .catch(falseOnEnoent)
-}
-
-function isDirectoryAsync(path: string) {
-  return statAsync(path)
-    .then(x => x.isDirectory())
-    .catch(falseOnEnoent)
-}
-
-export {
-  dequote,
-  padRight,
-  isWindows,
-  rimrafAsync,
-  statAsync,
-  execFileAsync,
-  readFileAsync,
-  pathExistsAsync,
-  isDirectoryAsync,
-  writeFileAsync
-}
@@ -1,105 +0,0 @@
-import * as nexe from '../src/nexe'
-import {
-  getUnBuiltReleases,
-  getLatestGitRelease
-} from '../src/releases'
-import * as ci from './ci'
-import { runAlpineBuild } from './docker'
-import { getTarget } from '../src/target'
-import { pathExistsAsync, statAsync, readFileAsync, execFileAsync } from '../src/util'
-import got = require('got')
-
-const env = process.env,
-  branchName = env.CIRCLE_BRANCH || env.APPVEYOR_REPO_BRANCH || env.TRAVIS_BRANCH || '',
-  isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD || env.NEXE_TRIGGERED),
-  isLinux = Boolean(env.CIRCLECI),
-  isWindows = Boolean(env.APPVEYOR),
-  isMac = Boolean(env.TRAVIS),
-  isPullRequest = Boolean(env.CIRCLE_PR_NUMBER)
-    || Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) 
-    || Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
-  headers = { 
-    'Authorization': 'token ' + env.GITHUB_TOKEN,
-    'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
-  }
-
-if (require.main === module) {
-  if (!isPullRequest) {
-    build().catch(x => {
-      console.error(x)
-      process.exit(1)
-    })
-  }
-}
-
-async function build () {
-  if (isScheduled) {
-    const releases = await getUnBuiltReleases({ headers })
-    if (!releases.length) {
-      return
-    }
-    const windowsBuild = releases.find(x => x.platform === 'windows')
-    const macBuild = releases.find(x => x.platform === 'mac')
-    const linuxOrAlpine = releases.find(x => x.platform === 'linux' || x.platform === 'alpine')
-
-    if (linuxOrAlpine) {
-      await ci.triggerDockerBuild(linuxOrAlpine, branchName)
-    }
-    if (macBuild) {
-      await ci.triggerMacBuild(macBuild, branchName)
-    }
-    if (windowsBuild) {
-      await ci.triggerWindowsBuild(windowsBuild)
-    }
-  }
-
-  if (env.NEXE_VERSION) {
-    const
-      target = getTarget(env.NEXE_VERSION),
-      output = isWindows ? './out.exe' : './out',
-      options = {
-        empty: true,
-        build: true,
-        target,
-        output
-      }
-    
-    const stop = keepalive()
-    if (target.platform === 'alpine') {
-      await runAlpineBuild(target, nexe.version.split('.')[0])
-    } else {
-      await nexe.compile(options)      
-    }
-    stop()
-    
-    
-    if (await pathExistsAsync(output)) {
-      await assertNexeBinary(output)
-      const gitRelease = await getLatestGitRelease({ headers })
-      await got(gitRelease.upload_url.split('{')[0], {
-        query: { name: target.toString() },
-        body: await readFileAsync(output),
-        headers: {
-          'Authorization': 'token ' + env.GITHUB_TOKEN,
-          'Content-Type': 'application/octet-stream',
-          'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
-        }
-      })
-      console.log(target + ' uploaded.')
-    }
-  }
-}
-
-function keepalive () {
-  const keepalive = setInterval(() => console.log('Building...'), 300 * 1000)
-  return () => clearInterval(keepalive)
-}
-
-function assertNexeBinary (file: string) {
-  return execFileAsync(file).catch(e => {
-    if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
-      return
-    }
-    throw e
-  })
-}
@@ -1,48 +0,0 @@
-import { NexeTarget } from '../src/releases'
-import got = require('got')
-import * as assert from 'assert'
-const { env } = process
-
-export function triggerMacBuild(release: NexeTarget, branch: string) {
-  assert.ok(env.TRAVIS_TOKEN)
-  const travis = `https://api.travis-ci.org/repo/nexe%2Fnexe/requests`
-  return got(travis, {
-    json: true,
-    body: {
-      request: {
-        branch: branch,
-        config: {
-          merge_mode: 'deep_merge',
-          env: {
-            NEXE_VERSION: release.toString()
-          }
-        }
-      }
-    },
-    headers: {
-      'Travis-API-Version': '3',
-      'Authorization': `token ${env.TRAVIS_TOKEN}`
-    }
-  })
-}
-
-export function triggerDockerBuild (release: NexeTarget, branch: string) {
-  assert.ok(env.CIRCLE_TOKEN)
-  const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/${branch}?circle-token=${env.CIRCLE_TOKEN}`
-  return got(circle, {
-    json: true,
-    body: {
-      build_parameters: {
-        NEXE_VERSION: release.toString()
-      }
-    }
-  })
-}
-
-export function triggerWindowsBuild (release: NexeTarget) {
-  const hasVersion = 'NEXE_VERSION' in env
-  env.NEXE_VERSION = hasVersion 
-    ? env.NEXE_VERSION!.trim() 
-    : release.toString() 
-  return Promise.resolve()
-}
@@ -1,73 +0,0 @@
-import { NexeTarget } from '../src/target'
-import { writeFileAsync, readFileAsync } from '../src/util'
-import { spawn } from 'child_process'
-import got = require('got')
-import { createWriteStream, WriteStream } from 'fs'
-
-function alpine (target: NexeTarget, nexeVersion: string) {  
-  return `
-FROM i386/alpine:3.4
-RUN apk add --no-cache curl make gcc g++ binutils-gold python linux-headers paxctl libgcc libstdc++ git vim tar gzip wget
-ENV NODE_VERSION=${target.version}
-ENV NEXE_VERSION=beta
-WORKDIR /
-
-RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
-  cd /node-v\${NODE_VERSION} && \
-  ./configure --prefix=/usr --fully-static && \
-  make -j$(getconf _NPROCESSORS_ONLN) && \
-  make install && \
-  paxctl -cm /usr/bin/node
-
-RUN mkdir /nexe_temp && mv node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
-  npm install -g nexe@\${NEXE_VERSION} && \
-  nexe --build --empty --temp /nexe_temp -c="--fully-static" -o out
-`.trim()
-}
-
-export async function runAsync (command: string, output: WriteStream) {
-  const commands = command.split(/\r?\n/)
-    .filter(x => x.trim())
-    .map(x => x.trim().split(' '))
-  const sequence = Promise.resolve()
-  for (const command of commands) {
-    await new Promise((resolve, reject) => {
-      const cp = spawn(command.shift() as string, command)
-      cp.stderr.pipe(output)
-      cp.stdout.pipe(output)
-      const close = function (this: any, e: Error) {
-        this.kill()
-        e ? reject(e) : resolve()
-      }
-      cp.on('error', (e) => {
-        output.write(e.stack)
-      })
-      .on('close', close)
-      .on('exit', close)
-    })
-  }
-}
-
-export async function runAlpineBuild (target: NexeTarget, nexeVersion: string) {
-  await writeFileAsync('Dockerfile', alpine(target, nexeVersion))
-  const outFilename = 'nexe-alpine-build-log.txt'
-  const output = createWriteStream(outFilename)
-  try {
-    await runAsync(`
-    docker build -t nexe-alpine .
-    docker run -d --name nexe nexe-alpine sh
-    docker cp nexe:/out out
-    docker rm nexe
-  `, output)
-  } catch(e) {
-    console.log(e)
-  } finally {
-    output.close()
-    await got(`https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`, {
-      body: await readFileAsync(outFilename),
-      method: 'PUT'
-    })
-    .then(x => console.log(x.body))
-    .catch(e => console.log('Error posting log', e))
-  }
-}
@@ -1,3 +0,0 @@
--check-leaks
--require ts-node/register
--recursive
@@ -1,28 +0,0 @@
-import { padRight, isWindows } from '../src/util'
-import { expect } from 'chai'
-import { blue as b } from 'chalk'
-import { getTarget, NexeTarget } from '../src/target'
-
-const arch = process.arch === 'ia32' ? 'x86' : process.arch
-
-describe('Targets', () => {
-  [
-    ['win-ia32-6.11.2', 'windows-x86-6.11.2'],
-    [{ version: '6.11.2', platform: 'win', arch: 'ia32' }, 'windows-x86-6.11.2'],
-    ['win32-x64-6.11.2', 'windows-x64-6.11.2'],
-    ['darwin-x64-v8.4.0', 'mac-x64-8.4.0'],
-    ['static-x86-6.10.3', 'alpine-x86-6.10.3'],
-    ['linux-x32', `linux-x86-${process.version.slice(1)}`],
-    ['alpine-notsupported-6.10.3', `alpine-${arch}-6.10.3`],
-    ['not-a-thing', getTarget(process).toString()]
-  ].forEach(([input, expected]) => {
-    it(`should accept: ${padRight(JSON.stringify(input), 53)} ${b('->')}   ${expected}`, () => {
-      expect(getTarget(input).toString()).to.equal(expected)
-    })
-  })
-
-  it ('should stringify and toString', () => {
-    expect(JSON.stringify(getTarget(process))).to.equal(`"${getTarget(process)}"`)
-  })
-})
-
@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target":"es5",
-    "lib": ["es2017"],
-    "module": "commonjs",
-    "outDir": "./lib",
-    "strict": true
-  },
-  "include":[
-    "src/**/*.ts"
-  ]
-}
Author	SHA1	Message	Date
Jared Allard	5dc698be9d	minor comsetic logging fix. vbump to v0.4.1	2015-08-09 08:42:18 -07:00
Jared Allard	1bf334399b	fix second run issues with --flag enabled. better error handling	2015-08-09 08:32:18 -07:00
Jared Allard	a30db5fc5d	package: finally got around to adding contrib	2015-06-29 10:41:16 -07:00
Jared Allard	77cfcf0da4	retarget 2.3.1 for nexe	2015-06-26 18:36:26 -07:00
Jared Allard	d8541a82ac	readme: note on output.	2015-06-26 18:30:35 -07:00
Jared Allard	489bd0f0fe	exe: fixes #122 , implement base nexe package field	2015-06-26 18:27:26 -07:00
Jared Allard	a3f30bf783	nexe: vbump / remove devdepends	2015-06-26 15:30:02 -07:00
Jared Allard	61ff0b1052	changelog: maintainer fix	2015-06-19 21:49:15 -07:00
Jared Allard	e02d39a6bf	manifest: async 0.9.0 => 1.2.1	2015-06-19 21:46:00 -07:00
Jared Allard	ca414f03db	readme: author update	2015-06-19 21:43:23 -07:00
Jared Allard	4200724316	readme: clairify that all platforms require python	2015-05-31 11:53:07 -07:00
Jared Allard	686f67fac2	readme: clairify building requirements.	2015-05-31 11:50:54 -07:00
RainbowDashDC	494618cca1	nexe: vbump and dependencies.	2015-05-01 13:29:42 -07:00
Jared Allard	86fe200bfd	Merge pull request #114 from shivamadhavan/master Updated version of dependency builtins to 1.0.1 ( inclusion of console to the built in module list )	2015-04-16 21:11:54 -07:00
Shiva Kumar Madhavan	c272f52994	Updated version of dependency builtins to 1.0.1 ( inclusion of console to the built in module list )	2015-04-16 17:17:08 +08:00
Craig Jefferds	93ed48a537	Merge pull request #111 from lahdekorpi/patch-1 Fixed typo in README.md	2015-03-30 08:51:44 -07:00
Toni Lähdekorpi	740e3f441d	Fixed typo in README.md	2015-03-30 18:51:18 +03:00
Jared Allard	8204feadaa	Add 'readline' not include rule. For some reason nexe attempts to include readline, this solves it. readline is a bultin of node as of 10	2015-03-20 22:08:31 -07:00
Jared Allard	cdf53e133b	Update README.md Fixing a spelling mistake. Ugh.	2015-03-20 10:55:09 -07:00
Jared Allard	65c07d4e4a	Update README to show new feature	2015-03-20 09:26:30 -07:00
Jared Allard	4c3443655e	Merge pull request #108 from crcn/iojs Implement io.js support! And a few fixes	2015-03-20 09:20:39 -07:00
RainbowDashDC	6d20d4da22	Fixes #107 , implements --framework/-F. Fetchs iojs latest.	2015-03-19 23:50:48 -07:00
RainbowDashDC	b72b14b6c3	Initial iojs support.	2015-03-16 10:36:39 -07:00
Jared Allard	9134bcf351	Add waffle.io board label	2015-03-08 20:49:52 -07:00
Christopher Karper	1c0d8d0fc0	Freshened up all dependencies	2015-02-22 21:32:59 -05:00
Christopher Karper	a7c3fda721	Updated deps	2015-02-22 15:05:47 -05:00
Christopher Karper	7d75480a6f	Renamed relative to absolute	2015-02-21 19:42:04 -05:00
Christopher Karper	67361b27e1	Update README.md Added myself as a maintainer.	2015-02-21 19:35:17 -05:00
Christopher Karper	3b6f9ff4b7	This was bothering me...	2015-02-21 19:02:16 -05:00
RainbowDashDC	6fcfb10e38	Update changelog for 0.3.6 and 0.3.7	2015-02-21 01:32:20 -05:00
RainbowDashDC	06cab4f43b	Publish new version to hopefully fix #103	2015-02-21 01:16:34 -05:00
Craig Jefferds	2cacd8340b	Update README.md	2015-02-18 14:18:47 -08:00
Craig Jefferds	0e90ac9f16	Update README.md	2015-02-18 14:18:29 -08:00
Jared Allard	efd3f78c9d	Merge pull request #102 from gitter-badger/gitter-badge Add a Gitter chat badge to README.md	2015-02-18 13:40:14 -08:00
The Gitter Badger	54967d1ab0	Added Gitter badge	2015-02-18 19:35:28 +00:00
RainbowDashDC	bb489a3cb7	Fixes #98 by giving win32 a 100 length progress bar.	2015-02-15 19:38:35 -08:00
Jared Allard	6097c20204	Merge pull request #101 from CKarper/master Lighter weight way to accomplish the exclusion of the sys module	2015-02-15 15:00:05 -08:00
Christopher Karper	39665a8d5c	Lighter weight way to accomplish the exclusion of the sys module	2015-02-15 17:51:05 -05:00
Jared Allard	f49ece0c86	Merge pull request #100 from CKarper/master Stub to ignore require('sys')	2015-02-15 12:57:05 -08:00
Christopher Karper	5aca22d28e	This handles embedding 'bin' scripts with shebang interpreter directives at the start	2015-02-15 15:02:58 -05:00
Christopher Karper	e79b0fb23e	Stub to ignore require('sys')	2015-02-15 14:52:40 -05:00
RainbowDashDC	cac698609c	V bump to solve critical error.	2015-02-15 11:10:34 -08:00
RainbowDashDC	b040337a94	Fixes #99 , resolves #97 by warning on missing file. New examples. New log functions	2015-02-15 11:05:24 -08:00
Jared Allard	06d7730802	Merge pull request #96 from CKarper/patch-1 Support .json extensions in require() resolution	2015-02-15 07:39:13 -08:00
Christopher Karper	ad4da1d193	Support .json extensions in require() resolution Embarrassingly simple fix. Added .json to the list of extensions to search when a require with no extension is found. This resolves #57	2015-02-15 00:33:28 -05:00
RainbowDashDC	5927b45e70	Add changelog.md, add resourceFiles to example, MIT-LICENSE.txt => LICENSE.txt	2015-02-14 19:53:30 -08:00
RainbowDashDC	e4155c8fed	Version bump 0.3.5, update depends	2015-02-14 09:44:49 -08:00
RainbowDashDC	e91f5b52af	Add example, fix outdated examples	2015-02-14 01:57:54 -08:00
RainbowDashDC	3b1d5a9fe1	Modify readme, implement cross-plat --python <loc> closes #94	2015-02-14 01:50:32 -08:00
Jared Allard	3ac298fe4f	Merge pull request #95 from LorenzGardner/master Make process.argv consistent in the child fork case	2015-02-09 17:46:51 -08:00
Lorenz Gardner	229f0516c6	Merge branch 'master' of https://github.com/LorenzGardner/nexe	2015-02-09 16:06:29 -06:00
Lorenz Gardner	29d5f6aaeb	Make process.argv consistent in the child fork cas (argv.[0] must = the executable)	2015-02-09 16:05:09 -06:00
LorenzGardner	174599df30	Merge pull request #2 from crcn/master Pull in changes to master	2015-02-09 15:56:29 -06:00
Jared Allard	3ca6bbbda2	Merge pull request #93 from LorenzGardner/embedFiles Embed files	2015-01-31 18:56:18 -08:00
Lorenz Gardner	97dbd37068	Add support for embedded files.	2015-01-06 19:05:01 -06:00
Lorenz Gardner	b615e125c0	Make the example code demonstrate forked process and dynamic require	2015-01-05 17:58:57 -06:00
LorenzGardner	c34f6719b5	Merge pull request #1 from crcn/master update	2014-12-30 12:07:37 -06:00
Craig Jefferds	2342fe6fdd	Merge pull request #92 from LorenzGardner/child.fork Add child_process.fork support.	2014-12-23 19:59:18 -03:00
LorenzGardner	333cc697c3	update read me mentioning usage of child_process.fork	2014-12-23 12:16:49 -06:00
Lorenz Gardner	ece4b2d62a	Add child_process.fork support.	2014-12-23 12:01:33 -06:00
Craig Jefferds	ba62973dca	Merge pull request #88 from LorenzGardner/master Add support for JSON files, and __dirname	2014-12-19 16:05:25 -08:00
LorenzGardner	9b5892e6ad	clarify workaround for native module support	2014-12-19 14:23:40 -06:00
Lorenz Gardner	f7ad9a8e83	It actually makes way more sense for __driname to be exectuable dir rather than the cwd.	2014-12-18 18:02:48 -06:00
LorenzGardner	7c1331bed8	Update README.md update the readme to explain how to workaround the limitations (not supporting dynamic require statements and lack of native module support the pseudo support of __dirname)	2014-12-18 17:46:55 -06:00
Lorenz Gardner	e55dacf8c8	Merge branch 'JSON-Support' Conflicts: lib/bundle.js	2014-12-18 17:02:29 -06:00
Lorenz Gardner	ec79ff85d4	add __dirname support	2014-12-17 18:52:04 -06:00
Lorenz Gardner	99a8cbe9b3	Add JSON support for require statments.	2014-12-17 13:09:00 -06:00
LorenzIndus	f458298ffb	update version of builtins in deps Get the fix they did to include the "constants" builtin module.	2014-12-17 08:48:01 -06:00
Craig Jefferds	c3fa94a2e5	Merge pull request #83 from rknell/patch-1 Update README.md	2014-11-04 14:41:23 -08:00
rknell	961f72b1d9	Update README.md Adding missing comma to example	2014-11-05 07:57:53 +10:00
Craig Jefferds	d91d91fc2b	Merge pull request #82 from RainbowDashDC/master Prevent Windows Paths from causing issues.	2014-10-27 18:21:34 -07:00
Jared Allard	273bfa3e4d	Prevent Windows Paths from causing issues.	2014-10-27 15:14:55 -07:00
Craig Condon	31b01469c7	v bump	2014-10-10 09:23:51 -07:00
Craig Condon	b94d0c3719	Merge branch 'master' of github.com:crcn/nexe	2014-10-10 09:23:31 -07:00
Craig Condon	275a7b025b	fix issue loading native modules	2014-10-10 09:23:20 -07:00
Craig Jefferds	71d7b97736	Update README.md	2014-09-19 12:09:10 -07:00
Craig Jefferds	faf0a85b36	Merge pull request #78 from tm1000/patch-1 Update README.md	2014-09-16 11:31:11 -07:00
Craig Jefferds	56578c09b1	Merge pull request #79 from tm1000/patch-2 Remove all non-ascii code from external sources	2014-09-16 11:31:01 -07:00
Andrew Nagy	6ad1ec436c	Remove all non-ascii code from external sources Remove all non-ascii code from external sources	2014-09-16 10:32:45 -07:00
Andrew Nagy	62461dbc41	Update README.md Fix the documentation :-)	2014-09-12 16:14:04 -07:00
Craig Jefferds	7f34aa8854	Merge pull request #74 from caffeinewriter/replace-yargs Replace optimist with yargs	2014-08-29 19:13:00 -07:00
Brandon Anzaldi	76072f6df9	Replace optimist with yargs in nexe bin	2014-08-29 18:44:52 -07:00
Brandon Anzaldi	83daa5553b	Replace Optimist with Yargs in Package.json	2014-08-29 18:43:06 -07:00
Craig Condon	ff09ef6755	cleanup	2014-08-10 23:46:38 -07:00
Craig Condon	85c8831248	include all node.js builtins	2014-08-10 23:32:01 -07:00
Craig Condon	3d2ae606ef	v bump	2014-07-30 12:22:50 -07:00
Craig Condon	d4f27aea7f	filter http	2014-07-30 12:22:37 -07:00
Craig Condon	87abd1a295	remove commented out code	2014-07-30 11:38:16 -07:00
Craig Condon	9fd462da2f	v bump	2014-07-30 11:37:20 -07:00
Craig Condon	60849404a2	remove sardines - move into nexe. Use bundle.js	2014-07-30 11:37:05 -07:00
Craig Condon	00fa37fff0	start on using browserify	2014-07-30 11:12:20 -07:00
Craig Condon	270350fda6	fix #48 - ability to just run ----> bundle /Users/craig/Developer/Public/nexe/lib/index.js unable to include script /Users/craig/Developer/Public/nexe/lib/exe.js from /Users/craig/Developer/Public/nexe/lib/index.js, Error: Cannot find module 'nexe' at Function.module.exports [as sync] (/Users/craig/Developer/Public/nexe/node_modules/sardines/node_modules/amdify/node_modules/resolve/lib/sync.js:32:11) at resolvePath (/Users/craig/Developer/Public/nexe/node_modules/sardines/node_modules/amdify/lib/pathInfo.js:135:20) at self.getPathInfo (/Users/craig/Developer/Public/nexe/node_modules/sardines/node_modules/amdify/lib/pathInfo.js:88:24) at /Users/craig/Developer/Public/nexe/node_modules/sardines/node_modules/amdify/lib/analyzeDeps.js:324:13 at /Users/craig/Developer/Public/nexe/node_modules/async/lib/async.js:111:13 at Array.forEach (native) at _each (/Users/craig/Developer/Public/nexe/node_modules/async/lib/async.js:32:24) at Object.async.each (/Users/craig/Developer/Public/nexe/node_modules/async/lib/async.js:110:9) at scanRequired (/Users/craig/Developer/Public/nexe/node_modules/sardines/node_modules/amdify/lib/analyzeDeps.js:321:9) at Function.on.success.deps.forEach.dep.source (/Users/craig/Developer/Public/nexe/node_modules/sardines/node_modules/amdify/lib/analyzeDeps.js:245:5) in cwd. Resolves package.json main script	2014-05-28 10:47:52 -07:00
Craig Condon	dd2aa5a831	Merge pull request #55 from fritx/patch-1 Update README.md	2014-05-28 10:28:08 -07:00
Fritz Lin	afc7140b6b	Update README.md Better style with Code Usage in README.md	2014-05-28 22:02:28 +08:00
Craig Condon	1d47091304	v bump	2014-05-13 11:42:44 -07:00
Craig Condon	36bbdd4aa9	Merge pull request #52 from jhbruhn/master Windows support	2014-05-12 14:40:28 -07:00
Jan-Henrik	e73804a4dd	Added Windows support to Readme	2014-05-12 20:33:04 +02:00
Jan-Henrik	bd1152357e	Added Windows Support using vcbuild.bat	2014-05-12 20:29:02 +02:00
Craig Condon	c53f229848	added progress to package.json	2014-03-06 11:28:00 -08:00
Craig Condon	3cb81249d8	Merge pull request #46 from northshorenetworks/master Updated README.md	2014-02-28 19:43:16 -08:00
Adam Snodgrass	518fbc7280	Updated README.md	2014-02-28 21:40:59 -06:00
Craig Condon	dd5607886a	Merge pull request #45 from northshorenetworks/master Remove duplicate _log definition in monkeypatch.js	2014-02-28 19:39:44 -08:00
Adam Snodgrass	666774b5b5	Remove duplicate _log definition	2014-02-28 21:35:56 -06:00
Adam Snodgrass	3f75ae462e	Merge pull request #2 from crcn/master Pull in crcn/nexe master changes	2014-02-28 21:33:12 -06:00
Craig Condon	dacb31fd67	Merge pull request #44 from northshorenetworks/master Add option to pass through CLI flags but ignore node and v8 flags	2014-02-28 19:31:00 -08:00
Adam Snodgrass	d4e62c668e	Add option to disable node and v8 flags and pass through app flags	2014-02-28 21:16:38 -06:00
Craig Condon	b267d9ba41	fix typo	2014-02-28 19:01:16 -08:00
Adam Snodgrass	75932723ac	Added progress to package.json dependencies; Defined _log in monkeypatch.js	2014-02-28 18:54:38 -06:00
Adam Snodgrass	28442e6714	Merge pull request #1 from crcn/master Pull in crcn/nexe master changes	2014-02-28 18:14:51 -06:00
Craig Condon	9bb3b76a65	remove old file	2014-02-28 10:46:43 -08:00
Craig Condon	6702ce326a	resolve merge conflict	2014-02-28 10:40:07 -08:00
Craig Condon	27075a778d	move utils to their own file	2014-02-28 10:39:13 -08:00
Craig Condon	368195be77	Update README.md	2014-02-28 10:33:18 -08:00
Craig Condon	b11ce7540c	Update README.md	2014-02-28 10:23:52 -08:00
Craig Condon	069c910b7b	Update README.md	2014-02-28 10:23:40 -08:00
Craig Condon	934c7bb3d5	Update README.md	2014-02-28 10:23:04 -08:00
Craig Condon	8c8a1eddd7	Update README.md	2014-02-28 10:21:27 -08:00
Craig Condon	3eea6784dd	Update README.md	2014-02-28 10:21:17 -08:00
Craig Condon	cef44e9b77	Update README.md	2014-02-28 10:20:53 -08:00
Craig Condon	b6f555c223	Merge pull request #42 from northshorenetworks/master Add platform detection for openbsd & freebsd compatibility	2014-02-28 10:17:06 -08:00
Adam Snodgrass	87cacafd3e	Add platform detection for openbsd & freebsd compatibility	2014-02-27 23:08:33 -08:00
Craig Condon	9caa365a3e	Merge branch 'master' of github.com:crcn/nexe	2014-02-27 16:49:56 -08:00
Craig Condon	e7e80f5a2c	refactor	2014-02-27 16:49:35 -08:00
Craig Condon	4284c399dd	Merge pull request #36 from tallesl/issue35 Solves #35	2013-12-12 22:18:07 -08:00
Talles L	89eeeda575	Solves #35	2013-12-13 03:25:03 -02:00
Craig Condon	3b1b82dc40	cleanup	2013-10-14 10:40:46 -07:00
Craig Condon	a9a97fefe1	download latest version	2013-10-14 10:29:35 -07:00
Craig Condon	12a7069a32	v bump	2013-10-14 10:26:47 -07:00
Craig Condon	533ed8c500	Merge branch 'master' of github.com:crcn/nexe	2013-10-14 10:25:57 -07:00
Craig Condon	875d6d0ff7	update node version	2013-10-14 10:25:46 -07:00
Craig Condon	ea2cfdf5ee	Merge pull request #32 from samyakbhuta/master Installing 'nexe' globally.	2013-10-14 10:22:52 -07:00
Samyak Bhuta	60ebde86cc	Added preference for global install.	2013-10-14 18:47:33 +05:30
Samyak Bhuta	d927887355	'nexe', can be installed globally.	2013-10-14 16:28:08 +05:30
Craig Condon	04280a3016	Merge pull request #29 from alexwhitman/node-argv Unshift 'node' onto process.argv	2013-08-18 10:36:51 -07:00
Alex Whitman	3c084b9573	Unshift 'node' onto process.argv The node executable is the first value in argv. This was missing after compiling.	2013-08-18 18:16:23 +01:00
Craig Condon	708851cc40	Merge pull request #28 from alexwhitman/fixup Linting, spawning and temp directory	2013-08-17 08:37:59 -07:00
Alex Whitman	2214dccd4a	Add `temp` option to README	2013-08-17 12:40:00 +01:00
Alex Whitman	ca9fced819	Add `-t\|--temp` option to specify location for node.js sources	2013-08-17 12:04:38 +01:00
Alex Whitman	684b285217	Rewrite configure/make spawning	2013-08-17 11:36:03 +01:00
Alex Whitman	1dc6243b75	Fix up linting warnings - Mix of tabs and spaces - Trailing whitepsace - Missing semi-colons	2013-08-17 10:31:55 +01:00
Craig Condon	f1a8a7269f	fix #26 - should resolve to absolute path unless / is the first character	2013-07-26 13:40:54 -07:00
Craig Condon	4e8830365e	added mit license	2013-06-04 14:32:26 -07:00
Craig Condon	34e6f79096	update readme	2013-04-29 12:41:14 -07:00
Craig Condon	e58e22a329	updated example	2013-04-09 13:52:47 -07:00
Craig Condon	4866e04c13	replace browserify with sardines	2013-04-09 13:37:45 -07:00
Craig Condon	bedcdfe26f	v bump	2013-02-27 11:27:10 -08:00
Craig Condon	5fe8618236	added ability to use -h or --help for help menu	2013-02-27 11:26:44 -08:00
Craig Condon	127377a92b	properly parse relative path	2013-02-01 11:39:52 -08:00
Craig Condon	d6a083778a	cleanup	2013-02-01 11:39:32 -08:00
Craig Condon	a52eae6665	Merge branch 'master' of github.com:crcn/nexe	2013-02-01 11:37:03 -08:00
Craig Condon	75ecf22ba9	properly parse relative path	2013-02-01 11:36:47 -08:00
Craig Condon	7f444e93de	Update README.md	2013-02-01 11:30:47 -08:00
Craig Condon	818da103a8	added dependency	2013-01-31 12:19:14 -08:00
Craig Condon	b565aaafc0	Update README.md	2012-12-02 12:08:10 -06:00
Craig Condon	67282e2506	remove node modules	2012-11-30 20:17:44 -06:00
Craig Condon	3c432a0d3a	cleanup	2012-11-30 20:16:17 -06:00
Craig Condon	a831244c3d	finally works	2012-11-30 20:12:56 -06:00
Craig Condon	ad5532eaad	finally works	2012-11-30 20:11:55 -06:00
Craig Condon	8b03984ca8	fix package repo	2012-02-17 14:54:58 -06:00
Craig Condon	953d57240f	update pkg	2011-11-30 12:55:16 -06:00
Craig Condon	dfb751ca12	updated readme	2011-11-26 17:34:11 -06:00
Craig Condon	0813ef0f67	typo	2011-11-26 17:30:50 -06:00
Craig Condon	1e12cad040	can build node.js file from cwd now	2011-11-26 17:30:13 -06:00
Craig Condon	015b60ee24	can build node.js file from cwd now	2011-11-26 17:24:25 -06:00
Craig Condon	66d3454129	updated readme	2011-11-26 17:03:30 -06:00
Craig Condon	b385069ebb	updated readme	2011-11-26 17:03:08 -06:00
Craig Condon	51879ed636	updated readme	2011-11-26 17:01:47 -06:00
Craig Condon	c018684658	ability to build executables	2011-11-26 17:00:12 -06:00
				`@@ -1 +0,0 @@`
				`export * from './fuse-native-module-plugin'`