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
80 changed files with 1457 additions and 5219 deletions
@@ -0,0 +1,4 @@
+[commands]
+proj = subl .
+.DS_Store
+
@@ -1,8 +0,0 @@
-root = true
-[*]
-end_of_line = lf
-charset = utf-8
-indent_style = space
-indent_size = 2
-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,5 +0,0 @@
-{
-    "recommendations": [
-      "esbenp.prettier-vscode"
-    ]
-}
@@ -1,6 +0,0 @@
-{
-  "typescript.tsdk": "./node_modules/typescript/lib",
-  "prettier.semi": false,
-  "prettier.singleQuote": true,
-  "prettier.typescriptEnable": ["typescript"]
-}
@@ -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
-  * New Resource access
-  * stdin and stdout interfaces
-  * Opt-in 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,196 +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/jaredallard/nexe"><img src="https://img.shields.io/circleci/project/jaredallard/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@beta -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

- Supports production ready, ([securable](#security)) builds
+### 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 (Beta)
+## Building Requirements

-*Note: V2 API is still subject to change. * For v1 see [V1-EOL](https://github.com/nexe/nexe/tree/V1-EOL)
+- Linux / Mac / BSD / Windows
+- Python 2.6 or 2.7 (use --python if not in PATH)
+- Windows: Visual Studio 2010+

- Existing application bundle:
+## Caveats

-    `nexe -i ./my-app-bundle.js -o ./my-app.exe`
+### Doesn't support native modules

- stdin interface
+- 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.

-  `rollup -c | nexe --resource ./public/**/* -o my-app.exe`
-
-For more CLI options see: `nexe --help`
-
-## Including Additional Resources
-
-Additional 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, some users may want to customize the way node is built, either by changing the flags, providing a different icon, or different executable details. These options are supported out of the box, and subsequent builds with compatible options will result in instant build times.
-
-Nexe also exposes its patching pipeline to the user. This allows the application of simple patching of node sources prior to compilation.
-
-## Node.js API
-
-Using Nexe Programatically
-
-#### Example
+### Doesn't support dynamic require statements

+Such As:

 ```javascript
-const nexe = require('nexe')
-
-nexe.compile({
-  input: './my-app-bundle.js'
-  output: './my-app.exe'
-  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);
 ```

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

- - #### `build: boolean`
-    - Build node from source (required in beta)
- - #### `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`
-    - Dash seperated platform-architecture-version. e.g. `'win32-ia32-6.10.3'`
-    - default: `[process.platform, process.arch, process.version.slice(1)].join('-')`
- #### `bundle: string`
-    - Path to a custom bundling function. When executed it should either return a fusebox producer, or a string.
-    - If it is a string it will be required and the export `nexeBundle` will be used
-    - Defaults to the internal fuse-box configuration
- - #### `name: string`
-    - Module friendly name of the application
-    - default: basename of the input file, or `nexe_${Date.now()}`
- - #### `version: string`
-    - The Node version you're building for
-    - default: `process.version.slice(1)`
- - #### `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: Array<string>`
-    - Array of node runtime flags to build node with.
-    - Example: `['--expose-gc']`
-    - default: `[]`
- - #### `configure: Array<string>`
-    - Array of arguments for the node build configure step
-    - Example: `['--with-dtrace', '--dest-cpu=x64']`
-    - default: `[]`
- - #### `make: Array<string>`
-    - Array of arguments for the node build make step
-    - default: `[]`
- - #### `vcBuild: Array<string>`
-    - Array of arguments for the node build step on windows
-    - default: `['nosign', 'release']`
- - #### `snapshot: string`
-    - path to a file to be used as the warmup snapshot for the build
-    - default: `null`
- - #### `resources: Array<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 accompanying configuration and exit
- - #### `enableNodeCli: boolean`
-    - Enable the original Node CLI (will prevent application cli from working)
-    - default: `false`
- - #### `sourceUrl: string`
-    - Provide an alternate url for the node source. Should be a `.tar.gz`
- - #### `loglevel: string`
-    - Set the loglevel, info, silent, or verbose
-    - default: `'info'`
- - #### `padding`
-    - Advanced option for controlling the size available in the executable.
-    - It must be larger than the bundle + resources in bytes
-    - default: 3, 6, 9, 16, 25, or 40 MB sizes are selected automatically.
- - #### `patches: Array<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<SourceFile>`
-    - Access (or create) a file within the downloaded Node.js source.
- - `files: Array<SourceFile>`
-    - The cache of 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.

-#### `SourceFile`
-  - `contents: 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 `SourceFile#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 [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`

-Future: 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

-## Security
-A common use case for Nexe is production deployment. When distributing executables it is important to [sign](https://en.wikipedia.org/wiki/Code_signing) them before distributing. Nexe was designed specifically to not mangle the binary it produces, this allows the checksum and signature of the size and location offsets to be maintained through the code signing process.
+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)
@@ -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);
+			}
+		}
+	);
+}
@@ -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,23 +0,0 @@
-const { FuseBox } = require('fuse-box')
-const nexe = '../..'
-const { NativeModulePlugin } = require(nexe + '/lib/bundling/fuse')
-const fuse = FuseBox.init({
-  homeDir: './',
-  cache: false,
-  log: true,
-  debug: true,
-  output: '$name.js',
-  plugins: [
-    new NativeModulePlugin({
-      zmq: {
-        additionalFiles: [
-          '../../windows/lib/x64/libzmq-v100-mt-4_0_4.dll'
-        ]
-      }
-    })
-  ]
-})
-fuse.bundle('app')
-    .target('electron')
-    .instructions(`> index.js`)
-fuse.run()
@@ -1,19 +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)
-console.log('global', global.require.main)
-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,18 +0,0 @@
-{
-  "name": "native-build",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "bundle": "node build",
-    "build-windows": "nexe -i app.js -o app.exe"
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "zmq": "^2.15.3"
-  },
-  "devDependencies": {
-    "fuse-box": "^2.2.1-beta.7"
-  }
-}
@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-const nexe = require('./lib/nexe')
-
-module.exports = nexe
-
-if (require.main === module) {
-  nexe.compile(nexe.argv).catch((e) => {
-    process.stderr.write(e.message, () => process.exit(1))
-  })
-}
@@ -1,22 +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,58 +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-beta.4",
+  "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": {
-    "prebuild": "rimraf lib && npm run lint",
-    "prepublish": "npm run build",
-    "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"
-  ],
-  "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",
-    "bluebird": "^3.5.0",
-    "chalk": "^1.1.3",
-    "download": "^6.2.0",
-    "fuse-box": "^2.2.1",
-    "globby": "^6.1.0",
-    "memory-fs": "^0.4.1",
-    "minimist": "^1.2.0",
-    "mkdirp": "^0.5.1",
-    "nigel": "^2.0.2",
-    "ora": "^1.2.0",
-    "rimraf": "^2.6.1",
-    "tar": "^3.1.3"
+    "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/bluebird": "^3.5.8",
-    "@types/chalk": "^0.4.31",
-    "@types/globby": "^0.6.0",
-    "@types/minimist": "^1.2.0",
-    "@types/mkdirp": "^0.3.29",
-    "@types/ora": "^0.3.31",
-    "@types/rimraf": "0.0.28",
-    "mocha": "^3.2.0",
-    "prettier": "^1.4.4",
-    "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,62 +0,0 @@
-import { join, dirname } from 'path'
-import { readdir, unlink } from 'fs'
-import { readFileAsync, writeFileAsync, isDirectoryAsync } from './util'
-import { promisify, map } from 'bluebird'
-import * as mkdirp from 'mkdirp'
-import { NexeCompiler } from './compiler'
-
-const mkdirpAsync = promisify(mkdirp)
-const unlinkAsync = (promisify(unlink) as any) as (path: string) => PromiseLike<void>
-const readdirAsync = promisify(readdir)
-
-function readDirAsync(dir: string): PromiseLike<string[]> {
-  return readdirAsync(dir)
-    .map((file: string) => {
-      const path = join(dir, file)
-      return isDirectoryAsync(path).then((x: boolean) => (x ? readDirAsync(path) : path as any))
-    })
-    .reduce((a: string[], b: string[] | string) => a.concat(b), [])
-}
-
-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 map(tmpFiles, async path => {
-    return compiler.writeFileAsync(path.replace(temp, ''), await readFileAsync(path, 'utf-8'))
-  })
-
-  await next()
-
-  await map(tmpFiles, x => unlinkAsync(x))
-  return map(compiler.files, 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,92 +0,0 @@
-import * as fs from 'fs'
-import * as path from 'path'
-import * as child from 'child_process'
-
-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
-
-  isRequireBindings(node: any) {
-    return node.callee.name === 'require' && node.arguments[0].value === 'bindings'
-  }
-
-  onNode(absolutePath: string, node: any, parent: any) {
-    if (node.type === 'CallExpression') {
-      if (this.isRequireBindings(node) && 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.isRequireBindings(node) && 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,137 +0,0 @@
-import { BindingsRewrite } from './bindings-rewrite'
-import { createHash } from 'crypto'
-import { readFileSync } from 'fs'
-import { dirname, join, basename } from 'path'
-
-function hashName(name: string | Buffer) {
-  return createHash('md5').update(name).digest('hex').toString().slice(0, 8)
-}
-
-export interface FuseBoxFile {
-  info: { absPath: string }
-  absPath: string
-  contents: string
-  analysis: {
-    dependencies: string[]
-    requiresRegeneration: boolean
-  }
-  loadContents(): void
-  makeAnalysis(
-    parsingOptions?: any,
-    traversalPlugin?: {
-      plugins: Array<{
-        onNode(file: FuseBoxFile, node: any, parent: any): void
-        onEnd(file: FuseBoxFile): void
-      }>
-    }
-  ): void
-}
-
-export interface NativeModulePluginOptions {
-  [key: string]:
-    | {
-        additionalFiles: string[]
-      }
-    | true
-}
-
-export default function(options: NativeModulePluginOptions) {
-  return new NativeModulePlugin(options)
-}
-
-export class NativeModulePlugin {
-  public test: RegExp
-  public limit2Project = false
-  private modules: (keyof NativeModulePluginOptions)[]
-
-  constructor(public options: NativeModulePluginOptions) {
-    this.modules = Object.keys(options)
-    this.test = new RegExp(`node_modules\/(${Object.keys(options).join('|')}).*\.js|\.node$`)
-  }
-
-  init(context: any) {
-    context.allowExtension('.node')
-  }
-
-  transform(file: FuseBoxFile) {
-    file.loadContents()
-
-    if (file.absPath.endsWith('.node')) {
-      const contents = readFileSync(file.absPath)
-      const module = this.modules.find(x =>
-        Boolean(~file.absPath.indexOf(join('node_modules', x)))
-      )!
-      const bindingName = basename(file.absPath)
-      const settings = this.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 === 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 = readFileSync(join(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)
-      `
-      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,31 +0,0 @@
-import { NexeCompiler } from '../compiler'
-import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin } from 'fuse-box'
-import NativeModulePlugin from './fuse'
-
-function bundleProducer(filename: string) {
-  const fuse = FuseBox.init({
-    cache: false,
-    log: Boolean(process.env.NEXE_BUNDLE_DEBUG) || false,
-    homeDir: './',
-    writeBundles: false,
-    target: 'server',
-    plugins: [JSONPlugin(), CSSPlugin(), HTMLPlugin()]
-  })
-  fuse.bundle('nexe').instructions(`> ${filename}`)
-  return fuse.run().then(x => {
-    if (x.bundles.size > 1) {
-      console.log('THROW', x.bundles)
-    }
-    let output = ''
-    x.bundles.forEach(y => (output = y.context.output.lastPrimaryOutput.content!.toString()))
-  })
-}
-
-export default function bundle(compiler: NexeCompiler, next: any) {
-  if (!compiler.options.bundle) {
-    return next()
-  }
-
-  if (typeof compiler.options.bundle === 'string') {
-  }
-}
@@ -1,73 +0,0 @@
-import { normalize } from 'path'
-import * as Bluebird from 'bluebird'
-import { Readable } from 'stream'
-import { createWriteStream, chmodSync } from 'fs'
-import { readFileAsync, dequote, isWindows } from './util'
-import { NexeCompiler } from './compiler'
-
-function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
-  return new Bluebird(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 whether the process is in a tty. If it is then the input is read into memory.
- * Otherwise, it is buffered from stdin. If no input options are passed in the tty, 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 { input, output } = compiler.options
-  const { log } = compiler
-  if (!input && !process.stdin.isTTY) {
-    log.step('Using stdin as input')
-    compiler.input = await readStreamAsync(process.stdin)
-  } else if (input) {
-    log.step(`Using input file as the main module: ${input}`)
-    compiler.input = await readFileAsync(normalize(input), 'utf-8')
-  } else if (!compiler.options.empty) {
-    const bundle = require.resolve(process.cwd())
-    log.step("Using the cwd's main file as the main module")
-    compiler.input = await readFileAsync(bundle, 'utf-8')
-  } else {
-    log.step('Using empty input as the main module')
-    compiler.input = ''
-  }
-
-  compiler.input = compiler.input.trim()
-  await next()
-
-  compiler.output = output || `${compiler.options.name}${isWindows ? '.exe' : ''}`
-  const deliverable = await compiler.compileAsync()
-
-  return new Bluebird((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,285 +0,0 @@
-import { normalize, join } from 'path'
-import * as Bluebird from 'bluebird'
-import { Buffer } from 'buffer'
-import { createHash } from 'crypto'
-import { createReadStream } from 'fs'
-import { Readable } from 'stream'
-import { spawn } from 'child_process'
-import { Stream as Needle } from 'nigel'
-import { Logger } from './logger'
-import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows } from './util'
-import { NexeOptions } from './options'
-
-const isBsd = Boolean(~process.platform.indexOf('bsd'))
-const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
-const configure = isWindows ? 'configure' : './configure'
-const marker = Buffer.from('<nexe~sentinel>').toString('hex')
-const tail = `\n//${marker}`
-const needle = Buffer.from(marker)
-const fixedIntegerLength = 10
-const padLeft = (x: string | number, l = fixedIntegerLength, c = '0') => (c.repeat(l) + x).slice(-l)
-const inflate = (value: string, size: number) => {
-  if (!size || value.length >= size) {
-    return value
-  }
-  return value + ' '.repeat(size - value.length)
-}
-
-export interface NexeFile {
-  filename: string
-  contents: string
-}
-
-interface NexeHeader {
-  /**
-   * Zero padded number indicating the extra size available in the binary
-   */
-  paddingSize: string
-  /**
-   *
-   */
-  binaryOffset: string
-  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 = join(this.options.temp, this.options.version)
-  public files: NexeFile[] = []
-  public input: string
-  public output: string | null
-
-  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 = isWindows
-    ? join(this.src, 'Release', 'node.exe')
-    : join(this.src, 'out', 'Release', 'node')
-
-  constructor(public options: NexeOptions) {
-    const { python } = (this.options = options)
-
-    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) {
-        cachedFile = {
-          filename: file,
-          contents: await readFileAsync(join(this.src, file), 'utf-8').catch(
-            { code: 'ENOENT' },
-            () => ''
-          )
-        }
-        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(code = 0) {
-    const time = Date.now() - this.start
-    this.log.write(`Finsihed in ${time / 1000}s`)
-    return this.log.flush().then(x => process.exit(code))
-  }
-
-  private _findPaddingSize(size: number, override = this.options.padding) {
-    if (override === 0) {
-      return 0
-    }
-    size = override > size ? override : size
-    const padding = [3, 6, 9, 16, 25, 40].map(x => x * 1e6).find(p => size <= p)
-    if (!padding) {
-      throw new Error(
-        `No prebuilt target large enough (${(size / 1024).toFixed(
-          2
-        )}Mb).\nUse the --build flag and build for the current platform`
-      )
-    }
-    return padding
-  }
-
-  private _getNodeExecutableLocation(target?: string | null) {
-    if (target) {
-      return join(this.options.temp, target)
-    }
-    return this.nodeSrcBinPath
-  }
-
-  private _runBuildCommandAsync(command: string, args: string[]) {
-    return new Bluebird((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}`)
-    await this._configureAsync()
-    const buildOptions = isWindows ? this.options.vcBuild : this.options.make
-    this.compileStep.log(`Compiling Node with arguments: ${buildOptions}`)
-    await this._runBuildCommandAsync(make, buildOptions)
-    return createReadStream(this._getNodeExecutableLocation())
-  }
-
-  private _fetchPrebuiltBinaryAsync() {
-    return this._buildAsync()
-  }
-
-  private _getPayload(header: NexeHeader) {
-    return this._serializeHeader(header) + this.input + '/**' + this.resources.bundle + `**/`
-  }
-
-  private _generateHeader() {
-    const zeros = padLeft(0)
-    const version =
-      ['configure', 'vcBuild', 'make'].reduce((a, c) => {
-        return (a += (this.options as any)[c].slice().sort().join())
-      }, '') + this.options.enableNodeCli
-    const header = {
-      version: padLeft(0, 32),
-      resources: this.resources.index,
-      contentSize: zeros,
-      paddingSize: zeros,
-      resourceOffset: zeros,
-      binaryOffset: zeros
-    }
-    const serializedHeader = this._serializeHeader(header)
-    header.contentSize = padLeft(Buffer.byteLength(this._getPayload(header)))
-    header.paddingSize = padLeft(this._findPaddingSize(+header.contentSize))
-    header.resourceOffset = padLeft(Buffer.byteLength(serializedHeader + this.input + '/**'))
-    header.version = createHash('md5').update(version + header.paddingSize).digest('hex')
-    return header
-  }
-
-  private async _getExistingBinaryHeaderAsync(target: string | undefined | null) {
-    const filename = this._getNodeExecutableLocation(target)
-    const existingBinary = await pathExistsAsync(filename)
-    if (existingBinary) {
-      return this._extractHeaderAsync(filename)
-    }
-    return null
-  }
-
-  private _extractHeaderAsync(path: string): Promise<NexeHeader> {
-    const binary = createReadStream(path)
-    const haystack = new Needle(needle)
-    let needles = 0
-    let stackCache: Buffer[] = []
-    return new Promise((resolve, reject) => {
-      binary
-        .on('error', reject)
-        .pipe(haystack)
-        .on('error', reject)
-        .on('close', () => reject(new Error(`Binary: ${path} is not compatible with nexe`)))
-        .on('haystack', (x: Buffer) => needles && stackCache.push(x))
-        .on('needle', () => {
-          if (++needles === 2) {
-            resolve(JSON.parse(Buffer.concat(stackCache).toString()))
-            binary.close()
-            haystack.end()
-          }
-        })
-    })
-  }
-
-  private _serializeHeader(header: NexeHeader) {
-    return `/**${marker}${JSON.stringify(header)}${marker}**/process.__nexe=${JSON.stringify(
-      header
-    )};`
-  }
-
-  async setMainModule(compiler: NexeCompiler, next: () => Promise<void>) {
-    await next()
-    const header = compiler._generateHeader()
-    const contents = inflate(this._getPayload(header), +header.paddingSize) + tail
-    const file = await compiler.readFileAsync('lib/_third_party_main.js')
-    file.contents += '\n' + contents
-  }
-
-  async compileAsync() {
-    const step = (this.compileStep = this.log.step('Compiling result'))
-    let target = this.options.targets.slice().shift()
-    let prebuiltBinary = null
-    const header = this._generateHeader()
-    target = target && `${target}-${header.version.slice(0, 6)}`
-    step.log(`Scanning existing binary...`)
-    const existingHeader = await this._getExistingBinaryHeaderAsync(target)
-    if (existingHeader && existingHeader.version === header.version) {
-      const location = this._getNodeExecutableLocation(target)
-      step.log(`Source already built: ${location}`)
-      prebuiltBinary = createReadStream(location)
-    }
-    if (target) {
-      throw new Error('\nNot Implemented, use --build during beta\n')
-      // prebuiltBinary = await this._fetchPrebuiltBinaryAsync(target)
-    }
-    if (!prebuiltBinary) {
-      prebuiltBinary = await this._buildAsync()
-      step.log('Node binary compiled')
-    }
-    return this._assembleDeliverable(header, prebuiltBinary)
-  }
-
-  private _assembleDeliverable(header: NexeHeader, binary: NodeJS.ReadableStream) {
-    const haystack = new Needle(Buffer.concat([Buffer.from('/**'), needle]))
-    const artifact = new Readable({ read() {} })
-    let needles = 0
-    let currentStackSize = 0
-    binary.pipe(haystack)
-    haystack
-      .on('close', () => artifact.push(null))
-      .on('needle', () => ++needles && haystack.needle(needle))
-      .on('haystack', (x: Buffer) => {
-        if (!needles) {
-          currentStackSize += x.length
-          artifact.push(x)
-        }
-        if (needles === 1 && !+header.binaryOffset) {
-          header.binaryOffset = padLeft(currentStackSize)
-          const content = Buffer.from(inflate(this._getPayload(header), +header.paddingSize) + tail)
-          artifact.push(content)
-        }
-        if (needles > 2) {
-          artifact.push(x)
-        }
-      })
-    return artifact
-  }
-}
@@ -1,40 +0,0 @@
-import download = require('download')
-import { isDirectoryAsync } from './util'
-import { LogStep } from './logger'
-import { IncomingMessage } from 'http'
-import { NexeCompiler } from './compiler'
-
-function fetchNodeSourceAsync(cwd: string, url: string, step: LogStep, options = {}) {
-  const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
-  return download(url, cwd, 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: ${cwd}`))
-}
-
-/**
- * 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 } = compiler
-  const { version, 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 isDirectoryAsync(src)) {
-    step.log('Source already downloaded')
-    return next()
-  }
-
-  return fetchNodeSourceAsync(src, url, step, downloadOptions).then(next)
-}
@@ -1,65 +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): LogStep {
-    if (this.silent) {
-      return { modify() {}, log() {} }
-    }
-    if (!this.ora.id) {
-      this.ora.start().text = text
-    } else {
-      this.ora.succeed().text = text
-      this.ora.start()
-    }
-
-    return {
-      modify: this.modify,
-      log: this.verbose ? this.write : this.modify
-    } as LogStep
-  }
-}
@@ -1,32 +0,0 @@
-import { compose, PromiseConfig, Middleware } from 'app-builder'
-import resource from './resource'
-import { NexeCompiler } from './compiler'
-import { argv, normalizeOptionsAsync, NexeOptions } from './options'
-import cli from './cli'
-import download from './download'
-import artifacts from './artifacts'
-import patches from './patches'
-import { rimrafAsync } from './util'
-import * as Bluebird from 'bluebird'
-
-PromiseConfig.constructor = Bluebird
-
-async function compile(compilerOptions: NexeOptions, callback?: (err: Error | null) => void) {
-  const options = await normalizeOptionsAsync(compilerOptions)
-  const compiler = new NexeCompiler(options)
-  const build = compiler.options.build
-
-  if (options.clean) {
-    const step = compiler.log.step('Cleaning up nexe build artifacts...')
-    step.log(`Deleting directory and contents at: ${compiler.src}`)
-    await rimrafAsync(compiler.src)
-    step.log(`Deleted directory and contents at: ${compiler.src}`)
-    return compiler.quit()
-  }
-
-  const buildSteps = build ? [download, artifacts, ...patches, ...options.patches] : []
-  const nexe = compose(resource, cli, buildSteps)
-  return nexe(compiler).asCallback(callback)
-}
-
-export { argv, compile }
@@ -1,214 +0,0 @@
-import * as parseArgv from 'minimist'
-import { NexeCompiler } from './compiler'
-import { basename, extname, join } from 'path'
-import * as Bluebird from 'bluebird'
-import { EOL } from 'os'
-
-export interface NexePatch {
-  (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
-}
-
-export interface NexeOptions {
-  build: boolean
-  /**
-   * Entrypoint filepath
-   */
-  input: string
-  output: string
-  targets: string[]
-  /**
-   * Build name, Used for executable, and stacktraces
-   */
-  name: string
-  /**
-   * The node version to be built
-   */
-  version: string
-  python?: string
-  /**
-   * Node flags e.g. "--expose-gc" baked into the executable
-   */
-  flags: string[]
-  /**
-   * Pass configuration options to node build configure script
-   */
-  configure: string[]
-  /**
-   * Pass make options to node make script
-   */
-  make: string[]
-  vcBuild: string[]
-  snapshot?: string
-  /**
-   * Array of glob strings describing resources to pull into the bundle
-   */
-  resources: string[]
-  /**
-   * Temporary directory where nexe artifacts will be cached
-   * TODO dot folder in home dir
-   */
-  temp: string
-  ico?: string
-  rc: { [key: string]: string }
-  /**
-   * Causes nexe to remove all temporary files for current configuration
-   */
-  clean: boolean
-  enableNodeCli: boolean
-  sourceUrl?: string
-  bundle: boolean | string
-  loglevel: 'info' | 'silent' | 'verbose'
-  silent?: boolean
-  verbose?: boolean
-  info?: boolean
-  padding: number
-  patches: NexePatch[]
-
-  empty: boolean
-  warmup?: string
-  downloadOptions?: any
-}
-
-function padRight(str: string, l: number) {
-  return (str + ' '.repeat(l)).substr(0, l)
-}
-const defaults = {
-  temp: process.env.NEXE_TEMP || join(process.cwd(), '.nexe'),
-  version: process.version.slice(1),
-  flags: [],
-  configure: [],
-  make: [],
-  targets: [],
-  vcBuild: ['nosign', 'release'],
-  enableNodeCli: false,
-  bundle: true,
-  build: true,
-  patches: []
-}
-const alias = {
-  i: 'input',
-  o: 'output',
-  t: 'target',
-  n: 'name',
-  v: 'version',
-  r: 'resource',
-  a: 'resource',
-  p: 'python',
-  f: 'flag',
-  c: 'configure',
-  m: 'make',
-  vc: 'vcBuild',
-  s: 'snapshot',
-  cli: 'enableNodeCli',
-  h: 'help',
-  l: 'loglevel'
-}
-const argv = parseArgv(process.argv, { alias, default: defaults })
-const help = `
-nexe --help              CLI OPTIONS
-
-  -b   --build                              -- build from source
-  -i   --input      =index.js               -- application entry point
-  -o   --output     =my-app.exe             -- path to output file
-  -t   --target     =win32-x64-6.10.3       -- *target a prebuilt binary
-  -n   --name       =my-app                 -- main app module name
-  -v   --version    =${padRight(process.version.slice(1), 23)}-- node version
-  -p   --python     =/path/to/python2       -- python executable
-  -f   --flag       ="--expose-gc"          -- *v8 flags to include during compilation
-  -c   --configure  ="--with-dtrace"        -- *pass arguments to the configure command
-  -m   --make       ="--loglevel"           -- *pass arguments to the make command
-  -vc  --vcBuild    =x64                    -- *pass arguments to vcbuild.bat
-  -s   --snapshot   =/path/to/snapshot      -- build with warmup snapshot
-  -r   --resource   =./paths/**/*           -- *embed file bytes within the binary
-       --bundle     =./path/to/config       -- pass a module path that exports nexeBundle
-       --temp       =./path/to/temp         -- nexe temp files (for downloads and source builds)
-       --no-bundle                          -- set when input is already bundled
-       --ico                                -- file name for alternate icon file (windows)
-       --rc-*                               -- populate rc file options (windows)
-       --clean                              -- force download of sources
-       --enableNodeCli                      -- enable node cli enforcement (blocks app cli)
-       --sourceUrl                          -- pass an alternate source (node.tar.gz) url
-       --silent                             -- disable logging
-       --verbose                            -- set logging to verbose
-
-       -* variable key name                 * option can be used more than once`.trim()
-
-function flattenFilter(...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() {
-  let filename
-  try {
-    const file = require.resolve(process.cwd())
-    filename = basename(file).replace(extname(file), '')
-  } catch (_) {}
-
-  return !filename || filename === 'index' ? 'nexe_' + Date.now() : filename
-}
-
-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 (typeof options.input === 'string' && !name) {
-    name = basename(options.input).replace(extname(options.input), '')
-  }
-  name = name || tryResolveMainFileName()
-  return name.replace(/\.exe$/, '')
-}
-
-function normalizeOptionsAsync(input: Partial<NexeOptions>) {
-  if (argv.help || argv._.some((x: string) => x === 'version')) {
-    process.stderr.write(argv.help ? help : '2.0.0-beta.4' + EOL, () => process.exit(0))
-  }
-
-  const options = Object.assign({}, defaults, input) as NexeOptions
-  const opts = options as any
-  delete opts._
-  options.loglevel = extractLogLevel(options)
-  options.name = extractName(options)
-  options.flags = flattenFilter(opts.flag, options.flags)
-  options.targets = flattenFilter(opts.target, options.targets)
-  options.make = flattenFilter(options.make)
-  options.vcBuild = flattenFilter(options.vcBuild)
-  options.configure = flattenFilter(options.configure)
-  options.resources = flattenFilter(opts.resource, options.resources)
-  options.rc = options.rc || extractCliMap(/^rc-.*/, options)
-
-  if (options.build || options.padding === 0) {
-    options.targets = []
-    options.build = true
-  } else if (!options.targets.length) {
-    const defaultTarget = [process.platform, process.arch, options.version].join('-')
-    options.targets = [defaultTarget]
-  }
-
-  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.options.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,18 +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,21 +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,
-  (compiler: NexeCompiler, next: () => Promise<void>) => compiler.setMainModule(compiler, next),
-  nexePatches,
-  buildFixes,
-  cli,
-  flags,
-  ico,
-  rc
-]
-
-export default patches
@@ -1,19 +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.replace(new RegExp(`VALUE "${key}",*`), `VALUE "${key}", ${value}`)
-  })
-
-  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,80 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function main(compiler: NexeCompiler, next: () => Promise<void>) {
-  await compiler.setFileContentsAsync(
-    'lib/_third_party_main.js',
-    `
-const fs = require('fs')
-const Buffer = require('buffer').Buffer
-const isString = x => typeof x === 'string' || x instanceof String
-
-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
-  }
-})());
-
-const originalReadFile = fs.readFile
-const originalReadFileSync = fs.readFileSync
-
-fs.readFile = function readFile (file, options, callback) {
-  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 = +manifest.binaryOffset + +manifest.resourceOffset + 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) {
-  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 = +manifest.binaryOffset + +manifest.resourceOffset + 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
-}`.trim()
-  )
-  return next()
-}
@@ -1,33 +0,0 @@
-import { each } from 'bluebird'
-import { readFileAsync, isDirectoryAsync } 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,35 +0,0 @@
-declare module 'nigel' {
-  import { Writable } from 'stream'
-  interface Needle {
-    value: Buffer
-    lastPos: number
-    last: number
-    length: number
-    badCharShift: Buffer
-  }
-
-  export function compile(needle: Buffer): Needle
-  export function horspool(haystack: Buffer, needle: Needle, start: number): number
-  export function all(haystack: Buffer, needle: Needle, pos: number): number[]
-  export class Stream extends Writable {
-    constructor(needle: Buffer)
-    needle(needle: Buffer): void
-    flush(): void
-  }
-}
-
-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,47 +0,0 @@
-import { readFile, writeFile, stat } from 'fs'
-import * as Bluebird from 'bluebird'
-import rimraf = require('rimraf')
-
-const { promisify } = Bluebird
-const rimrafAsync = (promisify(rimraf) as any) as (path: string) => Bluebird<void>
-
-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): Bluebird<Buffer>
-  (path: string, encoding: string): Bluebird<string>
-}
-
-const readFileAsync = (promisify(readFile) as any) as ReadFileAsync
-const writeFileAsync = (promisify(writeFile) as any) as (
-  path: string,
-  contents: string | Buffer
-) => Promise<void>
-const statAsync = promisify(stat)
-const isWindows = process.platform === 'win32'
-
-function pathExistsAsync(path: string) {
-  return statAsync(path).then(x => true).catch({ code: 'ENOENT' }, () => false)
-}
-
-function isDirectoryAsync(path: string) {
-  return statAsync(path).then(x => x.isDirectory()).catch({ code: 'ENOENT' }, () => false)
-}
-
-export {
-  dequote,
-  isWindows,
-  rimrafAsync,
-  readFileAsync,
-  pathExistsAsync,
-  isDirectoryAsync,
-  writeFileAsync
-}
@@ -1 +0,0 @@
-true
@@ -1,11 +0,0 @@
-/**
- * Embedded Files Test
- *
- * @author Jared Allard <jaredallard@outlook.com>
- * @version 0.0.1
- * @license MIT
- **/
-
-const nexeres = require('nexeres');
-
-process.stdout.write(nexeres.get('hw.txt').toString('ascii'));
@@ -1,28 +0,0 @@
-{
-  "name": "embededfiles-test",
-  "version": "0.0.0",
-  "private": true,
-  "scripts": {
-    "start": "node index.js"
-  },
-  "dependencies": {
-  },
-  "nexe": {
-    "input": "index.js",
-    "output": "test.nex",
-    "resourceFiles": [
-      "hw.txt"
-    ],
-    "browserify": {
-      "excludes": [],
-      "requires": []
-    },
-    "temp": "../src",
-    "debug": false,
-    "runtime": {
-      "nodeConfigureOpts": ["--fully-static"],
-      "framework": "node",
-      "version": "5.7.0"
-    }
-  }
-}
@@ -1,61 +0,0 @@
-var express = require('express');
-var path = require('path');
-var favicon = require('serve-favicon');
-var logger = require('morgan');
-var cookieParser = require('cookie-parser');
-var bodyParser = require('body-parser');
-var jade       = require('jade');
-
-var routes = require('./routes/index');
-var users = require('./routes/users');
-
-var app = express();
-
-// view engine setup
-app.set('views', path.join(__dirname, 'views'));
-app.set('view engine', 'jade');
-
-// uncomment after placing your favicon in /public
-//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
-app.use(logger('dev'));
-app.use(bodyParser.json());
-app.use(bodyParser.urlencoded({ extended: false }));
-app.use(cookieParser());
-app.use(express.static(path.join(__dirname, 'public')));
-
-app.use('/', routes);
-app.use('/users', users);
-
-// catch 404 and forward to error handler
-app.use(function(req, res, next) {
-  var err = new Error('Not Found');
-  err.status = 404;
-  next(err);
-});
-
-// error handlers
-
-// development error handler
-// will print stacktrace
-if (app.get('env') === 'development') {
-  app.use(function(err, req, res, next) {
-    res.status(err.status || 500);
-    res.render('error', {
-      message: err.message,
-      error: err
-    });
-  });
-}
-
-// production error handler
-// no stacktraces leaked to user
-app.use(function(err, req, res, next) {
-  res.status(err.status || 500);
-  res.render('error', {
-    message: err.message,
-    error: {}
-  });
-});
-
-
-module.exports = app;
@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Module dependencies.
- */
-
-var app = require('../app');
-var debug = require('debug')('express-test:server');
-var http = require('http');
-
-/**
- * Get port from environment and store in Express.
- */
-
-var port = normalizePort(process.env.PORT || '3000');
-app.set('port', port);
-
-/**
- * Create HTTP server.
- */
-
-var server = http.createServer(app);
-
-/**
- * Listen on provided port, on all network interfaces.
- */
-
-server.listen(port);
-server.on('error', onError);
-server.on('listening', onListening);
-
-/**
- * Normalize a port into a number, string, or false.
- */
-
-function normalizePort(val) {
-  var port = parseInt(val, 10);
-
-  if (isNaN(port)) {
-    // named pipe
-    return val;
-  }
-
-  if (port >= 0) {
-    // port number
-    return port;
-  }
-
-  return false;
-}
-
-/**
- * Event listener for HTTP server "error" event.
- */
-
-function onError(error) {
-  if (error.syscall !== 'listen') {
-    throw error;
-  }
-
-  var bind = typeof port === 'string'
-    ? 'Pipe ' + port
-    : 'Port ' + port;
-
-  // handle specific listen errors with friendly messages
-  switch (error.code) {
-    case 'EACCES':
-      console.error(bind + ' requires elevated privileges');
-      process.exit(1);
-      break;
-    case 'EADDRINUSE':
-      console.error(bind + ' is already in use');
-      process.exit(1);
-      break;
-    default:
-      throw error;
-  }
-}
-
-/**
- * Event listener for HTTP server "listening" event.
- */
-
-function onListening() {
-  var addr = server.address();
-  var bind = typeof addr === 'string'
-    ? 'pipe ' + addr
-    : 'port ' + addr.port;
-  debug('Listening on ' + bind);
-}
-
-process.stdout.write('true');
-process.exit(0);
@@ -1,28 +0,0 @@
-{
-  "name": "express-test",
-  "version": "0.0.0",
-  "private": true,
-  "scripts": {
-    "start": "node ./bin/www"
-  },
-  "dependencies": {
-    "body-parser": "~1.13.2",
-    "cookie-parser": "~1.3.5",
-    "debug": "~2.2.0",
-    "express": "~4.13.1",
-    "jade": "~1.11.0",
-    "morgan": "~1.6.1",
-    "serve-favicon": "~2.3.0"
-  },
-  "nexe": {
-    "input": "bin/www",
-    "output": "test.nex",
-    "temp": "../src",
-    "debug": false,
-    "runtime": {
-      "framework": "node",
-      "version": "5.10.0",
-      "ignoreFlags": true
-    }
-  }
-}
@@ -1,8 +0,0 @@
-body {
-  padding: 50px;
-  font: 14px "Lucida Grande", Helvetica, Arial, sans-serif;
-}
-
-a {
-  color: #00B7FF;
-}
@@ -1,9 +0,0 @@
-var express = require('express');
-var router = express.Router();
-
-/* GET home page. */
-router.get('/', function(req, res, next) {
-  res.render('index', { title: 'Express' });
-});
-
-module.exports = router;
@@ -1,9 +0,0 @@
-var express = require('express');
-var router = express.Router();
-
-/* GET users listing. */
-router.get('/', function(req, res, next) {
-  res.send('respond with a resource');
-});
-
-module.exports = router;
@@ -1,6 +0,0 @@
-extends layout
-
-block content
-  h1= message
-  h2= error.status
-  pre #{error.stack}
@@ -1,5 +0,0 @@
-extends layout
-
-block content
-  h1= title
-  p Welcome to #{title}
@@ -1,7 +0,0 @@
-doctype html
-html
-  head
-    title= title
-    link(rel='stylesheet', href='/stylesheets/style.css')
-  body
-    block content
@@ -1,13 +0,0 @@
-/**
- * Test to verify if we support strict mode (flags)
- *
- * @author Jared Allard <jaredallard@outlook.com>
- * @version 0.0.1
- * @license MIT
- **/
-
- // "use strict"; w/o --use_strict
-
- let isStrict = (function() { return !this; })();
-
- console.log(isStrict);
@@ -1,15 +0,0 @@
-{
-	"name": "flags-test",
-	"nexe": {
-		"input": "./index.js",
-		"output": "test.nex",
-		"temp": "../src",
-		"runtime": {
-			"framework": "node",
-			"version": "5.7.0",
-			"ignoreFlags": false,
-			"js-flags": "--use_strict",
-			"node-args": ""
-		}
-	}
-}
@@ -1,23 +0,0 @@
-"use strict";
-
-let gulp = require('gulp');
-let nexe = require('nexe');
-
-gulp.task( "compile", ( callback ) => {
-    let options = {
-        input: "index.js",
-        output: "test.nex",
-        python: "python",
-        nodeTempDir: "./tmp",
-        nodeVersion: "latest",
-        flags: false,
-        framework: "nodejs"
-    };
-
-    nexe.compile( options, ( err ) => {
-        console.log( err );
-        callback( err );
-    } );
-} );
-
-gulp.task('default', ['compile']);
@@ -1,2 +0,0 @@
-// it probably executed.
-console.log(true);
@@ -1,26 +0,0 @@
-{
-  "name": "gulp-test-170",
-  "version": "0.0.1",
-  "description": "gulpfile.js issue #170",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "Jared Allard <jaredallard@outlook.com>",
-  "license": "MIT",
-  "dependencies": {
-    "gulp": "^3.9.0",
-    "nexe": "^1.0.5"
-  },
-  "nexe": {
-    "input": "./index.js",
-    "output": "test.nex",
-    "temp": "../src",
-    "runtime": {
-      "framework": "node",
-      "version": "5.7.0",
-      "ignoreFlags": true,
-      "node-args": ""
-    }
-  }
-}
@@ -1,19 +0,0 @@
-/**
- * Test to verify if we support strict mode (flags)
- *
- * @author Jared Allard <jaredallard@outlook.com>
- * @version 0.0.1
- * @license MIT
- **/
-
- // test.nex --help
-
- let status = false;
-
- // console.log(process.argv);
-
- if(process.argv[2]) {
-   status = true;
- }
-
- console.log(status);
@@ -1,15 +0,0 @@
-{
-  "name": "flags-test",
-  "nexe": {
-    "input": "./index.js",
-    "output": "test.nex",
-    "temp": "../src",
-    "runtime": {
-      "framework": "node",
-      "version": "5.7.0",
-      "ignoreFlags": true,
-      "node-args": ""
-    }
-  },
-  "dependencies": {}
-}
@@ -1,3 +0,0 @@
-require('js-yaml');
-
-console.log(true);
@@ -1,23 +0,0 @@
-{
-  "name": "js-yaml-148",
-  "version": "1.0.0",
-  "description": "#148 js-yaml fails to work",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "Jared Allard <jaredallard@outlook.com>",
-  "license": "MIT",
-  "dependencies": {
-    "js-yaml": "^3.5.2"
-  },
-  "nexe": {
-    "input": "index.js",
-    "output": "test.nex",
-    "temp": "../src",
-    "runtime": {
-      "version": "5.7.0",
-      "framework": "node"
-    }
-  }
-}
@@ -1 +0,0 @@
--timeout 100000000
@@ -1,249 +0,0 @@
-/**
- * Test runner for nexe
- *
- * @author Jared Allard <jaredallard@outlook.com>
- * @license MIT
- **/
-
-'use strict';
-
-const assert = require('assert');
-const fs     = require('fs');
-const path   = require('path');
-const spawn  = require('child_process').spawn;
-
-// our vars
-const NEXE_VERSION = require('../package.json').version;
-const testBase = __dirname;
-const LOG_FILE = path.join(testBase, 'test.log');
-
-if(fs.existsSync(LOG_FILE)) {
-  fs.unlinkSync(LOG_FILE);
-}
-
-let logfile = fs.createWriteStream(LOG_FILE, {
-  autoClose: false
-});
-
-const compileTest = function(test, cb) {
-  let testDir = path.join(testBase, test);
-  if(!fs.existsSync(testDir)) {
-    throw new Error('Test not found');
-    return cb(false);
-  }
-
-  let npminst = spawn('npm', ['install'], {
-    cwd: testDir
-  });
-
-  npminst.on('error', function() {
-    throw new Error('Failed to execute NPM');
-    return cb(false);
-  });
-
-  npminst.on('close', function(code) {
-    if(code !== 0) {
-      throw new Error('NPM exited with non-zero status');
-      return cb(false);
-    }
-
-    let testinst = spawn('../../bin/nexe', [], {
-      cwd: testDir
-    });
-
-    testinst.on('error', function() {
-      throw new Error('Test failed to compile');
-      return cb(false);
-    });
-
-    testinst.on('close', function(code) {
-      let err = null;
-      if(code !== 0) {
-        throw new Error('Test gave non-zero code');
-        err = false;
-      }
-
-      logfile = fs.createWriteStream(LOG_FILE);
-
-      return cb(err);
-    });
-    
-    testinst.stdout.on('data', function(d) {
-      process.stdout.write(d.toString('ascii'));
-    });
-  });
-};
-
-/**
- * Run a test-generated binary
- *
- * @param {string} test - test name (dir)
- * @param {array} optional args - array of args to pass to the binary
- * @param {function} cb - callback
- **/
-const runTest = function(test, args, cb) {
-  let testDir = path.join(testBase, test);
-  let testBin = path.join(testDir, 'test.nex')
-
-  // check params
-  if(!Array.isArray(args)) {
-    cb = args;
-    args = [];
-  }
-
-  if(!fs.existsSync(testDir)) {
-    throw new Error('Test not found');
-    return cb(false);
-  }
-
-  if(!fs.existsSync(testBin)) {
-    throw new Error('Test binary not found');
-    return cb(false);
-  }
-
-  let returned = false;
-  let testinst = spawn(testBin, args, {
-    cwd: testDir
-  })
-
-  testinst.stdout.on('data', function(d) {
-    let status = d.toString('ascii');
-
-    if(status === true || status === 'true' || status === 'true\n') {
-      testinst.stdin.pause();
-      testinst.kill();
-
-      // make it know we returned.
-      returned = true;
-
-      return cb();
-    }
-  })
-
-  testinst.on('close', function(c) {
-    if(returned !== true) {
-      throw new Error('Test failed (stdout never contained true)');
-      return cb(false);
-    }
-  });
-}
-
-console.log('NOTICE: The first test may take awhile as it may compile Node.js');
-console.log('        Monitor the log file (test.log) for progress.');
-
-
-after(function() {
-  console.log('notice: closing test.log file descriptor.')
-  logfile.end();
-});
-
-/**
- * Tests express compatability.
- **/
-describe('nexe can bundle express', function() {
-  let testname = 'express-test';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('nexe and embedding files', function() {
-  let testname = 'embeded-files';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('v8 flags test (strict mode)', function() {
-  let testname = 'flags-test';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('nexe can be utilized in gulp test', function() {
-  let testname = 'gulp-test-170';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('nexe can ignore node.js flags test', function() {
-  let testname = 'ignoreFlags-test';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, ['--help'], function(err) {
-        return next(err);
-      });
-    });
-  });
-});
-
-describe('nexe supports js-yaml test', function() {
-  let testname = 'js-yaml-148';
-
-  describe('build', function () {
-    it('compiles without errors', function (next) {
-      compileTest(testname, function(err) {
-        return next(err);
-      });
-    });
-
-    it('runs successfully', function(next) {
-      runTest(testname, function(err) {
-        return next(err);
-      });
-    });
-  });
-});
@@ -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