chore: bump version

docs: update readme
chore: update dependencies
2021-09-26 21:20:48 -05:00 · 2021-09-26 17:15:06 -05:00 · 2021-09-26 16:59:48 -05:00 · 2021-09-26 15:50:55 -05:00 · 2021-09-26 13:43:14 -05:00 · 2021-09-26 13:37:29 -05:00
50 changed files with 6626 additions and 2604 deletions
@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-
-export NVS_HOME="$HOME/.nvs"
-. "$NVS_HOME/nvs.sh" install && nvs link lts && nvs use default
-
-set -e -x
-
-yarn run asset-compile
@@ -1,28 +0,0 @@
-version: 2
-
-jobs:
-  build:
-    macos:
-      xcode: "9.0"
-    steps:
-    - checkout
-    - restore_cache:
-        keys:
-        - package-{{ checksum "package.json" }}-{{ checksum "yarn.lock" }}
-        - package- # Fallback for the latest package.json cache
-    - run:
-        name: setup
-        command: .circleci/setup.sh
-    - save_cache:
-        key: package-{{ checksum "package.json" }}-{{ checksum "yarn.lock" }} 
-        paths:
-        - node_modules
-    - run:
-        name: build
-        command: .circleci/build.sh
-
-workflows:
-  version: 2
-  test:
-    jobs:
-      - build
@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-echo "setting up node to use latest lts"
-
-export NVS_HOME="$HOME/.nvs"
-git clone --depth=1 https://github.com/jasongin/nvs "$NVS_HOME"
-. "$NVS_HOME/nvs.sh" install
-nvs add lts && nvs link lts nvs use default
-npm install -g yarn 
-yarn
@@ -4,6 +4,5 @@ end_of_line = lf
 charset = utf-8
 indent_style = space
 indent_size = 2
-#https://github.com/Microsoft/vscode/issues/23983#event-1087502108
-#trim_trailing_whitespace = true
+trim_trailing_whitespace = true
 insert_final_newline = true
@@ -0,0 +1 @@
+custom: https://www.paypal.me/calebsboyd
@@ -0,0 +1,23 @@
+---
+name: Bug Report
+about: Report a bug encountered while running Nexe
+labels: bug
+
+---
+<!-- Please use this template while reporting a bug and provide as much info as possible. Not doing so may result in your bug not being addressed in a timely manner. Thanks!
+-->
+
+**What happened**:
+
+**What you expected to happen**:
+
+**How to reproduce it (as minimally and precisely as possible)**:
+
+**Anything else we need to know?**:
+
+**Environment**:
+- Platform(OS/Version):
+- Host Node Version:
+- Target Node Version:
+- Nexe version:
+- Python Version:
@@ -0,0 +1,11 @@
+---
+name: Feature Request
+about: Suggest an feature request
+labels: feature
+
+---
+<!-- Please only use this template for submitting feature requests -->
+
+**What would you like to be added**:
+
+**Why is this needed**:
@@ -0,0 +1,11 @@
+**What this PR does / why we need it**:
+
+**Which issue(s) this PR fixes**:
+<!--
+*Automatically closes linked issue when PR is merged.
+Usage: `Fixes #<issue number>`, or `Fixes (paste link of issue)`.
+_If PR is about `failing-tests or flakes`, please post the related issues/tests in a comment and do not use `Fixes`_*
+-->
+Fixes #
+
+**Special notes for your reviewer**:
@@ -0,0 +1,21 @@
+name: No Response
+
+# Both `issue_comment` and `scheduled` event types are required for this Action
+# to work properly.
+on:
+  issue_comment:
+    types: [created]
+  schedule:
+    # 9AM Central
+    - cron: '0 14 * * *'
+
+jobs:
+  noResponse:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: lee-dohm/no-response@v0.5.0
+        with:
+          token: ${{ github.token }}
+          closeComment: 'Closed awaiting response from OP, please open a new issue with the requested information and/or examples'
+          daysUntilClose: 21
+          responseRequiredLabel: more-information-needed
@@ -1,6 +1,7 @@
 .DS_Store
 temp/
 coverage
+nexe
 node_modules
 *.log
 *.exe
@@ -1,14 +0,0 @@
-language: node_js
-node_js:
- '6'
-before_install:
-  - sudo apt-get -qq update
-  - sudo apt-get install -y g++-multilib
-node_js:
- '8'
-script: npm run asset-compile
-env:
-  global:
-    - secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
-notifications:
-  email: false
@@ -1,3 +1,3 @@
 {
-    "recommendations": [ "eg2.tslint" ]
+    "recommendations": [ "ms-vscode.vscode-typescript-tslint-plugin" ]
 }
@@ -1,16 +1,15 @@
+
 <p align="center"><img src="https://cloud.githubusercontent.com/assets/2391349/23598327/a17bb68a-01ee-11e7-8f55-88a5fc96e997.png" /></p>

 <p align="center">
-  <a href="https://circleci.com/gh/nexe/nexe"><img src="https://img.shields.io/circleci/project/github/nexe/nexe/master.svg" alt="Mac Build Status"></a>
-  <a href="https://travis-ci.org/nexe/nexe/builds"><img src="https://img.shields.io/travis/nexe/nexe/master.svg" alt="Linux Build Status"></a>
-  <a href="https://ci.appveyor.com/project/calebboyd/nexe/history"><img src="https://img.shields.io/appveyor/ci/calebboyd/nexe/master.svg" alt="Windows Build Status"></a>
+  <a href="https://dev.azure.com/nexe-ci/Nexe/_build?definitionId=1"><img src="https://img.shields.io/azure-devops/build/nexe-ci/nexe/1/master.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>
-  <a href="https://gitter.im/nexe/nexe?utm_source=badge&utm_medium=badge"><img src="https://badges.gitter.im/nexe/nexe.svg"></a>
+  <a href="https://discord.gg/2qTH52zNcZ"><img src="https://discordapp.com/api/guilds/814334925049561168/widget.png?style=shield"></a>
 </p>

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

 <p align="center">
@@ -43,7 +42,6 @@ For more CLI options see: `nexe --help`
 ### Examples

 - `nexe server.js -r "public/**/*.html"`
- `nexe my-bundle.js --no-bundle -o app.exe`
 - `nexe --build`
 - `nexe -t x86-8.0.0`

@@ -51,10 +49,39 @@ For more CLI options see: `nexe --help`

 Additional files or resources can be added to the binary by passing `-r "glob/pattern/**/*"`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`.

-## Compiling Node
+## Compiling the nexe Executable

-By default `nexe` will attempt to download a pre-built executable. However, It may be unavailable ([github releases](https://github.com/nexe/nexe/releases))
-or you may want to customize what is built. See `nexe --help` for a list of options available when passing the [`--build`](#build-boolean) option. You will also need to ensure your environment is setup to [build node](https://github.com/nodejs/node/blob/master/BUILDING.md). Note: the `python` binary in your path should be an acceptable version of python 2. eg. Systems that have python2 will need to create a [symlink](https://github.com/nexe/nexe/issues/354#issuecomment-319874486).
+By default `nexe` will attempt to download a pre-built executable. These are listed on the [releases page](https://github.com/nexe/nexe/releases/tag/v3.3.3). The exact version you want may be unavailable or you may want to customize what is built. See `nexe --help` for a list of options available when passing the [`--build`](#build-boolean) option. You will also need to ensure your environment is setup to [build node](https://github.com/nodejs/node/blob/master/BUILDING.md). Note: the `python` binary in your path should be an acceptable version of python 2. eg. Systems that have python 2 will need to create a [symlink](https://github.com/nexe/nexe/issues/354#issuecomment-319874486).
+
+### Linux and macOS
+[Prerequisites & details](https://github.com/nodejs/node/blob/master/BUILDING.md#unix-and-macos)
+
+### Windows
+
+The fastest and most reliable way to get started is simply to run the commands below. If you'd rather read the details or perform a manual install of the prerequisites, [you can find that here](https://github.com/nodejs/node/blob/master/BUILDING.md#windows).
+
+The instructions below are the fastest and most reliable method.
+Run the following sets of commands with PowerShell (running as Administrator).
+
+**Install all required build tools (and dependencies):**
+```
+Set-ExecutionPolicy Unrestricted -Force
+iex ((New-Object System.Net.WebClient).DownloadString('https://boxstarter.org/bootstrapper.ps1'))
+get-boxstarter -Force
+Install-BoxstarterPackage https://raw.githubusercontent.com/nodejs/node/master/tools/bootstrap/windows_boxstarter -DisableReboots
+```
+
+**Set config:**
+```
+npm config set msvs_version 2019
+npm config set python python2.7
+```
+Where `2019` is the version of Visual Studio you have (if you have it).
+
+**Notes:**
+- The above works and has been tested with node.js `14.5.4` and `15.8.0`
+- Python 3 and Python 2 can coexist and `nexe` will still work, considering the `set config` area above
+- Don't use `npm install windows-build-tools` unless you're having some type of issue, because the above commands configures and installs the latest/preferred too.

 ## Node.js API

@@ -90,14 +117,14 @@ compile({
    - Output executable file path
    - default: same as `name` with an OS specific extension.
 - #### `target: string | object`
-    - An object or string describing platform-arch-version. e.g. `'windows-ia32-6.10.3'`
+    - An object or string describing platform-arch-version. e.g. `'windows-ia32-10.13.0'`
      - each segment is optional, and will be merged with the current environment
      - Examples: ([full list](https://github.com/nexe/nexe/releases))
-        - `'win32-x86-8.6.0`
+        - `'win32-x86-10.13.0`
        - `{ platform: 'alpine' }`
-        - `darwin-8.6.0`
+        - `darwin-10.13.0`
        - `linux-x64`
-        - `macos-8.4.0`
+        - `macos-10.13.0`

        See [test/target.spec.ts](test/target.spec.ts)
    - If the [`build`](#build-boolean) flag is set, the platform portion of the target is ignored.
@@ -115,8 +142,17 @@ compile({
 - #### `cwd: string`
    - Directory nexe will operate on as though it is the cwd
    - default: process.cwd()
+ - #### `mangle: boolean`
+    - If set to false, nexe will not include the virtual filesystem (your application and resources) on the output.
+    - This will cause the output to error as an "Invalid Binary" unless a userland patch alters the contents of lib/_third_party_main.js in the nodejs source.
+    - default: true
 - #### `build: boolean`
    - Build node from source, passing this flag tells nexe to download and build from source. Subsequently using this flag will cause nexe to use the previously built binary. To rebuild, first add [`--clean`](#clean-boolean)
+ - #### `remote: string`
+    - Provide a custom remote location for fetching pre-built nexe binaries from. This can either be an HTTP or HTTPS URL.
+    - default: `null`
+ - #### `asset: string`
+    - Provide a pre-built nexe binary asset, this is a file path is resolved relative to cwd.
 - #### `python: string`
    - On Linux this is the path pointing to your python2 executable
    - On Windows this is the directory where `python` can be accessed
@@ -130,10 +166,11 @@ compile({
    - Example: `['--with-dtrace', '--dest-cpu=x64']`
    - default: `[]`
 - #### `make: string[]`
-    - Array of arguments for the node build make step, on windows this step recieves options for vcBuild.bat
-    - default: `[]` or `['nosign', 'release']` for non windows systems
+    - Array of arguments for the node build make step
+    - default: `[]`
 - #### `vcBuild: string[]`
-    - Alias for `make` option
+    - Options for windows build
+    - default: `['nosign', 'release']`
 - #### `snapshot: string`
    - path to a file to be used as the warmup snapshot for the build
    - default: `null`
@@ -144,12 +181,12 @@ compile({
 - #### `temp: string`
    - Path to use for storing nexe's build files
    - Override in the env with `NEXE_TEMP`
-    - default: `./.nexe` in the cwd
+    - default: `~/.nexe`
 - #### `ico: string`
    - Path to a user provided icon to be used (Windows only). Requires `--build` to be set.
 - #### `rc: object`
    - Settings for patching the [node.rc](https://github.com/nodejs/node/blob/master/src/res/node.rc) configuration file (Windows only).
-    - Example:
+    - Example (keys may vary depending on the version. Reference the file linked above):
      ```javascript
        {
          CompanyName: "ACME Corp",
@@ -167,7 +204,7 @@ compile({
      variable will still be processed. NODE_OPTIONS support can be disabled with the `--without-node-options` configure flag.
    - default: `false`
  - #### `fakeArgv: boolean`
-    - fake the entry point file name (`process.argv[1]`). If nexe was used with stdin this will be `'[stdin]'`. 
+    - fake the entry point file name (`process.argv[1]`). If nexe was used with stdin this will be `'[stdin]'`.
 - #### `ghToken: string`
    - Provide a Github Token for accessing nexe releases
    - This is usually needed in CI environments
@@ -199,7 +236,7 @@ For examples, see the built in patches: [src/patches](src/patches).
    - Quickly perform a replace in a file within the downloaded Node.js source. The rest arguments are passed along to `String.prototype.replace`
 - `readFileAsync(filename: string): Promise<NexeFile>`
    - Access (or create) a file within the downloaded Node.js source.
- - `addResource(filename: string, contents: Buffer): void`
+ - `addResource(filename: string, contents: Buffer): Promise<void>`
    - Add a resource to the nexe bundle
 - `files: NexeFile[]`
    - The cache of the currently read, modified, or created files within the downloaded Node.js source.
@@ -213,9 +250,20 @@ Any modifications made to `NexeFile#contents` will be maintained in the cache _w

 ## Native Modules

-TODO
+In order to use native modules, the native binaries must be shipped alongside the binary generated by nexe.

- [ ] Implement support for `node-pre-gyp#find`.
+## Troubleshooting
+
+`Error: Entry file "" not found!` means you need to provide `nexe` with input. Either use `-i` or pipe data to it.
+
+`Error: https://github.com/nexe/nexe/releases/download/v3.3.3/windows-x64-15.8.0 is not available, create it using the --build flag` or similar message means that it either:
+- You are having networking issues such as the download being blocked
+- You should specify the target so `nexe` knows what version of the executable to use.
+	- See the [releases page](https://github.com/nexe/nexe/releases) to find the executable's version number
+	- Example
+		- `nexe -i "app.js" -r "public/**/*.html" -o "dist/myApp.exe" -t x64-14.15.3`
+		- where `-i` specifies the input, `-r` specifies resources to embed, `-o` specifies the output, `-t` specifies the target.
+	- Alternatively you can compile the executable yourself, see that section for details

 ## Contributing

@@ -223,20 +271,10 @@ Building
 ```
 $ git clone git@github.com:nexe/nexe.git
 $ cd nexe
-$ yarn
+$ npm i && npm run build
 ```

 Testing
 ```
 $ npm test
 ```
-
-## 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) | [![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) |  [Dustin Greif](https://github.com/dgreif) |
-
-### Former
-
- [Craig Condon](http://crcn.codes/)
@@ -1,23 +0,0 @@
-image:
-  - Visual Studio 2017
-  - Visual Studio 2015
-environment:
-  CIRCLE_TOKEN:
-    secure: TQKcepXmTzCNt4+tUBtYpwEQkdSPwFr9A8ugtoMhNbKu/SW1WM1EpjEu6kYXxpQ4
-  TRAVIS_TOKEN:
-    secure: 6ni/E6Rbmv6cFWW7QNLkpQY2fVpT7wr7y12GEtektN0=
-  GITHUB_TOKEN:
-    secure: 3wuEGJsppSKFvdwhp3jprUA9Zkc3WINlc/9oFXjhAR6J05lYMXP7Fl7lXTKpkGZx
-install:
-  - ps: Install-Product node 8
-  - curl -L -o nasm.exe https://www.nasm.us/pub/nasm/releasebuilds/2.13.03/win64/nasm-2.13.03-installer-x64.exe
-  - start /wait nasm.exe /S
-  - ps: $env:path="C:\Program Files\nasm;$($env:path)"
-  - npm i
-build: off
-test: off
-build_script:
-  - npm run asset-compile
-artifacts:
-  - path: $(HOMEPATH)\.nexe\**\node.exe
-
@@ -0,0 +1,69 @@
+schedules:
+- cron: "0 8 * * *"
+  displayName: "Daily Build 1"
+  always: true
+  branches:
+    include:
+      - master
+- cron: "0 13 * * *"
+  displayName: "Daily Build 2"
+  always: true
+  branches:
+    include:
+      - master
+- cron: "0 19 * * *"
+  displayName: "Daily Build 3"
+  always: true
+  branches:
+    include:
+      - master
+jobs:
+- job: BaseBuild
+  timeoutInMinutes: 360
+  strategy:
+    matrix:
+      linux:
+        imageName: 'ubuntu-16.04'
+      mac:
+        imageName: 'macos-10.15'
+      windows_2017:
+        imageName: 'vs2017-win2016'
+      windows_2015:
+        imageName: 'vs2017-win2016'
+      alpine:
+        imageName: 'ubuntu-16.04'
+  pool:
+    vmImage: $(imageName)
+  steps:
+  - task: UsePythonVersion@0
+    displayName: Setup Python
+    inputs:
+      versionSpec: '2.7'
+      architecture: 'x64'
+  - task: NodeTool@0
+    displayName: Install Node
+    inputs:
+      versionSpec: '12.x'
+  - script: sudo apt-get update && sudo apt-get install -y libc6-dev-i386 gcc-multilib g++-multilib
+    condition: contains(variables['Agent.JobName'], 'linux')
+    displayName: Install Linux build dependencies
+  - script: choco install visualcpp-build-tools --version 14.0.25420.1 -fy && npm config set msvs_version 2015
+    condition: contains(variables['Agent.JobName'], 'windows_2015')
+    displayName: Install Windows build dependencies
+  - script: npm install && npm run ci:build
+    displayName: Build Nexe
+    env:
+      GITHUB_TOKEN: $(PersonalGithubToken)
+      NEXE_VERBOSE: $(NEXE_VERBOSE)
+      msbuild_args: /3G
+    condition: not(contains(variables['Agent.JobName'], 'windows'))
+  - powershell: |
+      iex (new-object net.webclient).downloadstring('https://get.scoop.sh')
+      scoop install nasm
+      npm install
+      npm run ci:build
+    displayName: Build Nexe (Windows)
+    condition: contains(variables['Agent.JobName'], 'windows')
+    env:
+      GITHUB_TOKEN: $(PersonalGithubToken)
+      NEXE_VERBOSE: $(NEXE_VERBOSE)
@@ -10,7 +10,20 @@ if (require.main === module) {
    process.stderr.write(showHelp ? options.help : options.version + eol)
  } else {
    const nexe = require('./lib/nexe')
-    nexe.compile(argv).catch(() => {
+    nexe.compile(argv).catch((error) => {
+      const NexeError = require('./lib/compiler').NexeError
+      const chalk = require('chalk')
+      const isSilent = Boolean(argv.silent === true || argv.loglevel === 'silent')
+      if (!isSilent) {
+        if (error instanceof NexeError) {
+          process.stderr.write(eol + chalk.red('Error: ') + error.message + eol
+            + eol + 'See nexe -h for usage..' + eol + eol
+          )
+        } else {
+          process.stderr.write(error.stack + eol)
+        }
+      }
+
      process.exit(1)
    })
  }
@@ -1,19 +0,0 @@
-<!-- If you need help or think you have found a bug, please help us with your issue by entering the following information (otherwise you can delete this text): -->
-
-**Is this a BUG or a FEATURE REQUEST?:** 
-
-**What happened:**
-
-**What you expected to happen:**
-
-**How to reproduce it (as minimally and precisely as possible):**
-
-**Anything else we need to know?:**
-
-**Environment**
-
- Platform(OS/Version):
- Host Node Version:
- Target Node Version:
- Nexe version:
- Python Version:
@@ -2,14 +2,14 @@
  "name": "nexe",
  "description": "Create a single executable out of your Node.js application",
  "license": "MIT",
-  "version": "3.0.0-beta.1",
+  "version": "4.0.0-beta.19",
  "contributors": [
    "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
    "Jared Allard <jaredallard@outlook.com>",
    "Caleb Boyd <caleb.boyd@hotmail.com>"
  ],
  "scripts": {
-    "asset-compile": "ts-node tasks/asset-compile",
+    "ci:build": "ts-node tasks/build",
    "test": "mocha",
    "lint": "tslint \"{src,plugins,tasks}/**/*.ts\" --fix",
    "prepare": "npm run lint && npm run build && npm test",
@@ -30,46 +30,50 @@
    "nexe": "index.js"
  },
  "engines": {
-    "node": ">=6"
+    "node": ">=10"
+  },
+  "mocha": {
+    "spec": "./test/**/*.spec.ts",
+    "checkLeaks": true,
+    "require": [
+      "ts-node/register"
+    ]
  },
  "dependencies": {
    "@calebboyd/semaphore": "^1.3.1",
-    "app-builder": "^5.2.0",
+    "app-builder": "^7.0.4",
    "caw": "^2.0.1",
-    "chalk": "^2.4.1",
-    "cherow": "^1.6.8",
-    "download": "^7.1.0",
-    "globby": "^8.0.1",
-    "got": "^9.2.2",
-    "minimist": "^1.2.0",
-    "mkdirp": "^0.5.1",
-    "multistream": "^2.1.1",
-    "ora": "^3.0.0",
-    "pify": "^4.0.0",
-    "resolve-dependencies": "^2.1.1",
-    "rimraf": "^2.6.2"
+    "chalk": "^2.4.2",
+    "cherow": "1.6.9",
+    "download": "^8.0.0",
+    "globby": "^11.0.2",
+    "got": "^11.8.2",
+    "minimist": "^1.2.5",
+    "mkdirp": "^1.0.4",
+    "multistream": "^4.1.0",
+    "ora": "^3.4.0",
+    "resolve-dependencies": "^6.0.7",
+    "rimraf": "^3.0.2"
  },
  "devDependencies": {
-    "@types/chai": "^4.1.5",
-    "@types/execa": "^0.9.0",
-    "@types/globby": "^8.0.0",
-    "@types/got": "^8.3.4",
-    "@types/minimist": "^1.2.0",
-    "@types/mkdirp": "^0.5.2",
-    "@types/mocha": "^5.2.5",
+    "@types/chai": "^4",
+    "@types/download": "^6",
+    "@types/globby": "^9",
+    "@types/minimist": "^1.2.2",
+    "@types/mkdirp": "^1.0.2",
+    "@types/mocha": "^9.0.0",
    "@types/multistream": "^2.1.1",
-    "@types/ora": "^1.3.4",
-    "@types/pify": "3.0.2",
-    "@types/rimraf": "2.0.2",
-    "@types/semver": "^5.5.0",
-    "chai": "^4.1.2",
-    "execa": "^1.0.0",
-    "mocha": "^5.2.0",
-    "prettier": "^1.14.3",
-    "ts-node": "^7.0.1",
-    "tslint": "^5.11.0",
-    "tslint-config-prettier": "^1.15.0",
-    "tslint-plugin-prettier": "^2.0.0",
-    "typescript": "^3.0.3"
+    "@types/ora": "^3.2.0",
+    "@types/rimraf": "3.0.2",
+    "@types/semver": "^7.3.8",
+    "chai": "^4.3.4",
+    "execa": "^5.1.1",
+    "mocha": "^9.1.2",
+    "prettier": "^2.4.1",
+    "ts-node": "^10.2.1",
+    "tslint": "^6.1.1",
+    "tslint-config-prettier": "^1.18.0",
+    "tslint-plugin-prettier": "^2.3.0",
+    "typescript": "^4.4.3"
  }
 }
@@ -1,52 +1,121 @@
-import { delimiter, dirname, normalize, join } from 'path'
+import { delimiter, resolve, normalize, join } from 'path'
 import { Buffer } from 'buffer'
-import { createReadStream } from 'fs'
-import { Readable, Stream } from 'stream'
+import { createReadStream, ReadStream } from 'fs'
 import { spawn } from 'child_process'
 import { Logger, LogStep } from './logger'
-import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows, bound } from './util'
+import {
+  readFileAsync,
+  writeFileAsync,
+  pathExistsAsync,
+  statAsync,
+  dequote,
+  isWindows,
+  bound,
+  semverGt,
+  wrap,
+} from './util'
 import { NexeOptions, version } from './options'
 import { NexeTarget } from './target'
-import download = require('download')
-import { getLatestGitRelease } from './releases'
-import { IncomingMessage } from 'http'
-import combineStreams = require('multistream')
+import MultiStream = require('multistream')
 import { Bundle, toStream } from './fs/bundle'
+import { File } from 'resolve-dependencies'

 const isBsd = Boolean(~process.platform.indexOf('bsd'))
 const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
 const configure = isWindows ? 'configure' : './configure'

+type StringReplacer = (match: string) => string
+
 export interface NexeFile {
  filename: string
  absPath: string
-  contents: string
+  contents: string | Buffer
 }

 export { NexeOptions }

+export class NexeError extends Error {
+  constructor(m: string) {
+    super(m)
+    Object.setPrototypeOf(this, NexeError.prototype)
+  }
+}
+
 export class NexeCompiler {
+  /**
+   * Epoch of when compilation started
+   */
  private start = Date.now()
-  private env = { ...process.env }
-  private bundle: Bundle
  private compileStep: LogStep | undefined
  public log = new Logger(this.options.loglevel)
+  /**
+   * Copy of process.env
+   */
+  public env = { ...process.env }
+  /**
+   * Virtual FileSystem
+   */
+  public bundle: Bundle
+  /**
+   * Root directory for the source of the current build
+   */
  public src: string
+  /**
+   * In memory files that are being manipulated by the compiler
+   */
  public files: NexeFile[] = []
+  /**
+   * Standalone pieces of code run before the application entrypoint
+   */
  public shims: string[] = []
+  /**
+   * The last shim (defaults to "require('module').runMain()")
+   */
  public startup: string = ''
+  /**
+   * The main entrypoint filename for your application - eg. node mainFile.js
+   */
  public entrypoint: string | undefined
-  public bundledInput?: string
+  /**
+   * Not used
+   */
  public targets: NexeTarget[]
+  /**
+   * Current target of the compiler
+   */
  public target: NexeTarget
+  /**
+   * Output filename (-o myapp.exe)
+   */
  public output = this.options.output
-  private nodeSrcBinPath: string
+  /**
+   * Flag to indicate whether or notstdin was used for input
+   */
+  public stdinUsed = false
+  /**
+   * Path to the configure script
+   */
+  public configureScript: string
+  /**
+   * The file path of node binary
+   */
+  public nodeSrcBinPath: string
+  /**
+   * Remote asset path if available
+   */
+  public remoteAsset: string

  constructor(public options: NexeOptions) {
    const { python } = (this.options = options)
+    //SOMEDAY iterate over multiple targets with `--outDir`
    this.targets = options.targets as NexeTarget[]
    this.target = this.targets[0]
+    if (!/https?\:\/\//.test(options.remote)) {
+      throw new NexeError(`Invalid remote URI scheme (must be http or https): ${options.remote}`)
+    }
+    this.remoteAsset = options.remote + this.target.toString()
    this.src = join(this.options.temp, this.target.version)
+    this.configureScript = configure + (semverGt(this.target.version, '10.10.0') ? '.py' : '')
    this.nodeSrcBinPath = isWindows
      ? join(this.src, 'Release', 'node.exe')
      : join(this.src, 'out', 'Release', 'node')
@@ -67,31 +136,23 @@ export class NexeCompiler {
  }

  @bound
-  addResource(file: string, content?: Buffer | string) {
-    return this.bundle.addResource(file, content)
-  }
-
-  get binaryConfiguration() {
-    return { resources: this.bundle.index }
-  }
-
-  get resourceSize() {
-    return this.bundle.blobSize
+  addResource(absoluteFileName: string, content?: Buffer | string | File) {
+    return this.bundle.addResource(absoluteFileName, content)
  }

  @bound
  async readFileAsync(file: string) {
    this.assertBuild()
-    let cachedFile = this.files.find(x => normalize(x.filename) === normalize(file))
+    let cachedFile = this.files.find((x) => normalize(x.filename) === normalize(file))
    if (!cachedFile) {
      const absPath = join(this.src, file)
      cachedFile = {
        absPath,
        filename: file,
-        contents: await readFileAsync(absPath, 'utf-8').catch(x => {
+        contents: await readFileAsync(absPath, 'utf-8').catch((x) => {
          if (x.code === 'ENOENT') return ''
          throw x
-        })
+        }),
      }
      this.files.push(cachedFile)
    }
@@ -105,30 +166,33 @@ export class NexeCompiler {
  }

  @bound
-  async replaceInFileAsync(file: string, replace: string | RegExp, value: string) {
+  async replaceInFileAsync(file: string, replace: string | RegExp, value: string | StringReplacer) {
    const entry = await this.readFileAsync(file)
-    entry.contents = entry.contents.replace(replace, value)
+    entry.contents = entry.contents.toString().replace(replace, value as any)
  }

  @bound
-  async setFileContentsAsync(file: string, contents: string) {
+  async setFileContentsAsync(file: string, contents: string | Buffer) {
    const entry = await this.readFileAsync(file)
    entry.contents = contents
  }

-  quit() {
+  quit(error?: any) {
    const time = Date.now() - this.start
-    this.log.write(`Finished in ${time / 1000}s`)
+    this.log.write(`Finished in ${time / 1000}s`, error ? 'red' : 'green')
    return this.log.flush()
  }

  assertBuild() {
    if (!this.options.build) {
-      throw new Error('This feature is only available with `--build`')
+      throw new NexeError('This feature is only available with `--build`')
    }
  }

  public getNodeExecutableLocation(target?: NexeTarget) {
+    if (this.options.asset) {
+      return resolve(this.options.cwd, this.options.asset)
+    }
    if (target) {
      return join(this.options.temp, target.toString())
    }
@@ -139,11 +203,11 @@ export class NexeCompiler {
    if (this.log.verbose) {
      this.compileStep!.pause()
    }
-    return new Promise((resolve, reject) => {
+    return new Promise<void>((resolve, reject) => {
      spawn(command, args, {
        cwd: this.src,
        env: this.env,
-        stdio: this.log.verbose ? 'inherit' : 'ignore'
+        stdio: this.log.verbose ? 'inherit' : 'ignore',
      })
        .once('error', (e: Error) => {
          if (this.log.verbose) {
@@ -157,7 +221,7 @@ export class NexeCompiler {
          }
          if (code != 0) {
            const error = `${command} ${args.join(' ')} exited with code: ${code}`
-            reject(new Error(error))
+            reject(new NexeError(error))
          }
          resolve()
        })
@@ -165,13 +229,16 @@ export class NexeCompiler {
  }

  private _configureAsync() {
+    if (isWindows && semverGt(this.target.version, '10.15.99')) {
+      return Promise.resolve()
+    }
    return this._runBuildCommandAsync(this.env.PYTHON || 'python', [
-      configure,
-      ...this.options.configure
+      this.configureScript,
+      ...this.options.configure,
    ])
  }

-  private async _buildAsync() {
+  public async build(): Promise<ReadStream> {
    this.compileStep!.log(
      `Configuring node build${
        this.options.configure.length ? ': ' + this.options.configure : '...'
@@ -186,37 +253,21 @@ export class NexeCompiler {
    return createReadStream(this.getNodeExecutableLocation())
  }

-  private async _fetchPrebuiltBinaryAsync(target: NexeTarget) {
-    let downloadOptions = this.options.downloadOptions
+  private async _shouldCompileBinaryAsync(binary: NodeJS.ReadableStream | null, location: string) {
+    //SOMEDAY combine make/configure/vcBuild/and modified times of included files
+    const { snapshot, build } = this.options

-    if (this.options.ghToken) {
-      downloadOptions = Object.assign({}, downloadOptions)
-      downloadOptions.headers = Object.assign({}, downloadOptions.headers, {
-        Authorization: 'token ' + this.options.ghToken
-      })
+    if (!binary) {
+      return true
    }

-    const githubRelease = await getLatestGitRelease(downloadOptions)
-    const assetName = target.toString()
-    const asset = githubRelease.assets.find(x => x.name === assetName)
-
-    if (!asset) {
-      throw new Error(`${assetName} not available, create it using the --build flag`)
+    if (build && snapshot != null && (await pathExistsAsync(snapshot))) {
+      const snapshotLastModified = (await statAsync(snapshot)).mtimeMs
+      const binaryLastModified = (await statAsync(location)).mtimeMs
+      return snapshotLastModified > binaryLastModified
    }
-    const filename = this.getNodeExecutableLocation(target)

-    await download(asset.browser_download_url, dirname(filename), this.options.downloadOptions).on(
-      'response',
-      (res: IncomingMessage) => {
-        const total = +res.headers['content-length']!
-        let current = 0
-        res.on('data', data => {
-          current += data.length
-          this.compileStep!.modify(`Downloading...${((current / total) * 100).toFixed()}%`)
-        })
-      }
-    )
-    return createReadStream(filename)
+    return false
  }

  async compileAsync(target: NexeTarget) {
@@ -224,37 +275,36 @@ export class NexeCompiler {
    const build = this.options.build
    const location = this.getNodeExecutableLocation(build ? undefined : target)
    let binary = (await pathExistsAsync(location)) ? createReadStream(location) : null
-    if (!build && !binary) {
-      step.modify('Fetching prebuilt binary')
-      binary = await this._fetchPrebuiltBinaryAsync(target)
-    }
-    if (!binary) {
-      binary = await this._buildAsync()
+
+    if (await this._shouldCompileBinaryAsync(binary, location)) {
+      binary = await this.build()
      step.log('Node binary compiled')
    }
-    return this._assembleDeliverable(binary)
+    return this._assembleDeliverable(binary!)
  }

  code() {
    return [this.shims.join(''), this.startup].join(';')
  }

-  private _assembleDeliverable(binary: NodeJS.ReadableStream) {
+  private async _assembleDeliverable(binary: NodeJS.ReadableStream) {
    if (!this.options.mangle) {
      return binary
    }
+    const resources = this.bundle.renderIndex()
+    this.shims.unshift(wrap(`process.__nexe = ${JSON.stringify({ resources })};\n`))

-    const startup = this.code(),
-      codeSize = Buffer.byteLength(startup)
+    const code = this.code(),
+      codeSize = Buffer.byteLength(code),
+      lengths = Buffer.from(Array(16))

-    const lengths = Buffer.from(Array(16))
    lengths.writeDoubleLE(codeSize, 0)
-    lengths.writeDoubleLE(this.bundle.blobSize, 8)
-    return combineStreams([
+    lengths.writeDoubleLE(this.bundle.size, 8)
+    return new (MultiStream as any)([
      binary,
-      toStream(startup),
+      toStream(code),
      this.bundle.toStream(),
-      toStream(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths]))
+      toStream(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths])),
    ])
  }
 }
@@ -1,15 +1,20 @@
-const __nexe_patches = (process.nexe = { patches: {} }).patches
-function __nexe_noop_patch(original, ...args) {
-  return original.call(this, ...args)
-}
-function __nexe_patch(obj, method, patch) {
-  const original = obj[method]
-  if (!original) return
-  __nexe_patches[method] = patch
-  obj[method] = function( ...args) {
-    return __nexe_patches[method].call(this, original, ...args)
+if (true) {
+  const __nexe_patches = (process.nexe = { patches: {} }).patches
+  const slice = [].slice
+  const __nexe_noop_patch = function (original) {
+    const args = slice.call(arguments, 1)
+    return original.apply(this, args)
  }
+  const __nexe_patch = function (obj, method, patch) {
+    const original = obj[method]
+    if (!original) return
+    __nexe_patches[method] = patch
+    obj[method] = function() {
+      const args = [original].concat(slice.call(arguments))
+      return __nexe_patches[method].apply(this, args)
+    }
+  }
+  __nexe_patch((process).binding('fs'), 'internalModuleReadFile', __nexe_noop_patch)
+  __nexe_patch((process).binding('fs'), 'internalModuleReadJSON', __nexe_noop_patch)
+  __nexe_patch((process).binding('fs'), 'internalModuleStat', __nexe_noop_patch)
 }
-__nexe_patch((process).binding('fs'), 'internalModuleReadFile', __nexe_noop_patch)
-__nexe_patch((process).binding('fs'), 'internalModuleReadJSON', __nexe_noop_patch)
-__nexe_patch((process).binding('fs'), 'internalModuleStat', __nexe_noop_patch)
@@ -1,70 +1,159 @@
-import { stat as getStat, Stats, createReadStream } from 'fs'
+import * as fs from 'fs'
+import { promisify } from 'util'
 import { relative } from 'path'
 import { Readable } from 'stream'
-import combineStreams = require('multistream')
+import { argv } from '../options'
+import { File } from 'resolve-dependencies'
+import MultiStream = require('multistream')

-const stat = (file: string): Promise<Stats> => {
-  return new Promise((resolve, reject) => {
-    getStat(file, (err, stats) => (err ? reject(err) : resolve(stats)))
-  })
-}
+const lstat = promisify(fs.lstat),
+  realpath = promisify(fs.realpath),
+  createReadStream = fs.createReadStream,
+  stat = promisify(fs.stat)
+
+export type MultiStreams = (Readable | (() => Readable))[]

 function makeRelative(cwd: string, path: string) {
  return './' + relative(cwd, path)
 }

+function sortEntry(a: [string, File], b: [string, File]) {
+  return a[0] > b[0] ? 1 : -1
+}
+
 export function toStream(content: Buffer | string) {
-  const readable = new Readable({ read() {} })
-  readable.push(content)
-  readable.push(null)
+  const readable = new Readable({
+    read() {
+      this.push(content)
+      this.push(null)
+    },
+  })
  return readable
 }

-export type File = { absPath: string; contents: string; deps: FileMap }
-export type FileMap = { [absPath: string]: File | null }
-
-export interface BundleOptions {
-  entries: string[]
-  cwd: string
-  expand: boolean
-  loadContent: boolean
-  files: FileMap
+async function createFile(absoluteFileName: string) {
+  const stats = await lstat(absoluteFileName),
+    file: File = {
+      size: stats.size,
+      moduleType: 'commonjs',
+      contents: '',
+      absPath: absoluteFileName,
+      deps: {},
+    }
+  if (stats.isSymbolicLink()) {
+    file.size = stats.size
+    const [realPath, realStat] = await Promise.all([
+      realpath(absoluteFileName),
+      stat(absoluteFileName),
+    ])
+    file.realPath = realPath
+    file.realSize = realStat.size
+  }
+  return file
 }

 export class Bundle {
+  size = 0
+  cwd: string
+  rendered = false
+  private offset = 0
+  private index: { [key: string]: [number, number] } = {}
+  private files: { [key: string]: File } = {}
+  streams: MultiStreams = []
  constructor({ cwd }: { cwd: string } = { cwd: process.cwd() }) {
    this.cwd = cwd
  }
-  cwd: string
-  blobSize: number = 0
-  index: { [relativeFilePath: string]: [number, number] } = {}
-  streams: (Readable | (() => Readable))[] = []

-  async addResource(absoluteFileName: string, content?: Buffer | string) {
-    let length = 0
-    if (content !== undefined) {
-      length = Buffer.byteLength(content)
-    } else {
-      const stats = await stat(absoluteFileName)
-      length = stats.size
-    }
-
-    const start = this.blobSize
-
-    this.blobSize += length
-    this.index[makeRelative(this.cwd, absoluteFileName)] = [start, length]
-    this.streams.push(() => (content ? toStream(content) : createReadStream(absoluteFileName)))
+  get list() {
+    return Object.keys(this.files)
  }

-  concat() {
-    throw new Error('Not Implemented')
+  public async addResource(
+    absoluteFileName: string,
+    content?: File | Buffer | string
+  ): Promise<number> {
+    if (this.files[absoluteFileName]) {
+      return this.size
+    }
+    if (typeof content === 'string' || Buffer.isBuffer(content)) {
+      this.files[absoluteFileName] = {
+        size: Buffer.byteLength(content),
+        moduleType: 'commonjs',
+        contents: content as any, //todo type is wrong here... should allow buffer
+        deps: {},
+        absPath: absoluteFileName,
+      }
+    } else if (content) {
+      this.files[content.absPath] = content
+    } else {
+      this.files[absoluteFileName] = {
+        absPath: absoluteFileName,
+        moduleType: 'commonjs',
+        contents: '',
+        deps: {},
+        size: 0,
+      }
+      this.files[absoluteFileName] = await createFile(absoluteFileName)
+    }
+    return (this.size += this.files[absoluteFileName].size)
+  }
+
+  /**
+   * De-dupe files by absolute path, partition by symlink/real
+   * Iterate over real, add entries
+   * Iterate over symlinks, add symlinks
+   */
+  renderIndex() {
+    if (this.rendered) {
+      throw new Error('Bundle index already rendered')
+    }
+    const files = Object.entries(this.files),
+      realFiles: [string, File][] = [],
+      symLinks: [string, File][] = []
+    for (const entry of files) {
+      if (entry[1].realPath) {
+        symLinks.push(entry)
+      } else {
+        realFiles.push(entry)
+      }
+    }
+    realFiles.sort(sortEntry)
+    symLinks.sort(sortEntry)
+
+    for (const [absPath, file] of realFiles) {
+      this.addEntry(absPath, file)
+    }
+    for (const [absPath, file] of symLinks) {
+      this.addEntry(file.realPath as string, file)
+      this.addEntry(absPath, file, file.realPath)
+    }
+    this.rendered = true
+    return this.index
+  }
+
+  /**
+   * Add a stream if needed and an entry with the required offset and size
+   * Ensure the calling order of this method is idempotent (eg, while iterating a sorted set)
+   * @param entryPath
+   * @param file
+   * @param useEntry
+   */
+  addEntry(entryPath: string, file: File, useEntry?: string) {
+    const existingName = useEntry && makeRelative(this.cwd, useEntry),
+      name = makeRelative(this.cwd, entryPath),
+      size = file.realSize ?? file.size,
+      existingEntry = this.index[existingName ?? name]
+
+    this.index[name] = existingEntry || [this.offset, size]
+    if (!existingEntry) {
+      this.streams.push(() =>
+        file.contents ? toStream(file.contents) : createReadStream(file.absPath)
+      )
+      this.offset += size
+    }
  }

  toStream() {
-    return combineStreams(this.streams)
-  }
-
-  toJSON() {
-    return this.index
+    return new (MultiStream as any)(this.streams)
  }
 }
@@ -1,4 +1,5 @@
 import { Stats } from 'fs'
+import { getLatestGitRelease } from '../releases'

 export interface NexeBinary {
  blobPath: string
@@ -13,90 +14,117 @@ export interface NexeBinary {
 }

 let originalFsMethods: any = null
-let nexeBinary: NexeBinary | null = null
+let lazyRestoreFs = () => {}

-function restoreFs(fs: any = require('fs')): NexeBinary | false {
-  if (!nexeBinary) {
-    return false
-  }
-  const source = nexeBinary
-  Object.assign(fs, originalFsMethods)
-  nexeBinary = originalFsMethods = null
-  return source
-}
+// optional Win32 file namespace prefix followed by drive letter and colon
+const windowsFullPathRegex = /^(\\{2}\?\\)?([a-zA-Z]):/
+
+const upcaseDriveLetter = (s: string): string =>
+  s.replace(windowsFullPathRegex, (_match, ns, drive) => `${ns || ''}${drive.toUpperCase()}:`)

 function shimFs(binary: NexeBinary, fs: any = require('fs')) {
  if (originalFsMethods !== null) {
    return
  }
  originalFsMethods = Object.assign({}, fs)
-  nexeBinary = binary
-  const { blobPath, resources: manifest } = binary
-  const { resourceStart, stat } = binary.layout
-  const directories: { [key: string]: { [key: string]: boolean } } = {},
+  const { blobPath, resources: manifest } = binary,
+    { resourceStart, stat } = binary.layout,
+    directories: { [key: string]: { [key: string]: boolean } } = {},
+    notAFile = '!@#$%^&*',
+    isWin = process.platform.startsWith('win'),
    isString = (x: any): x is string => typeof x === 'string' || x instanceof String,
-    isNotFile = () => false,
-    isNotDirectory = isNotFile,
-    isFile = () => true,
    noop = () => {},
-    isDirectory = isFile,
-    path = require('path')
+    path = require('path'),
+    winPath: (key: string) => string = isWin ? upcaseDriveLetter : (s) => s,
+    baseDir = winPath(path.dirname(process.execPath))

-  let log = (text: string) => {
-    if ((process.env.DEBUG || '').toLowerCase().includes('nexe:require')) {
-      process.stderr.write('[nexe] - ' + text + '\n')
-    } else {
-      log = noop
-    }
-  }
-
-  const getKey = process.platform.startsWith('win')
-    ? function getKey(filepath: string): string {
-        let key = path.resolve(filepath)
-        if (key.substr(1, 2) === ':\\') {
-          key = key[0].toUpperCase() + key.substr(1)
-        }
-        return key
+  let log = (_: string) => true
+  let loggedManifest = false
+  if ((process.env.DEBUG || '').toLowerCase().includes('nexe:require')) {
+    log = (text: string) => {
+      setupManifest()
+      if (!loggedManifest) {
+        process.stderr.write('[nexe] - MANIFEST' + JSON.stringify(manifest, null, 4) + '\n')
+        process.stderr.write('[nexe] - DIRECTORIES' + JSON.stringify(directories, null, 4) + '\n')
+        loggedManifest = true
      }
-    : path.resolve
+      return process.stderr.write('[nexe] - ' + text + '\n')
+    }
+  }

-  const statTime = function() {
+  const getKey = function getKey(filepath: string | Buffer | null): string {
+    if (Buffer.isBuffer(filepath)) {
+      filepath = filepath.toString()
+    }
+    if (!isString(filepath)) {
+      return notAFile
+    }
+    let key = path.resolve(baseDir, filepath)
+
+    return winPath(key)
+  }
+
+  const statTime = function () {
    return {
-      dev: 0,
-      ino: 0,
-      nlink: 0,
-      rdev: 0,
-      uid: 123,
-      gid: 500,
-      blksize: 4096,
-      blocks: 0,
      atime: new Date(stat.atime),
-      atimeMs: stat.atime.getTime(),
      mtime: new Date(stat.mtime),
-      mtimeMs: stat.mtime.getTime(),
      ctime: new Date(stat.ctime),
-      ctimMs: stat.ctime.getTime(),
      birthtime: new Date(stat.birthtime),
-      birthtimeMs: stat.birthtime.getTime()
    }
  }

-  const createStat = function(directoryExtensions: any, fileExtensions?: any) {
-    if (!fileExtensions) {
-      return Object.assign({}, binary.layout.stat, directoryExtensions, { size: 0 }, statTime())
+  let BigInt: Function
+  try {
+    BigInt = eval('BigInt')
+  } catch (ignored) {}
+
+  const minBlocks = Math.max(Math.ceil(stat.blksize / 512), 1)
+  const createStat = function (extensions: any, options: any) {
+    const stat = Object.assign(new fs.Stats(), binary.layout.stat, statTime(), extensions)
+    if ('size' in extensions) {
+      //Assume non adjustable allocation size for file system
+      stat.blocks = Math.ceil(stat.size / stat.blksize) * minBlocks
    }
-    const size = directoryExtensions[1]
-    return Object.assign({}, binary.layout.stat, fileExtensions, { size }, statTime())
+    if (options && options.bigint && typeof BigInt !== 'undefined') {
+      for (const k in stat) {
+        if (Object.prototype.hasOwnProperty.call(stat, k) && typeof stat[k] === 'number') {
+          stat[k] = BigInt(stat[k])
+        }
+      }
+    }
+    return stat
  }

-  const ownStat = function(filepath: string) {
+  const ownStat = function (filepath: any, options: any) {
    setupManifest()
    const key = getKey(filepath)
    if (directories[key]) {
-      return createStat({ isDirectory, isFile: isNotFile })
+      let mode = binary.layout.stat.mode
+      mode |= fs.constants.S_IFDIR
+      mode &= ~fs.constants.S_IFREG
+      return createStat({ mode, size: 0 }, options)
    }
    if (manifest[key]) {
-      return createStat(manifest[key], { isFile, isDirectory: isNotDirectory })
+      return createStat({ size: manifest[key][1] }, options)
+    }
+  }
+
+  const getStat = function (fn: string) {
+    return function stat(filepath: string | Buffer, options: any, callback: any) {
+      let stat: any
+      if (typeof options === 'function') {
+        callback = options
+        stat = ownStat(filepath, null)
+      } else {
+        stat = ownStat(filepath, options)
+      }
+      if (stat) {
+        process.nextTick(() => {
+          callback(null, stat)
+        })
+      } else {
+        return originalFsMethods[fn].apply(fs, arguments)
+      }
    }
  }

@@ -109,11 +137,11 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
  }

  let setupManifest = () => {
-    Object.keys(manifest).forEach(filepath => {
+    Object.keys(manifest).forEach((filepath) => {
      const entry = manifest[filepath]
      const absolutePath = getKey(filepath)
      const longPath = makeLong(absolutePath)
-      const normalizedPath = path.normalize(filepath)
+      const normalizedPath = winPath(path.normalize(filepath))

      if (!manifest[absolutePath]) {
        manifest[absolutePath] = entry
@@ -139,6 +167,8 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
        currentDir = path.dirname(currentDir)
      }
    })
+    ;(manifest[notAFile] as any) = false
+    ;(directories[notAFile] as any) = false
    setupManifest = noop
  }

@@ -163,32 +193,26 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
    realpathSync: function realpathSync(filepath: any, options: any) {
      setupManifest()
      const key = getKey(filepath)
-      if (isString(filepath) && (manifest[filepath] || manifest[key])) {
+      if (manifest[key]) {
        return filepath
      }
      return originalFsMethods.realpathSync.call(fs, filepath, options)
    },
    readdir: function readdir(filepath: string | Buffer, options: any, callback: any) {
      setupManifest()
-      filepath = filepath.toString()
-      if ('function' === typeof options) {
-        callback = options
-        options = { encoding: 'utf8' }
-      }
      const dir = directories[getKey(filepath)]
      if (dir) {
-        process.nextTick(() => {
-          //todo merge with original?
-          callback(null, Object.keys(dir))
-        })
+        if ('function' === typeof options) {
+          callback = options
+          options = { encoding: 'utf8' }
+        }
+        process.nextTick(() => callback(null, Object.keys(dir)))
      } else {
        return originalFsMethods.readdir.apply(fs, arguments)
      }
    },
-
    readdirSync: function readdirSync(filepath: string | Buffer, options: any) {
      setupManifest()
-      filepath = filepath.toString()
      const dir = directories[getKey(filepath)]
      if (dir) {
        return Object.keys(dir)
@@ -198,8 +222,8 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {

    readFile: function readFile(filepath: any, options: any, callback: any) {
      setupManifest()
-      const entry = manifest[filepath] || manifest[getKey(filepath)]
-      if (!entry || !isString(filepath)) {
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
        return originalFsMethods.readFile.apply(fs, arguments)
      }
      const [offset, length] = entry
@@ -207,82 +231,82 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
      const encoding = fileOpts(options).encoding
      callback = typeof options === 'function' ? options : callback

-      fs.open(blobPath, 'r', function(err: Error, fd: number) {
+      originalFsMethods.open(blobPath, 'r', function (err: Error, fd: number) {
        if (err) return callback(err, null)
-        fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function(
-          error: Error,
-          bytesRead: number,
-          result: Buffer
-        ) {
-          if (error) {
-            return fs.close(fd, function() {
-              callback(error, null)
+        originalFsMethods.read(
+          fd,
+          Buffer.alloc(length),
+          0,
+          length,
+          resourceOffset,
+          function (error: Error, bytesRead: number, result: Buffer) {
+            if (error) {
+              return originalFsMethods.close(fd, function () {
+                callback(error, null)
+              })
+            }
+            originalFsMethods.close(fd, function (err: Error) {
+              if (err) {
+                return callback(err, result)
+              }
+              callback(err, encoding ? result.toString(encoding) : result)
            })
          }
-          fs.close(fd, function(err: Error) {
-            if (err) {
-              return callback(err, result)
-            }
-            callback(err, encoding ? result.toString(encoding) : result)
-          })
-        })
+        )
      })
    },
    createReadStream: function createReadStream(filepath: any, options: any) {
      setupManifest()
-      const entry = manifest[filepath] || manifest[getKey(filepath)]
-      if (!entry || !isString(filepath)) {
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
        return originalFsMethods.createReadStream.apply(fs, arguments)
      }
      const [offset, length] = entry
      const resourceOffset = resourceStart + offset
      const opts = fileOpts(options)

-      return fs.createReadStream(
+      return originalFsMethods.createReadStream(
        blobPath,
        Object.assign({}, opts, {
          start: resourceOffset,
-          end: resourceOffset + length - 1
+          end: resourceOffset + length - 1,
        })
      )
    },
    readFileSync: function readFileSync(filepath: any, options: any) {
      setupManifest()
-
-      const entry = manifest[filepath] || manifest[getKey(filepath)]
-      if (!entry || !isString(filepath)) {
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
        return originalFsMethods.readFileSync.apply(fs, arguments)
      }
      const [offset, length] = entry
      const resourceOffset = resourceStart + offset
      const encoding = fileOpts(options).encoding
-      const fd = fs.openSync(process.execPath, 'r')
+      const fd = originalFsMethods.openSync(process.execPath, 'r')
      const result = Buffer.alloc(length)
-      fs.readSync(fd, result, 0, length, resourceOffset)
-      fs.closeSync(fd)
+      originalFsMethods.readSync(fd, result, 0, length, resourceOffset)
+      originalFsMethods.closeSync(fd)
      return encoding ? result.toString(encoding) : result
    },
-    statSync: function statSync(filepath: string | Buffer) {
-      const stat = isString(filepath) && ownStat(filepath)
+    statSync: function statSync(filepath: string | Buffer, options: any) {
+      const stat = ownStat(filepath, options)
      if (stat) {
        return stat
      }
      return originalFsMethods.statSync.apply(fs, arguments)
    },
-    stat: function stat(filepath: string | Buffer, callback: any) {
-      const stat = isString(filepath) && ownStat(filepath)
+    stat: getStat('stat'),
+    lstat: getStat('lstat'),
+    lstatSync: function statSync(filepath: string | Buffer, options: any) {
+      const stat = ownStat(filepath, options)
      if (stat) {
-        process.nextTick(() => {
-          callback(null, stat)
-        })
-      } else {
-        return originalFsMethods.stat.apply(fs, arguments)
+        return stat
      }
-    }
+      return originalFsMethods.lstatSync.apply(fs, arguments)
+    },
  }
-
  if (typeof fs.exists === 'function') {
-    nfs.exists = function(filepath: string, cb: Function) {
+    nfs.exists = function (filepath: string, cb: Function) {
      cb = cb || noop
      const exists = nfs.existsSync(filepath)
      process.nextTick(() => cb(exists))
@@ -291,9 +315,9 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {

  const patches = (process as any).nexe.patches || {}
  delete (process as any).nexe
-  patches.internalModuleReadFile = function(this: any, original: any, ...args: any[]) {
-    const [filepath] = args
+  patches.internalModuleReadFile = function (this: any, original: any, ...args: any[]) {
    setupManifest()
+    const filepath = getKey(args[0])
    if (manifest[filepath]) {
      log('read     (hit)              ' + filepath)
      return nfs.readFileSync(filepath, 'utf-8')
@@ -301,9 +325,17 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
    log('read          (miss)       ' + filepath)
    return original.call(this, ...args)
  }
-  patches.internalModuleStat = function(this: any, original: any, ...args: any[]) {
+  let returningArray: boolean
+  patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
+    if (returningArray == null) returningArray = Array.isArray(original.call(this, ''))
+    const res = patches.internalModuleReadFile.call(this, original, ...args)
+    return returningArray && !Array.isArray(res)
+      ? [res, /"(main|name|type|exports|imports)"/.test(res)]
+      : res
+  }
+  patches.internalModuleStat = function (this: any, original: any, ...args: any[]) {
    setupManifest()
-    const [filepath] = args
+    const filepath = getKey(args[0])
    if (manifest[filepath]) {
      log('stat     (hit)              ' + filepath + '   ' + 0)
      return 0
@@ -324,7 +356,7 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
  }

  if (typeof fs.exists === 'function') {
-    nfs.exists = function(filepath: string, cb: Function) {
+    nfs.exists = function (filepath: string, cb: Function) {
      cb = cb || noop
      const exists = nfs.existsSync(filepath)
      if (!exists) {
@@ -333,8 +365,72 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
      process.nextTick(() => cb(exists))
    }
  }
+
+  if (typeof fs.copyFile === 'function') {
+    nfs.copyFile = function (filepath: string, dest: string, flags: number, callback: Function) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.copyFile.apply(fs, arguments)
+      }
+      if (typeof flags === 'function') {
+        callback = flags
+        flags = 0
+      }
+      nfs.readFile(filepath, (err: any, buffer: any) => {
+        if (err) {
+          return callback(err)
+        }
+        originalFsMethods.writeFile(dest, buffer, (err: any) => {
+          if (err) {
+            return callback(err)
+          }
+          callback(null)
+        })
+      })
+    }
+    nfs.copyFileSync = function (filepath: string, dest: string) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.copyFileSync.apply(fs, arguments)
+      }
+      return originalFsMethods.writeFileSync(dest, nfs.readFileSync(filepath))
+    }
+  }
+
+  if (typeof fs.realpath.native === 'function') {
+    nfs.realpath.native = function realpathNative(filepath: any, options: any, cb: any): void {
+      setupManifest()
+      const key = getKey(filepath)
+      if (isString(filepath) && (manifest[filepath] || manifest[key])) {
+        return process.nextTick(() => cb(null, filepath))
+      }
+      return originalFsMethods.realpath.native.call(fs, filepath, options, cb)
+    }
+    nfs.realpathSync.native = function realpathSyncNative(filepath: any, options: any) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (manifest[key]) {
+        return filepath
+      }
+      return originalFsMethods.realpathSync.native.call(fs, filepath, options)
+    }
+  }
+
  Object.assign(fs, nfs)
+
+  lazyRestoreFs = () => {
+    Object.keys(nfs).forEach((key) => {
+      fs[key] = originalFsMethods[key]
+    })
+    lazyRestoreFs = () => {}
+  }
  return true
 }

+function restoreFs() {
+  lazyRestoreFs()
+}
+
 export { shimFs, restoreFs }
@@ -1,5 +1,5 @@
-import colors = require('chalk')
-import ora = require('ora')
+import colors from 'chalk'
+import ora from 'ora'

 const frameLength = 120

@@ -24,7 +24,7 @@ export class Logger {
      this.ora = ora({
        text: 'Starting...',
        color: 'blue',
-        spinner: 'dots'
+        spinner: 'dots',
      })
      this.ora.stop()
    }
@@ -35,7 +35,7 @@ export class Logger {

  flush() {
    !this.silent && this.ora.succeed()
-    return new Promise(resolve => setTimeout(resolve, frameLength))
+    return new Promise((resolve) => setTimeout(resolve, frameLength))
  }

  _write(update: string, color = 'green') {
@@ -66,7 +66,7 @@ export class Logger {
      modify: this.modify,
      log: this.verbose ? this.write : this.modify,
      pause: () => this.ora.stopAndPersist(),
-      resume: () => this.ora.start()
+      resume: () => this.ora.start(),
    } as LogStep
  }
 }
@@ -1,6 +1,6 @@
 import { EOL } from 'os'
 import { compose } from 'app-builder'
-import { NexeCompiler } from './compiler'
+import { NexeCompiler, NexeError } from './compiler'
 import { normalizeOptions, NexeOptions, NexePatch } from './options'
 import resource from './steps/resource'
 import clean from './steps/clean'
@@ -15,31 +15,29 @@ async function compile(
  compilerOptions?: Partial<NexeOptions>,
  callback?: (err: Error | null) => void
 ) {
-  const options = normalizeOptions(compilerOptions)
-  const compiler = new NexeCompiler(options)
+  let error: Error | null = null,
+    options: NexeOptions | null = null,
+    compiler: NexeCompiler | null = null

-  const nexe = compose(
-    clean,
-    resource,
-    cli,
-    bundle,
-    shim,
-    options.build ? [download, artifacts, ...patches, ...(options.patches as NexePatch[])] : [],
-    options.plugins as NexePatch[]
-  )
-
-  let error = null
  try {
-    await nexe(compiler)
-  } catch (e) {
+    options = normalizeOptions(compilerOptions)
+    compiler = new NexeCompiler(options)
+    await compose(
+      clean,
+      resource,
+      cli,
+      bundle,
+      shim,
+      download,
+      options.build ? [artifacts, ...patches, ...(options.patches as NexePatch[])] : [],
+      options.plugins as NexePatch[]
+    )(compiler)
+  } catch (e: any) {
    error = e
  }

  if (error) {
-    if (compiler.options.loglevel !== 'silent' && error) {
-      process.stderr.write(EOL + error.message + EOL)
-    }
-    compiler.quit()
+    compiler && compiler.quit(error)
    if (callback) return callback(error)
    return Promise.reject(error)
  }
@@ -1,11 +1,11 @@
 import * as parseArgv from 'minimist'
-import { NexeCompiler } from './compiler'
-import { isWindows } from './util'
+import { NexeCompiler, NexeError } from './compiler'
+import { isWindows, STDIN_FLAG } from './util'
 import { basename, extname, join, isAbsolute, resolve } from 'path'
 import { getTarget, NexeTarget } from './target'
 import { EOL, homedir } from 'os'
 import chalk from 'chalk'
-import { resolveFileNameSync } from 'resolve-dependencies'
+import { resolveSync } from 'resolve-dependencies'
 const caw = require('caw')
 const c = process.platform === 'win32' ? chalk.constructor({ enabled: false }) : chalk

@@ -21,7 +21,10 @@ export interface NexeOptions {
  output: string
  targets: (string | NexeTarget)[]
  name: string
+  remote: string
+  asset: string
  cwd: string
+  fs: boolean | string[]
  flags: string[]
  configure: string[]
  vcBuild: string[]
@@ -35,11 +38,6 @@ export interface NexeOptions {
  patches: (string | NexePatch)[]
  plugins: (string | NexePatch)[]
  native: any
-  /**
-   * @deprecated
-   * Use mangle: false instead
-   */
-  empty: boolean
  mangle: boolean
  ghToken: string
  sourceUrl?: string
@@ -53,7 +51,6 @@ export interface NexeOptions {
  ico?: string
  debugBundle?: boolean
  warmup?: string
-  compress?: boolean
  clean?: boolean
  /**
   * Api Only
@@ -64,26 +61,28 @@ export interface NexeOptions {
 const defaults = {
  flags: [],
  cwd: process.cwd(),
+  fs: true,
  configure: [],
+  mangle: true,
  make: [],
  targets: [],
  vcBuild: isWindows ? ['nosign', 'release'] : [],
  enableNodeCli: false,
-  compress: false,
  build: false,
  bundle: true,
  patches: [],
-  plugins: []
+  plugins: [],
+  remote: 'https://github.com/nexe/nexe/releases/download/v3.3.3/',
 }
 const alias = {
  i: 'input',
  o: 'output',
  v: 'version',
+  a: 'asset',
  t: 'target',
  b: 'build',
  n: 'name',
  r: 'resource',
-  a: 'resource',
  p: 'python',
  f: 'flag',
  c: 'configure',
@@ -91,7 +90,7 @@ const alias = {
  h: 'help',
  l: 'loglevel',
  'fake-argv': 'fakeArgv',
-  'gh-token': 'ghToken'
+  'gh-token': 'ghToken',
 }
 const argv = parseArgv(process.argv, { alias, default: { ...defaults } })
 let help = `
@@ -104,6 +103,7 @@ ${c.bold('nexe <entry-file> [options]')}
  -t   --target                     -- node version description
  -n   --name                       -- main app module name
  -r   --resource                   -- *embed files (glob) within the binary
+       --remote                     -- alternate location (URL) to download pre-built base (nexe) binaries from
       --plugin                     -- extend nexe runtime behavior

   ${c.underline.bold('Building from source:')}
@@ -113,7 +113,8 @@ ${c.bold('nexe <entry-file> [options]')}
  -f   --flag                       -- *v8 flags to include during compilation
  -c   --configure                  -- *arguments to the configure step
  -m   --make                       -- *arguments to the make/build step
-       --no-mangle                  -- used when generating base binaries, or when pathing _third_party_main manually.
+       --patch                      -- module with middleware default export for adding a build patch
+       --no-mangle                  -- used when generating base binaries, or when patching _third_party_main manually
       --snapshot                   -- path to a warmup snapshot
       --ico                        -- file name for alternate icon file (windows)
       --rc-*                       -- populate rc file options (windows)
@@ -134,7 +135,7 @@ ${c.bold('nexe <entry-file> [options]')}
 help = EOL + help + EOL

 function flatten(...args: any[]): string[] {
-  return ([] as string[]).concat(...args).filter(x => x)
+  return ([] as string[]).concat(...args).filter((x) => x)
 }

 /**
@@ -145,16 +146,13 @@ function flatten(...args: any[]): string[] {
 */
 function extractCliMap(match: RegExp, options: any) {
  return Object.keys(options)
-    .filter(x => match.test(x))
-    .reduce(
-      (map: any, option: any) => {
-        const key = option.split('-')[1]
-        map[key] = options[option]
-        delete options[option]
-        return map
-      },
-      {} as any
-    )
+    .filter((x) => match.test(x))
+    .reduce((map: any, option: any) => {
+      const key = option.split('-')[1]
+      map[key] = options[option]
+      delete options[option]
+      return map
+    }, {} as any)
 }

 function extractLogLevel(options: NexeOptions) {
@@ -165,7 +163,7 @@ function extractLogLevel(options: NexeOptions) {
 }

 function isName(name: string) {
-  return name && name !== 'index'
+  return name && name !== 'index' && name !== STDIN_FLAG
 }

 function extractName(options: NexeOptions) {
@@ -194,31 +192,36 @@ function isEntryFile(filename?: string): filename is string {
  return Boolean(filename && !isAbsolute(filename))
 }

-export function resolveEntry(input: string, cwd: string, maybeEntry?: string) {
-  if (input === '-' || maybeEntry === '-') {
-    return ''
-  }
+export function resolveEntry(
+  input: string,
+  cwd: string,
+  maybeEntry: string | undefined,
+  bundle: boolean | string
+) {
  let result = null
+  if (input === '-' || maybeEntry === '-') {
+    return STDIN_FLAG
+  }
  if (input && isAbsolute(input)) {
    return input
  }
  if (input) {
    const inputPath = padRelative(input)
-    result = resolveFileNameSync(cwd, inputPath)
+    result = resolveSync(cwd, inputPath)
  }
-
  if (isEntryFile(maybeEntry) && (!result || !result.absPath)) {
    const inputPath = padRelative(maybeEntry)
-    result = resolveFileNameSync(cwd, inputPath)
+    result = resolveSync(cwd, inputPath)
  }
-  if (!process.stdin.isTTY) {
-    return ''
+  if (!process.stdin.isTTY && (!result || !result.absPath) && bundle === defaults.bundle) {
+    return STDIN_FLAG
  }
  if (!result || !result.absPath) {
-    result = resolveFileNameSync(cwd, '.')
+    result = resolveSync(cwd, '.')
+  }
+  if (!result.absPath) {
+    throw new NexeError(`Entry file "${input || ''}" not found!`)
  }
-  if (!result.absPath) throw new Error(`Entry file "${input}" not found!`)
-
  return result.absPath
 }

@@ -234,8 +237,8 @@ function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
    ? resolve(cwd, options.temp)
    : process.env.NEXE_TEMP || join(homedir(), '.nexe')
  const maybeEntry = isCli(input) ? argv._[argv._.length - 1] : undefined
-  options.input = resolveEntry(options.input, cwd, maybeEntry)
-  options.enableStdIn = isCli(input) && options.input === ''
+  options.input = resolveEntry(options.input, cwd, maybeEntry, options.bundle)
+  options.enableStdIn = isCli(input) && options.input === STDIN_FLAG
  options.name = extractName(options)
  options.loglevel = extractLogLevel(options)
  options.flags = flatten(opts.flag, options.flags)
@@ -244,10 +247,14 @@ function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
    options.targets.push(getTarget())
  }
  options.ghToken = options.ghToken || process.env.GITHUB_TOKEN || ''
-  options.make = flatten(options.vcBuild, options.make)
+  options.make = flatten(isWindows ? options.vcBuild : options.make)
  options.configure = flatten(options.configure)
  options.resources = flatten(opts.resource, options.resources)

+  if (!options.remote.endsWith('/')) {
+    options.remote += '/'
+  }
+
  options.downloadOptions = options.downloadOptions || {}
  options.downloadOptions.headers = options.downloadOptions.headers || {}
  options.downloadOptions.headers['User-Agent'] = 'nexe (https://www.npmjs.com/package/nexe)'
@@ -263,6 +270,21 @@ function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
      : `${options.output || options.name}`
  options.output = resolve(cwd, options.output)

+  const requireDefault = (x: string) => {
+    if (typeof x === 'string') {
+      return require(x).default
+    }
+    return x
+  }
+
+  options.mangle = 'mangle' in opts ? opts.mangle : true
+  options.plugins = flatten(opts.plugin, options.plugins).map(requireDefault)
+  options.patches = flatten(opts.patch, options.patches).map(requireDefault)
+
+  if ((!options.mangle && !options.bundle) || options.patches.length) {
+    options.build = true
+  }
+
  if (options.build) {
    const { arch } = options.targets[0] as NexeTarget
    if (isWindows) {
@@ -272,20 +294,9 @@ function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
    }
  }

-  const requireDefault = (x: string) => {
-    if (typeof x === 'string') {
-      return require(x).default
-    }
-    return x
-  }
-
-  options.mangle = 'mangle' in opts ? opts.mangle : !opts.empty
-  options.plugins = flatten(opts.plugin, options.plugins).map(requireDefault)
-  options.patches = flatten(opts.patch, options.patches).map(requireDefault)
-
  Object.keys(alias)
-    .filter(k => k !== 'rc')
-    .forEach(x => delete opts[x])
+    .filter((k) => k !== 'rc')
+    .forEach((x) => delete opts[x])

  return options
 }
@@ -1,29 +1,32 @@
 const fs = require('fs'),
  fd = fs.openSync(process.execPath, 'r'),
  stat = fs.statSync(process.execPath),
-  footer = Buffer.alloc(32, 0)
+  tailSize = Math.min(stat.size, 16000),
+  tailWindow = Buffer.from(Array(tailSize))

-fs.readSync(fd, footer, 0, 32, stat.size - 32)
+fs.readSync(fd, tailWindow, 0, tailSize, stat.size - tailSize)

-if (!footer.slice(0, 16).equals(Buffer.from('<nexe~~sentinel>'))) {
+const footerPosition = tailWindow.indexOf('<nexe~~sentinel>')
+if (footerPosition == -1) {
  throw 'Invalid Nexe binary'
 }

-const contentSize = footer.readDoubleLE(16),
+const footer = tailWindow.slice(footerPosition, footerPosition + 32),
+  contentSize = footer.readDoubleLE(16),
  resourceSize = footer.readDoubleLE(24),
-  contentStart = stat.size - 32 - resourceSize - contentSize,
+  contentStart = stat.size - tailSize + footerPosition - resourceSize - contentSize,
  resourceStart = contentStart + contentSize

 Object.defineProperty(
  process,
  '__nexe',
-  (function() {
+  (function () {
    let nexeHeader: any = null
    return {
-      get: function() {
+      get: function () {
        return nexeHeader
      },
-      set: function(value: any) {
+      set: function (value: any) {
        if (nexeHeader) {
          throw new Error('This property is readonly')
        }
@@ -34,13 +37,13 @@ Object.defineProperty(
            contentSize,
            contentStart,
            resourceSize,
-            resourceStart
-          }
+            resourceStart,
+          },
        })
        Object.freeze(nexeHeader)
      },
      enumerable: false,
-      configurable: false
+      configurable: false,
    }
  })()
 )
@@ -1,20 +1,44 @@
 import { NexeCompiler } from '../compiler'
+import { semverGt } from '../util'

 export default async function disableNodeCli(compiler: NexeCompiler, next: () => Promise<void>) {
  if (compiler.options.enableNodeCli) {
    return next()
  }

-  const nodeccMarker = 'argv[index][0] =='
+  if (semverGt(compiler.target.version, '11.6.0')) {
+    await compiler.replaceInFileAsync(
+      'src/node.cc',
+      /(?<!int )ProcessGlobalArgs\(argv[^;]*;/gm,
+      '0;/*$&*/'
+    )
+  } else if (semverGt(compiler.target.version, '10.9')) {
+    await compiler.replaceInFileAsync('src/node.cc', /(?<!void )ProcessArgv\(argv/g, '//$&')
+  } else if (semverGt(compiler.target.version, '9.999')) {
+    await compiler.replaceInFileAsync(
+      'src/node.cc',
+      'int i = 1; i < v8_argc; i++',
+      'int i = v8_argc; i < v8_argc; i++'
+    )
+    let matches = 0
+    await compiler.replaceInFileAsync('src/node.cc', /v8_argc > 1/g, (match) => {
+      if (matches++) {
+        return 'false'
+      }
+      return match
+    })
+  } else {
+    const nodeccMarker = 'argv[index][0] =='

-  await compiler.replaceInFileAsync(
-    'src/node.cc',
-    `${nodeccMarker} '-'`,
-    // allow NODE_OPTIONS, introduced in 8.0
-    parseInt(compiler.target.version.split('.')[0]) >= 8
-      ? `(${nodeccMarker} (is_env ? '-' : ']'))`
-      : `(${nodeccMarker} ']')`
-  )
+    await compiler.replaceInFileAsync(
+      'src/node.cc',
+      `${nodeccMarker} '-'`,
+      // allow NODE_OPTIONS, introduced in 8.0
+      semverGt(compiler.target.version, '7.99')
+        ? `(${nodeccMarker} (is_env ? '-' : ']'))`
+        : `(${nodeccMarker} ']')`
+    )
+  }

  return next()
 }
@@ -13,8 +13,8 @@ export default async function nodeGyp(
    `
    ${nodeGypMarker}
    ${files
-      .filter(x => x.filename.startsWith('lib'))
-      .map(x => `'${x.filename}'`)
+      .filter((x) => x.filename.startsWith('lib'))
+      .map((x) => `'${x.filename}'`)
      .toString()},
  `.trim()
  )
@@ -5,7 +5,8 @@ import cli from './disable-node-cli'
 import flags from './flags'
 import ico from './ico'
 import rc from './node-rc'
+import snapshot from './snapshot'

-const patches = [gyp, bootNexe, buildFixes, cli, flags, ico, rc]
+const patches = [gyp, bootNexe, buildFixes, cli, flags, ico, rc, snapshot]

 export default patches
@@ -8,18 +8,19 @@ export default async function nodeRc(compiler: NexeCompiler, next: () => Promise

  const file = await compiler.readFileAsync('src/res/node.rc')

-  Object.keys(options).forEach(key => {
+  Object.keys(options).forEach((key) => {
    let value = options[key]
    const isVar = /^[A-Z_]+$/.test(value)
    value = isVar ? value : `"${value}"`
-    file.contents = file.contents.replace(
-      new RegExp(`VALUE "${key}",.*`),
-      `VALUE "${key}", ${value}`
-    )
+    file.contents = file.contents
+      .toString()
+      .replace(new RegExp(`VALUE "${key}",.*`), `VALUE "${key}", ${value}`)
  })
-  ;['PRODUCTVERSION', 'FILEVERSION'].forEach(x => {
+  ;['PRODUCTVERSION', 'FILEVERSION'].forEach((x) => {
    if (options[x]) {
-      file.contents = file.contents.replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`)
+      file.contents = file.contents
+        .toString()
+        .replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`)
    }
  })

@@ -1,18 +1,26 @@
+import { resolve } from 'path'
 import { NexeCompiler } from '../compiler'
+import { semverGt } from '../util'

-export default async function snapshot(compiler: NexeCompiler, next: () => Promise<void>) {
-  const snapshotFile = compiler.options.snapshot
-  const warmupScript = compiler.options.warmup
+export default async function (compiler: NexeCompiler, next: () => Promise<void>) {
+  const { snapshot, warmup, cwd } = compiler.options

-  if (!snapshotFile) {
+  if (!snapshot) {
    return next()
  }

+  const variablePrefix = semverGt(compiler.target.version, '11.0.0') ? 'v8_' : ''
+
  await compiler.replaceInFileAsync(
-    'configure',
+    compiler.configureScript,
    'def configure_v8(o):',
-    `def configure_v8(o):\n  o['variables']['embed_script'] = '${snapshotFile}'\n  o['variables']['warmup_script'] = '${warmupScript ||
-      snapshotFile}'`
+    `def configure_v8(o):\n  o['variables']['${variablePrefix}embed_script'] = r'${resolve(
+      cwd,
+      snapshot
+    )}'\n  o['variables']['${variablePrefix}warmup_script'] = r'${resolve(
+      cwd,
+      warmup || snapshot
+    )}'`
  )

  return next()
@@ -1,16 +1,6 @@
 import { NexeCompiler } from '../compiler'
 import { parse } from 'cherow'
-
-function semverGt(version: string, operand: string) {
-  const [cMajor, cMinor, cPatch] = version.split('.').map(Number)
-  const [major, minor, patch] = operand.split('.').map(Number)
-
-  return (
-    cMajor > major ||
-    (cMajor === major && cMinor > minor) ||
-    (cMajor === major && cMinor === minor && cPatch > patch)
-  )
-}
+import { wrap, semverGt } from '../util'

 function walkSome(node: any, visit: Function) {
  if (!node || typeof node.type !== 'string' || node._visited) {
@@ -39,18 +29,20 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v

  if (version.startsWith('4.')) {
    bootFile = 'src/node.js'
+  } else if (semverGt(version, '11.99')) {
+    bootFile = 'lib/internal/bootstrap/pre_execution.js'
  } else if (semverGt(version, '9.10.1')) {
    bootFile = 'lib/internal/bootstrap/node.js'
  }

  const file = await compiler.readFileAsync(bootFile),
-    ast = parse(file.contents, {
+    ast = parse(file.contents.toString(), {
      loc: true,
      tolerant: true,
      next: true,
      globalReturn: true,
      node: true,
-      skipShebang: true
+      skipShebang: true,
    }),
    location = { start: { line: 0 } }

@@ -62,13 +54,56 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
    }
  })

-  const fileLines = file.contents.split('\n')
-  fileLines.splice(location.start.line, 0, '{{replace:lib/fs/bootstrap.js}}' + '\n')
+  const fileLines = file.contents.toString().split('\n')
+  fileLines.splice(
+    location.start.line,
+    0,
+    '{{replace:lib/fs/bootstrap.js}}' +
+      '\n' +
+      (semverGt(version, '11.99') ? 'expandArgv1 = false;\n' : '')
+  )
  file.contents = fileLines.join('\n')

-  await compiler.setFileContentsAsync(
-    'lib/_third_party_main.js',
-    '{{replace:lib/patches/boot-nexe.js}}'
-  )
+  if (semverGt(version, '11.99')) {
+    if (semverGt(version, '12.17.99')) {
+      await compiler.replaceInFileAsync(
+        bootFile,
+        'initializeFrozenIntrinsics();',
+        'initializeFrozenIntrinsics();\n' + wrap('{{replace:lib/patches/boot-nexe.js}}')
+      )
+    } else {
+      await compiler.replaceInFileAsync(
+        bootFile,
+        'initializePolicy();',
+        'initializePolicy();\n' + wrap('{{replace:lib/patches/boot-nexe.js}}')
+      )
+    }
+    await compiler.replaceInFileAsync(
+      bootFile,
+      'assert(!CJSLoader.hasLoadedAnyUserCJSModule)',
+      '/*assert(!CJSLoader.hasLoadedAnyUserCJSModule)*/'
+    )
+    const { contents: nodeccContents } = await compiler.readFileAsync('src/node.cc')
+    if (nodeccContents.includes('if (env->worker_context() != nullptr) {')) {
+      await compiler.replaceInFileAsync(
+        'src/node.cc',
+        'if (env->worker_context() != nullptr) {',
+        'if (env->worker_context() == nullptr) {\n' +
+          '  return StartExecution(env, "internal/main/run_main_module"); } else {\n'
+      )
+    } else {
+      await compiler.replaceInFileAsync(
+        'src/node.cc',
+        'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {',
+        'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {\n' +
+          '  return StartExecution(env, "internal/main/run_main_module");\n'
+      )
+    }
+  } else {
+    await compiler.setFileContentsAsync(
+      'lib/_third_party_main.js',
+      '{{replace:lib/patches/boot-nexe.js}}'
+    )
+  }
  return next()
 }
@@ -2,7 +2,7 @@ import got = require('got')
 import { platforms, architectures, NexeTarget, getTarget, targetsEqual } from './target'
 export { NexeTarget }

-const versionsToSkip = [0, 1, 2, 3, 4, 5, 7, 9, 11]
+const versionsToSkip = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 17, 19, 21, 22]
 export interface GitAsset {
  name: string
  url: string
@@ -25,8 +25,10 @@ async function getJson<T>(url: string, options?: any) {
 }

 function isBuildableVersion(version: string) {
-  const major = Number(version.split('.')[0])
-  return !versionsToSkip.includes(major) || version === '4.8.4'
+  if (version === '12.11.0') {
+    return false
+  }
+  return !versionsToSkip.includes(Number(version.split('.')[0]))
 }

 export function getLatestGitRelease(options?: any) {
@@ -37,7 +39,7 @@ export async function getUnBuiltReleases(options?: any) {
  const nodeReleases = await getJson<NodeRelease[]>(
    'https://nodejs.org/download/release/index.json'
  )
-  const existingVersions = (await getLatestGitRelease(options)).assets.map(x => getTarget(x.name))
+  const existingVersions = (await getLatestGitRelease(options)).assets.map((x) => getTarget(x.name))

  const versionMap: { [key: string]: true } = {}
  return nodeReleases
@@ -47,8 +49,8 @@ export async function getUnBuiltReleases(options?: any) {
        return versions
      }
      versionMap[version] = true
-      platforms.forEach(platform => {
-        architectures.forEach(arch => {
+      platforms.forEach((platform) => {
+        architectures.forEach((arch) => {
          if (arch === 'x86' && platform === 'mac') return
          if (arch.includes('arm')) return
          versions.push(getTarget({ platform, arch, version }))
@@ -56,5 +58,5 @@ export async function getUnBuiltReleases(options?: any) {
      })
      return versions
    }, [])
-    .filter(x => !existingVersions.some(t => targetsEqual(t, x)))
+    .filter((x) => !existingVersions.some((t) => targetsEqual(t, x)))
 }
@@ -1,29 +1,28 @@
 import { join, dirname } from 'path'
-import { readdir, unlink } from 'fs'
+import * as fs from 'fs'
+import { promisify } from 'util'
 import { readFileAsync, writeFileAsync, isDirectoryAsync } from '../util'
-import * as mkdirp from 'mkdirp'
+import mkdirpAsync = require('mkdirp')
 import { NexeCompiler } from '../compiler'
-import pify = require('pify')

-const mkdirpAsync = pify(mkdirp)
-const unlinkAsync = pify(unlink)
-const readdirAsync = pify(readdir)
+const unlinkAsync = promisify(fs.unlink),
+  readdirAsync = promisify(fs.readdir)

 function readDirAsync(dir: string): Promise<string[]> {
-  return readdirAsync(dir).then(paths => {
+  return readdirAsync(dir).then((paths) => {
    return Promise.all(
      paths.map((file: string) => {
        const path = join(dir, file)
-        return isDirectoryAsync(path).then(x => (x ? readDirAsync(path) : (path as any)))
+        return isDirectoryAsync(path).then((x) => (x ? readDirAsync(path) : (path as any)))
      })
-    ).then(result => {
+    ).then((result) => {
      return [].concat(...(result as any))
    })
  })
 }

 function maybeReadFileContentsAsync(file: string) {
-  return readFileAsync(file, 'utf-8').catch(e => {
+  return readFileAsync(file, 'utf-8').catch((e) => {
    if (e.code === 'ENOENT') {
      return ''
    }
@@ -47,16 +46,16 @@ export default async function artifacts(compiler: NexeCompiler, next: () => Prom
  const tmpFiles = await readDirAsync(temp)

  await Promise.all(
-    tmpFiles.map(async path => {
+    tmpFiles.map(async (path) => {
      return compiler.writeFileAsync(path.replace(temp, ''), await readFileAsync(path, 'utf-8'))
    })
  )

  await next()

-  await Promise.all(tmpFiles.map(x => unlinkAsync(x)))
+  await Promise.all(tmpFiles.map((x) => unlinkAsync(x)))
  return Promise.all(
-    compiler.files.map(async file => {
+    compiler.files.map(async (file) => {
      const sourceFile = join(src, file.filename)
      const tempFile = join(temp, file.filename)
      const fileContents = await maybeReadFileContentsAsync(sourceFile)
@@ -1,22 +1,85 @@
-import { NexeCompiler } from '../compiler'
-import { resolve } from 'path'
-import { each } from '@calebboyd/semaphore'
-import resolveFiles from 'resolve-dependencies'
+import { NexeCompiler, NexeError } from '../compiler'
+import { resolve, relative } from 'path'
+import resolveFiles, { resolveSync } from 'resolve-dependencies'
+import { dequote, STDIN_FLAG, semverGt, each } from '../util'
+import { Readable } from 'stream'
+
+function getStdIn(stdin: Readable): Promise<string> {
+  let out = ''
+  return new Promise((resolve) => {
+    stdin
+      .setEncoding('utf8')
+      .on('readable', () => {
+        let current
+        while ((current = stdin.read())) {
+          out += current
+        }
+      })
+      .on('end', () => resolve(out.trim()))
+    setTimeout(() => {
+      if (!out.trim()) {
+        resolve(out.trim())
+      }
+    }, 1000)
+  })
+}

 export default async function bundle(compiler: NexeCompiler, next: any) {
-  const { bundle, cwd, input } = compiler.options
-  if (!bundle) {
+  const { bundle: doBundle, cwd, input: inputPath } = compiler.options
+  let input = inputPath
+  compiler.entrypoint = './' + relative(cwd, input)
+
+  if (semverGt(compiler.target.version, '11.99')) {
+    compiler.startup = ''
+  } else {
+    compiler.startup = ';require("module").runMain();'
+  }
+
+  if (!doBundle) {
    await compiler.addResource(resolve(cwd, input))
    return next()
  }

-  if (!input) {
+  let code = ''
+  if (typeof doBundle === 'string') {
+    code = await require(doBundle).createBundle(compiler.options)
+  }
+
+  if (input === STDIN_FLAG && (code = code || dequote(await getStdIn(process.stdin)))) {
+    compiler.stdinUsed = true
+    compiler.entrypoint = './__nexe_stdin.js'
+    await compiler.addResource(resolve(cwd, compiler.entrypoint), code)
    return next()
  }

-  const { files } = await resolveFiles(input, { cwd, expand: true, loadContent: false })
-  await each(Object.keys(files), (filename: string) => compiler.addResource(filename), {
-    concurrency: 10
-  })
+  if (input === STDIN_FLAG) {
+    const maybeInput = resolveSync(cwd, '.')
+    if (!maybeInput || !maybeInput.absPath) {
+      throw new NexeError('No valid input detected')
+    }
+    input = maybeInput.absPath
+    compiler.entrypoint = './' + relative(cwd, input)
+  }
+
+  const { files, warnings } = resolveFiles(
+    input,
+    ...Object.keys(compiler.bundle.list).filter((x) => x.endsWith('.js')),
+    { cwd, expand: 'variable', loadContent: false }
+  )
+
+  if (
+    warnings.filter((x) => x.startsWith('Error parsing file') && !x.includes('node_modules')).length
+  ) {
+    throw new NexeError('Parsing Error:\n' + warnings.join('\n'))
+  }
+
+  //TODO: warnings.forEach((x) => console.log(x))
+
+  await Promise.all(
+    Object.entries(files).map(([key, file]) => {
+      return compiler.addResource(key, file)
+    })
+  )
+
  return next()
 }
@@ -1,24 +1,9 @@
-import { normalize, relative, resolve } from 'path'
+import { dirname, normalize, relative, resolve } from 'path'
 import { createWriteStream, chmodSync, statSync } from 'fs'
-import { dequote } from '../util'
-import { Readable } from 'stream'
 import { NexeCompiler } from '../compiler'
 import { NexeTarget } from '../target'
-
-function getStdIn(stdin: Readable): Promise<string> {
-  return new Promise(resolve => {
-    let out = ''
-    stdin
-      .setEncoding('utf8')
-      .on('readable', () => {
-        let current
-        while ((current = stdin.read())) {
-          out += current
-        }
-      })
-      .on('end', () => resolve(out))
-  })
-}
+import { STDIN_FLAG } from '../util'
+import mkdirp = require('mkdirp')

 /**
 * The "cli" step detects the appropriate input. If no input options are passed,
@@ -26,51 +11,48 @@ function getStdIn(stdin: Readable): Promise<string> {
 * 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 { log } = compiler
-  let stdInUsed = false
-  if (!process.stdin.isTTY && compiler.options.enableStdIn) {
-    stdInUsed = true
-    compiler.entrypoint = './__nexe_stdin.js'
-    const code = dequote(await getStdIn(process.stdin))
-    await compiler.addResource(resolve(compiler.options.cwd, compiler.entrypoint), code)
-  } else {
-    compiler.entrypoint = './' + relative(compiler.options.cwd, compiler.options.input)
-  }
-  compiler.startup = ';require("module").runMain();'
  await next()
+  const { log } = compiler,
+    target = compiler.options.targets.shift() as NexeTarget,
+    deliverable = await compiler.compileAsync(target),
+    output = normalize(compiler.output!)

-  const target = compiler.options.targets.shift() as NexeTarget
-  const deliverable = await compiler.compileAsync(target)
+  mkdirp.sync(dirname(output))

-  return new Promise((resolve, reject) => {
+  return new Promise((res, rej) => {
    const step = log.step('Writing result to file')
    deliverable
-      .pipe(createWriteStream(normalize(compiler.output!)))
-      .on('error', reject)
+      .pipe(createWriteStream(output))
+      .on('error', rej)
      .once('close', (e: Error) => {
        if (e) {
-          reject(e)
+          rej(e)
        } else if (compiler.output) {
-          const output = compiler.output
-          const mode = statSync(output).mode | 0o111
+          const output = compiler.output,
+            mode = statSync(output).mode | 0o111,
+            inputFileLogOutput = relative(
+              process.cwd(),
+              resolve(compiler.options.cwd, compiler.entrypoint || compiler.options.input)
+            ),
+            outputFileLogOutput = relative(process.cwd(), output)
+
          chmodSync(output, mode.toString(8).slice(-3))
-          const inputFile = relative(process.cwd(), compiler.options.input)
-          const outputFile = relative(process.cwd(), output)
          step.log(
            `Entry: '${
-              stdInUsed ? (compiler.options.mangle ? '[stdin]' : '[none]') : inputFile
-            }' written to: ${outputFile}`
+              compiler.stdinUsed
+                ? compiler.options.mangle
+                  ? STDIN_FLAG
+                  : '[none]'
+                : inputFileLogOutput
+            }' written to: ${outputFileLogOutput}`
          )
-          resolve(compiler.quit())
+          compiler.quit()
+          res(output)
        }
      })
  })
@@ -2,7 +2,8 @@ import download = require('download')
 import { pathExistsAsync } from '../util'
 import { LogStep } from '../logger'
 import { IncomingMessage } from 'http'
-import { NexeCompiler } from '../compiler'
+import { NexeCompiler, NexeError } from '../compiler'
+import { dirname } from 'path'

 function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options = {}) {
  const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
@@ -10,7 +11,7 @@ function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options
    .on('response', (res: IncomingMessage) => {
      const total = +res.headers['content-length']!
      let current = 0
-      res.on('data', data => {
+      res.on('data', (data) => {
        current += data.length
        setText((current / total) * 100)
        if (current === total) {
@@ -21,27 +22,56 @@ function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options
    .then(() => step.log(`Node source extracted to: ${dest}`))
 }

+async function fetchPrebuiltBinary(compiler: NexeCompiler, step: any) {
+  const { target, remoteAsset } = compiler,
+    filename = compiler.getNodeExecutableLocation(target)
+
+  try {
+    await download(remoteAsset, dirname(filename), compiler.options.downloadOptions).on(
+      'response',
+      (res: IncomingMessage) => {
+        const total = +res.headers['content-length']!
+        let current = 0
+        res.on('data', (data) => {
+          current += data.length
+          step!.modify(`Downloading...${((current / total) * 100).toFixed()}%`)
+        })
+      }
+    )
+  } catch (e: any) {
+    if (e.statusCode === 404) {
+      throw new NexeError(`${remoteAsset} is not available, create it using the --build flag`)
+    } else {
+      throw new NexeError('Error downloading prebuilt binary: ' + e)
+    }
+  }
+}
+
 /**
 * Downloads the node source to the configured temporary directory
 * @param {*} compiler
 * @param {*} next
 */
 export default async function downloadNode(compiler: NexeCompiler, next: () => Promise<void>) {
-  const {
-    src,
-    log,
-    targets: [{ version }]
-  } = compiler
-  const { sourceUrl, downloadOptions } = compiler.options
-  const url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`
-  const step = log.step(`Downloading Node.js source from: ${url}`)
-  if (await pathExistsAsync(src)) {
-    step.log('Source already downloaded')
+  const { src, log, target } = compiler,
+    { version } = target,
+    { sourceUrl, downloadOptions, build } = compiler.options,
+    url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`,
+    step = log.step(
+      `Downloading ${build ? '' : 'pre-built '}Node.js${build ? `source from: ${url}` : ''}`
+    ),
+    exeLocation = compiler.getNodeExecutableLocation(build ? undefined : target),
+    downloadExists = await pathExistsAsync(build ? src : exeLocation)
+
+  if (downloadExists) {
+    step.log('Already downloaded...')
    return next()
  }

-  if (compiler.options.build) {
+  if (build) {
    await fetchNodeSourceAsync(src, url, step, downloadOptions)
+  } else {
+    await fetchPrebuiltBinary(compiler, step)
  }

  return next()
@@ -1,22 +1,25 @@
-import { isDirectoryAsync, each } from '../util'
+import { each } from '../util'
 import * as globs from 'globby'
+import { resolve } from 'path'
 import { NexeCompiler } from '../compiler'

 export default async function resource(compiler: NexeCompiler, next: () => Promise<any>) {
-  const { cwd } = compiler.options
-  if (!compiler.options.resources.length) {
+  const { cwd, resources } = compiler.options
+  if (!resources.length) {
    return next()
  }
  const step = compiler.log.step('Bundling Resources...')
  let count = 0
-  await each(globs(compiler.options.resources, { cwd }), async file => {
-    if (await isDirectoryAsync(file)) {
-      return
-    }
+
+  // workaround for https://github.com/sindresorhus/globby/issues/127
+  // and https://github.com/mrmlnc/fast-glob#pattern-syntax
+  const resourcesWithForwardSlashes = resources.map((r) => r.replace(/\\/g, '/'))
+
+  await each(globs(resourcesWithForwardSlashes, { cwd, onlyFiles: true }), async (file) => {
    count++
    step.log(`Including file: ${file}`)
-    await compiler.addResource(file)
+    await compiler.addResource(resolve(cwd, file))
  })
-  step.log(`Included ${count} file(s). ${(compiler.resourceSize / 1e6).toFixed(3)} MB`)
+  step.log(`Included ${count} file(s)`)
  return next()
 }
@@ -1,12 +1,15 @@
 import { NexeCompiler } from '../compiler'
 import { wrap } from '../util'

-export default function(compiler: NexeCompiler, next: () => Promise<void>) {
+export default async function (compiler: NexeCompiler, next: () => Promise<void>) {
+  await next()
  compiler.shims.push(
    wrap(
-      `process.__nexe = ${JSON.stringify(compiler.binaryConfiguration)};\n` +
+      '' +
        '{{replace:lib/fs/patch.js}}' +
-        '\nshimFs(process.__nexe)'
+        '\nshimFs(process.__nexe)' +
+        `\n${compiler.options.fs ? '' : 'restoreFs()'}`
+      //TODO support only restoring specific methods
    )
  )
  compiler.shims.push(
@@ -22,10 +25,12 @@ export default function(compiler: NexeCompiler, next: () => Promise<void>) {
  compiler.shims.push(
    wrap(`
      if (!process.send) {
-        process.argv.splice(1,0, require.resolve("${compiler.entrypoint}"))  
+        const path = require('path')
+        const entry = path.resolve(path.dirname(process.execPath),${JSON.stringify(
+          compiler.entrypoint
+        )})
+        process.argv.splice(1,0, entry)
      }
    `)
  )
-
-  return next()
 }
@@ -1,8 +1,8 @@
 export type NodePlatform = 'windows' | 'mac' | 'alpine' | 'linux'
-export type NodeArch = 'x86' | 'x64' | 'arm7l' | 'arm6l' | 'arm64'
+export type NodeArch = 'x86' | 'x64' | 'arm' | 'arm64'

 const platforms: NodePlatform[] = ['windows', 'mac', 'alpine', 'linux'],
-  architectures: NodeArch[] = ['x86', 'x64', 'arm7l', 'arm6l', 'arm64']
+  architectures: NodeArch[] = ['x86', 'x64', 'arm', 'arm64']

 export { platforms, architectures }

@@ -21,21 +21,21 @@ const prettyPlatform: { [key: string]: NodePlatform } = {
  mac: 'mac',
  linux: 'linux',
  static: 'alpine',
-  alpine: 'alpine'
+  alpine: 'alpine',
 }

 const prettyArch: { [key: string]: NodeArch } = {
  x86: 'x86',
-  arm6: 'arm6l',
+  arm6: 'arm',
  arm64: 'arm64',
-  arm6l: 'arm6l',
-  arm: 'arm7l',
-  arm7: 'arm7l',
-  arm7l: 'arm7l',
+  arm6l: 'arm',
+  arm: 'arm',
+  arm7: 'arm',
+  arm7l: 'arm',
  amd64: 'x64',
  ia32: 'x86',
  x32: 'x86',
-  x64: 'x64'
+  x64: 'x64',
 }

 function isVersion(x: string) {
@@ -80,7 +80,7 @@ export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget
  target
    .toLowerCase()
    .split('-')
-    .forEach(x => {
+    .forEach((x) => {
      if (isVersion(x)) {
        version = x.replace(/v/g, '')
      }
@@ -1,9 +1,10 @@
 import { readFile, writeFile, stat } from 'fs'
 import { execFile } from 'child_process'
-import pify = require('pify')
+import { promisify } from 'util'
 import rimraf = require('rimraf')

-const rimrafAsync = pify(rimraf)
+const rimrafAsync = promisify(rimraf)
+export const STDIN_FLAG = '[stdin]'

 export async function each<T>(
  list: T[] | Promise<T[]>,
@@ -41,10 +42,10 @@ const bound: MethodDecorator = function bound<T>(
      Object.defineProperty(this, propertyKey as string, {
        configurable,
        value,
-        writable: true
+        writable: true,
      })
      return value
-    }
+    },
  }
 }

@@ -63,27 +64,43 @@ export interface ReadFileAsync {
  (path: string, encoding: string): Promise<string>
 }

-const readFileAsync = pify(readFile)
-const writeFileAsync = pify(writeFile)
-const statAsync = pify(stat)
-const execFileAsync = pify(execFile)
+const readFileAsync = promisify(readFile)
+const writeFileAsync = promisify(writeFile)
+const statAsync = promisify(stat)
+const execFileAsync = promisify(execFile)
 const isWindows = process.platform === 'win32'

 function pathExistsAsync(path: string) {
  return statAsync(path)
-    .then(x => true)
+    .then((x) => true)
    .catch(falseOnEnoent)
 }

 function isDirectoryAsync(path: string) {
  return statAsync(path)
-    .then(x => x.isDirectory())
+    .then((x) => x.isDirectory())
    .catch(falseOnEnoent)
 }
+/**
+ * @param version See if this version is greather than the second one
+ * @param operand Version to compare against
+ */
+function semverGt(version: string, operand: string) {
+  const [cMajor, cMinor, cPatch] = version.split('.').map(Number)
+  let [major, minor, patch] = operand.split('.').map(Number)
+  if (!minor) minor = 0
+  if (!patch) patch = 0
+  return (
+    cMajor > major ||
+    (cMajor === major && cMinor > minor) ||
+    (cMajor === major && cMinor === minor && cPatch > patch)
+  )
+}

 export {
  dequote,
  padRight,
+  semverGt,
  bound,
  isWindows,
  rimrafAsync,
@@ -92,5 +109,5 @@ export {
  readFileAsync,
  pathExistsAsync,
  isDirectoryAsync,
-  writeFileAsync
+  writeFileAsync,
 }
@@ -1,98 +0,0 @@
-import * as nexe from '../lib/nexe'
-import { getUnBuiltReleases, getLatestGitRelease } from '../lib/releases'
-import * as ci from './ci'
-import { runDockerBuild } from './docker'
-import { getTarget } from '../lib/target'
-import { pathExistsAsync, readFileAsync, execFileAsync } from '../lib/util'
-import got = require('got')
-
-const env = process.env,
-  branchName = env.CIRCLE_BRANCH || env.APPVEYOR_REPO_BRANCH || env.TRAVIS_BRANCH || '',
-  isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD || env.NEXE_TRIGGERED),
-  isWindows = Boolean(env.APPVEYOR),
-  isPullRequest =
-    Boolean(env.CIRCLE_PR_NUMBER) ||
-    Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) ||
-    Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
-  headers = {
-    Authorization: 'token ' + env.GITHUB_TOKEN,
-    'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
-  }
-
-if (require.main === module) {
-  if (!isPullRequest) {
-    build().catch(x => {
-      console.error(x)
-      process.exit(1)
-    })
-  }
-}
-
-async function build() {
-  if (isScheduled) {
-    const releases = await getUnBuiltReleases({ headers })
-    if (!releases.length) {
-      return
-    }
-    const windowsBuild = releases.find(x => x.platform === 'windows')
-    const macBuild = releases.find(x => x.platform === 'mac')
-    const linuxOrAlpine = releases.find(x => x.platform === 'linux' || x.platform === 'alpine')
-
-    if (linuxOrAlpine) {
-      await ci.triggerDockerBuild(linuxOrAlpine, branchName)
-    }
-    if (macBuild) {
-      await ci.triggerMacBuild(macBuild, branchName)
-    }
-    if (windowsBuild) {
-      await ci.triggerWindowsBuild(windowsBuild)
-    }
-  }
-
-  if (env.NEXE_VERSION) {
-    const target = getTarget(env.NEXE_VERSION),
-      output = isWindows ? './out.exe' : './out',
-      options = {
-        empty: true,
-        build: true,
-        target,
-        output
-      }
-    console.log('Building: ', target)
-    const stop = keepalive()
-    if (['arm7l', 'arm6l', 'arm64', 'alpine'].includes(target.platform)) {
-      await runDockerBuild(target)
-    } else {
-      await nexe.compile(options)
-    }
-    stop()
-
-    if (await pathExistsAsync(output)) {
-      await assertNexeBinary(output)
-      const gitRelease = await getLatestGitRelease({ headers })
-      await got(gitRelease.upload_url.split('{')[0], {
-        query: { name: target.toString() },
-        body: await readFileAsync(output),
-        headers: {
-          ...headers,
-          'Content-Type': 'application/octet-stream'
-        }
-      })
-      console.log(target + ' uploaded.')
-    }
-  }
-}
-
-function keepalive() {
-  const keepalive = setInterval(() => console.log('Building...'), 300 * 1000)
-  return () => clearInterval(keepalive)
-}
-
-function assertNexeBinary(file: string) {
-  return execFileAsync(file).catch(e => {
-    if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
-      return
-    }
-    throw e
-  })
-}
@@ -0,0 +1,116 @@
+import * as nexe from '../lib/nexe'
+import { getUnBuiltReleases, getLatestGitRelease } from '../lib/releases'
+import { runDockerBuild } from './docker'
+import { getTarget, targetsEqual, NexeTarget } from '../lib/target'
+import { pathExistsAsync, readFileAsync, execFileAsync, semverGt } from '../lib/util'
+import got from 'got'
+import { cpus } from 'os'
+
+const env = process.env,
+  isPullRequest = env.BUILD_REASON === 'PullRequest',
+  isWindows = process.platform === 'win32',
+  isLinux = process.platform === 'linux',
+  buildHost = env.AGENT_JOBNAME || (isWindows && 'windows_2017_2015') || '',
+  isMac = process.platform === 'darwin',
+  headers = {
+    Authorization: 'token ' + env.GITHUB_TOKEN,
+    'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)',
+  }
+
+if (require.main === module) {
+  if (!isPullRequest) {
+    build().catch((x) => {
+      console.error(x)
+      process.exit(1)
+    })
+  }
+}
+
+async function build() {
+  const releases = await getUnBuiltReleases({ headers })
+  if (!releases.length) {
+    return
+  }
+  const windowsBuild = releases.find((x) => x.platform === 'windows'),
+    macBuild = releases.find((x) => x.platform === 'mac'),
+    linux = releases.find((x) => x.platform === 'linux'),
+    alpine = releases.find((x) => x.platform === 'alpine')
+
+  let target: NexeTarget | undefined
+
+  if (env.NEXE_VERSION) target = getTarget(env.NEXE_VERSION)
+  else if (isWindows) target = windowsBuild
+  else if (isMac) target = macBuild
+  else if (isLinux) target = linux
+  if (buildHost.includes('alpine')) target = alpine
+
+  if (!target) {
+    return console.log('Nothing to build...')
+  }
+
+  if (isWindows && buildHost.includes('2017') && !semverGt(target.version, '9.99.99')) {
+    return console.log(`Not building ${target} on this host...`)
+  }
+  if (isWindows && buildHost.includes('2015') && semverGt(target.version, '9.99.99')) {
+    return console.log(`Not building ${target} on this host...`)
+  }
+
+  const output = isWindows ? './out.exe' : './out',
+    options = {
+      mangle: false,
+      build: true,
+      verbose: Boolean(env.NEXE_VERBOSE!),
+      target,
+      make: ['-j' + cpus().length],
+      output,
+    }
+  console.log('Building: ' + target + ' on ' + buildHost)
+  const stop = keepalive()
+
+  if (
+    [/*'arm7l', 'arm6l', 'arm64', */ 'alpine'].includes(target.platform) &&
+    buildHost.includes('alpine')
+  ) {
+    await runDockerBuild(target)
+  } else {
+    await nexe.compile(options)
+  }
+  stop()
+  if (await pathExistsAsync(output)) {
+    await assertNexeBinary(output)
+    const gitRelease = await getLatestGitRelease({ headers }),
+      unbuiltReleases = await getUnBuiltReleases({ headers })
+    if (!unbuiltReleases.some((x) => targetsEqual(x, target!))) {
+      console.log(`${target} already uploaded.`)
+      process.exit(0)
+      return
+    }
+    await got(gitRelease.upload_url.split('{')[0], {
+      searchParams: { name: target.toString() },
+      body: await readFileAsync(output),
+      headers: {
+        ...headers,
+        'Content-Type': 'application/octet-stream',
+      },
+    }).catch((reason) => {
+      console.log(reason && reason.response && reason.response.body)
+      throw reason
+    })
+    console.log(target + ' uploaded.')
+    process.exit(0)
+  }
+}
+
+function keepalive() {
+  const keepalive = setInterval(() => console.log('Building...'), 300 * 1000)
+  return () => clearInterval(keepalive)
+}
+
+function assertNexeBinary(file: string) {
+  return execFileAsync(file).catch((e) => {
+    if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
+      return
+    }
+    throw e
+  })
+}
@@ -1,58 +0,0 @@
-import { NexeTarget } from '../lib/releases'
-import got = require('got')
-import * as assert from 'assert'
-import { getTarget } from '../lib/target'
-const { env } = process
-
-export function triggerMacBuild(release: NexeTarget, branch: string) {
-  assert.ok(env.CIRCLE_TOKEN)
-  const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/${branch}?circle-token=${
-    env.CIRCLE_TOKEN
-  }`
-  return got(circle, {
-    json: true,
-    body: {
-      build_parameters: {
-        NEXE_VERSION: release.toString()
-      }
-    }
-  })
-}
-
-export function triggerDockerBuild(release: NexeTarget, branch: string) {
-  assert.ok(env.TRAVIS_TOKEN)
-  const travis = `https://api.travis-ci.org/repo/nexe%2Fnexe/requests`
-  return got(travis, {
-    json: true,
-    body: {
-      request: {
-        branch: branch,
-        config: {
-          merge_mode: 'deep_merge',
-          env: {
-            //use matrix so that secure global variable is merged
-            matrix: {
-              NEXE_VERSION: release.toString()
-            }
-          }
-        }
-      }
-    },
-    headers: {
-      'Travis-API-Version': '3',
-      Authorization: `token ${env.TRAVIS_TOKEN}`
-    }
-  })
-}
-
-export function triggerWindowsBuild(release: NexeTarget) {
-  const version = 'NEXE_VERSION' in env ? env.NEXE_VERSION!.trim() : release.toString()
-  if (getTarget(version).version.startsWith('10.')) {
-    if ((env.APPVEYOR_BUILD_WORKER_IMAGE || '').includes('2017')) {
-      env.NEXE_VERSION = version
-    }
-  } else {
-    env.NEXE_VERSION = version
-  }
-  return Promise.resolve()
-}
@@ -1,15 +1,15 @@
 import { NexeTarget, architectures } from '../lib/target'
 import { writeFileAsync, readFileAsync } from '../lib/util'
-import got = require('got')
+import got from 'got'
 import execa = require('execa')
 import { appendFileSync } from 'fs'

 function alpine(target: NexeTarget) {
  return `
-FROM ${target.arch === 'x64' ? '' : 'i386/'}alpine:3.4
+FROM ${target.arch === 'x64' ? '' : 'i386/'}alpine:3.12
 RUN apk add --no-cache curl make gcc g++ binutils-gold python linux-headers paxctl libgcc libstdc++ git vim tar gzip wget
 ENV NODE_VERSION=${target.version}
-ENV NEXE_VERSION=beta
+ENV NEXE_VERSION=latest
 WORKDIR /

 RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
@@ -20,19 +20,20 @@ RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.t
  paxctl -cm /usr/bin/node

 RUN rm /nexe_temp/\${NODE_VERSION}/out/Release/node && \
-  npm install -g nexe@\${NEXE_VERSION} && \
-  nexe --build --empty --temp /nexe_temp -c="--fully-static" -o out --enableStdIn=false
+  npm install -g nexe@\${NEXE_VERSION}
+RUN echo "console.log('hello world')" >> index.js && \
+  nexe --build --no-mangle --temp /nexe_temp -c="--fully-static" -o out
 `.trim()
 }

 function arm(target: NexeTarget) {
  return `
 FROM hypriot/rpi-node
-ENV NEXE_VERSION=beta
+ENV NEXE_VERSION=latest
 WORKDIR /

 RUN yarn global add nexe@\${NEXE_VERSION} && \
-  nexe --build --empty -o out -t ${target.version}
+  nexe --build --no-mangle -o out -t ${target.version}
 `.trim()
 }

@@ -45,10 +46,10 @@ export async function runDockerBuild(target: NexeTarget) {
  let output: any = []

  try {
-    output.push(await execa.shell(`docker build -t nexe-docker .`))
-    output.push(await execa.shell(`docker run -d --name nexe nexe-docker sh`))
-    output.push(await execa.shell(`docker cp nexe:/out out`))
-    output.push(await execa.shell(`docker rm nexe`))
+    output.push(await execa(`docker build -t nexe-docker .`, { shell: true }))
+    output.push(await execa(`docker run -d --name nexe nexe-docker sh`, { shell: true }))
+    output.push(await execa(`docker cp nexe:/out out`, { shell: true }))
+    output.push(await execa(`docker rm nexe`, { shell: true }))
  } catch (e) {
    console.log('Error running docker')
    appendFileSync(outFilename, e.message)
@@ -57,16 +58,11 @@ export async function runDockerBuild(target: NexeTarget) {
      appendFileSync(outFilename, x.stderr)
      appendFileSync(outFilename, x.stdout)
    })
-    await got(
-      `https://transfer.sh/${Math.random()
-        .toString(36)
-        .substring(2)}.txt`,
-      {
-        body: await readFileAsync(outFilename),
-        method: 'PUT'
-      }
-    )
-      .then(x => console.log('Posted docker log: ', x.body))
-      .catch(e => console.log('Error posting log', e))
+    await got(`https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`, {
+      body: await readFileAsync(outFilename),
+      method: 'PUT',
+    })
+      .then((x) => console.log('Posted docker log: ', x.body))
+      .catch((e) => console.log('Error posting log', e))
  }
 }
@@ -1,4 +0,0 @@
-./test/**/*.spec.ts
--check-leaks
--require ts-node/register
--recursive
@@ -10,9 +10,13 @@ describe('options', () => {
      const options = normalizeOptions()
      expect(options.cwd).to.equal(process.cwd())
    })
-    it('should use the main module in a package directory', () => {
+    it('should use the main module in a package directory (if not in a TTY)', () => {
      const options = normalizeOptions()
-      expect(options.input).to.equal(path.resolve('./index.js'))
+      if (!process.stdin.isTTY) {
+        expect(options.input).to.equal('[stdin]')
+      } else {
+        expect(options.input).to.equal(path.resolve('./index.js'))
+      }
    })
    it('should resolve relative paths for input', () => {
      const options = normalizeOptions({ input: 'test/fixture/entry.js' })
@@ -35,6 +39,26 @@ describe('options', () => {
      expect(options.output).to.equal(path.resolve(cwd, `abc${ext}`))
    })
  })
+
+  describe('remote', () => {
+    it('should use default remote', () => {
+      const options = normalizeOptions({})
+      expect(options.remote).to.equal('https://github.com/nexe/nexe/releases/download/v3.3.3/')
+    })
+    it('should append trailing slash to third-party remote if necessary', () => {
+      const options = normalizeOptions({
+        remote: 'https://sitejs.org/nexe'
+      })
+      expect(options.remote).to.equal('https://sitejs.org/nexe/')
+    })
+    it('should not append trailing slash to third-party remote that already has one', () => {
+      const options = normalizeOptions({
+        remote: 'https://sitejs.org/nexe/'
+      })
+      expect(options.remote).to.equal('https://sitejs.org/nexe/')
+    })
+  })
+
  describe('output', () => {
    it('should work', () => {
      const options = normalizeOptions({
@@ -1,9 +1,9 @@
 {
  "compilerOptions": {
-    "target":"es5",
+    "target":"es2015",
    "skipLibCheck": true,
    "experimentalDecorators": true,
-    "lib": ["es2017"],
+    "lib": ["es2018"],
    "module": "commonjs",
    "outDir": "./lib",
    "strict": true
Author	SHA1	Message	Date
calebboyd	4cd04d1b0c	chore: bump version	2021-09-26 21:20:48 -05:00
calebboyd	e539093ef4	docs: update readme	2021-09-26 17:15:06 -05:00
calebboyd	805ca35149	chore: update dependencies	2021-09-26 16:59:48 -05:00
calebboyd	37ee352408	build: add workflow for autoclose issues without response	2021-09-26 15:50:55 -05:00
Asher Oto	a9811257ea	docs: update readme (#861 )	2021-09-26 13:43:14 -05:00
bruce-one	dd3dec1f9d	docs: document asset option. (#903 )	2021-09-26 13:37:29 -05:00
bruce-one	fe9f73d22b	fix: support fs.realpath(Sync).native. (#892 )	2021-09-14 10:26:26 -05:00
Caleb Boyd	0c7b942f7f	fix(fs): only override time references (#883 )	2021-04-05 05:55:24 -05:00
Jared Allard	bd09fe59de	docs(README): add discord (#870 )	2021-02-25 19:54:16 -06:00
calebboyd	9962630ace	chore: bump package-lock version and dev deps	2021-02-25 06:37:52 -06:00
Wilmar den Ouden	232e1005e6	fix: update resolve-dependencies to 6.0.5 (#869 )	2021-02-25 06:32:35 -06:00
calebboyd	9f22309949	feat: add asset flag for using cached artifact	2021-01-26 07:16:29 -06:00
calebboyd	cf8e6ff393	fix: got upload searchParams	2021-01-05 12:47:29 -06:00
calebboyd	7275d4b848	fix: update dependencies	2021-01-03 17:00:24 -06:00
calebboyd	06a8242114	fix: resolve resources relative to passed cwd closes #645	2021-01-03 16:25:52 -06:00
calebboyd	2935ee3f93	fix: add lstat patch	2021-01-03 15:29:55 -06:00
calebboyd	9f1f323b09	build: audit fix	2020-12-16 15:08:08 -06:00
bruce-one	0ba696e976	fix: support for 12.19.1. (#835 )	2020-11-21 16:20:38 -06:00
bruce-one	0f0869b292	fix: internal module read json changes 12.18.3 (#803 )	2020-09-24 10:13:22 -05:00
calebboyd	c5dabbf9b4	build: audit fix	2020-07-21 08:59:59 -05:00
calebboyd	e51b6b21a6	fix: set filesize for resource files	2020-07-10 07:12:14 -05:00
calebboyd	2b261728b4	feat: deterministic builds	2020-07-09 10:21:14 -05:00
Caleb Boyd	017abb94cc	docs: add funding.yml	2020-07-01 10:33:33 -05:00
calebboyd	32033b6d15	fix: bring idepotent builds back	2020-06-27 06:46:13 -05:00
calebboyd	bc1d579baa	build: add more space for msbuild	2020-06-24 20:17:30 -05:00
calebboyd	6ffd47f1f1	chore: update macos build version	2020-06-24 09:55:56 -05:00
calebboyd	c4e16fb6e0	chore: bump globby and fix ci node version	2020-06-24 09:52:27 -05:00
calebboyd	ea6f1f0808	fix: update legacy v3 tag while v4 is beta	2020-06-22 14:59:44 -05:00
calebboyd	c1055149ab	chore: bump resolve dependnencies	2020-06-20 12:15:13 -05:00
calebboyd	79fffc358a	chore: update resolve-dependencies	2020-06-20 08:39:39 -05:00
Bryce Gibson	c8cf13a9dd	Move nexe boot to support 12.18.0.	2020-06-04 07:43:26 -05:00
Aral Balkan	928b8134a7	fix: remove full stop from one line of help output for consistency	2020-05-08 17:42:03 -05:00
Aral Balkan	0a2e8dba00	fix: replace --asset option with --remote option (#760 )	2020-05-08 17:42:03 -05:00
Aral Balkan	01c977bb3c	feat: alternate nexe base binary remotes (--remote option) (#760 )	2020-05-08 17:42:03 -05:00
calebboyd	ac5bf1876a	chore: bump beta	2020-04-26 09:08:59 -05:00
calebboyd	d6ba5d193f	fix: update resolve-dependencies	2020-04-26 09:08:25 -05:00
Aral Balkan	b785b72724	docs: link to list of pre-built executables (#738 )	2020-04-18 14:55:50 -05:00
bruce-one	de6bb58a10	fix: remove hasLoadedAnyUserCJSModule assertion to fix startup. (#743 )	2020-04-02 19:11:02 -05:00
calebboyd	56dfef1e45	chore: bump version	2020-03-31 09:45:41 -05:00
bruce-one	8f3d29812a	Handle multiline ProcessGlobalArgs change. (#742 ) Fixes #739.	2020-03-30 12:39:32 -05:00
calebboyd	c44877d6ad	chore: release beta.4	2020-02-20 21:37:14 -06:00
Roy Razon	a4db04dbee	fix: resources not being included on Windows (#701 )	2020-01-14 08:47:35 -06:00
Roy Razon	ec7f7f318e	fix: two windows fs patch bugs (#692 ) * fix: two windows fs patch bugs - winPath was not upcasing drive letters of namespace-prefixed keys - internalModuleReadFile and internalModuleStat were not normalizing keys before checking the manifest for existing entries	2020-01-14 08:29:25 -06:00
calebboyd	e49d72db88	chore: add additional debug logging	2019-10-24 09:59:01 -05:00
calebboyd	1686c1f68c	chore: increase buildable time	2019-10-10 13:00:40 -05:00
calebboyd	1e54736fec	fix: serialize shims/resources in upstream step closes #677	2019-10-09 12:20:53 -05:00
calebboyd	4112bd7b3e	fix: multistream export cast	2019-10-09 10:54:52 -05:00
calebboyd	5ec04f5791	chore: update buildable versions	2019-10-09 09:42:19 -05:00
Nathan Poirier	098a746e0d	fix: support fs.stat options (#665 )	2019-09-18 14:22:24 -05:00
Jared Allard	cc2c5e31fc	feat: use github issues/pr templates v2 (#663 )	2019-08-22 13:51:43 -05:00
Caleb Boyd	fe26b540de	fix: arm arch mapping (#662 )	2019-08-22 10:52:24 -05:00
bruce-one	a143c470fb	fix: support NODE_OPTIONS in newer node versions (#660 ) And use `$&` for code simplification.	2019-08-22 09:44:03 -05:00
calebboyd	eb887363de	fix(build): fix ci task execa types	2019-08-06 14:57:24 -05:00
calebboyd	de9894cf47	feat: variable import resolution BREAKING: node 6 is no longer supported	2019-07-31 16:15:37 -05:00
dependabot[bot]	2e2d381969	build(deps): bump lodash from 4.17.11 to 4.17.14 (#651 )	2019-07-15 10:36:54 -05:00
calebboyd	7d0f435bef	chore: pipeline troubleshooting	2019-07-11 15:09:34 -05:00
calebboyd	efd3dfc35a	fix: windows build 10.16	2019-06-25 15:32:32 -05:00
calebboyd	9c1d67b2e6	build: add 3rd scheduled build	2019-06-24 14:20:51 -05:00
calebboyd	93e0a021d3	build: increase timeout to 3 hours	2019-06-24 11:37:23 -05:00
calebboyd	021f50d50f	build: add schedules to yml	2019-06-24 09:38:05 -05:00
calebboyd	bf5ff7d9bd	chore: set build limit to two hours	2019-06-21 15:20:21 -05:00
calebboyd	86c3acedb1	chore: pipeline display names	2019-06-17 18:38:54 -05:00
calebboyd	ecb3d41a97	build: exit on existing target	2019-06-17 12:57:35 -05:00
calebboyd	1eb44797d0	fix: don't expand argv1 on node 12 bootstrap	2019-06-17 12:49:28 -05:00
calebboyd	1023b72513	fix: update patches for node 12 bootstrapping	2019-06-12 16:04:17 -05:00
calebboyd	0cf436c9a7	chore: dep bump	2019-06-11 10:42:26 -05:00
calebboyd	77f49eb07a	fix: asset alias	2019-06-11 10:36:09 -05:00
calebboyd	9bc98bf597	ci: fix gcc version	2019-06-10 15:50:26 -05:00
calebboyd	7e9a05675c	fix: reference ogfs in readFilePath for internalmethods	2019-06-05 15:03:49 -05:00
calebboyd	e62d728624	fix: uppercase windows path letters after normalize closes #618	2019-05-28 18:04:16 -05:00
Jason Cooke	a0c8d31f03	docs: fix typo (#625 )	2019-05-23 18:17:55 -05:00
calebboyd	472b98d839	chore: publish copyFile shim	2019-04-28 14:28:59 -05:00
calebboyd	9ae6ed8ae8	chore: log open handles after a minute or two	2019-04-28 13:28:40 -05:00
calebboyd	a0c648bc8b	chore: set install directory for nasm	2019-04-26 14:33:26 -05:00
Daniel Ruf	463595f502	chore: typo	2019-04-25 11:23:08 -05:00
calebboyd	be4ab09745	chore: update ci in readme	2019-04-25 11:22:19 -05:00
calebboyd	a6ad034336	chore: set env variables	2019-04-18 13:27:08 -05:00
calebboyd	0afbe3b732	chore: fix types in azure build script	2019-04-15 23:03:41 -05:00
calebboyd	0865fda5ef	fix: don't infer main module when not in tty	2019-04-15 23:01:50 -05:00
calebboyd	7bfdc39700	chore: add azure-pipeline.yml	2019-04-15 17:12:41 -05:00
calebboyd	9486399cec	chore: update alpine build script	2019-04-15 14:59:57 -05:00
calebboyd	75bf6a3dc4	chore: naive copyFile patch	2019-04-14 21:37:06 -05:00
calebboyd	0dca0745ee	feat(fs): add option to restore all but internal filesystem methods	2019-04-08 22:14:51 -05:00
Antonio Nuno Monteiro	6fc2ed9519	fix: snapshot gyp variable name after node 11 (#606 ) this changed from `embed_script` to `v8_embed_script` after node 11	2019-04-08 21:14:16 -05:00
calebboyd	448f4270ea	fix: set entrypoint correctly when outside a tty	2019-04-08 16:23:21 -05:00
calebboyd	c9c9b5a0a3	fix: mount vfs relative to execPath instead of cwd	2019-04-08 11:10:33 -05:00
calebboyd	d2756a5f75	fix: load implicit input if stdin is empty without a tty	2019-04-04 23:54:06 -05:00
calebboyd	255f3887c7	chore: remove unused methods	2019-04-04 19:37:30 -05:00
calebboyd	75ae41b7b9	chore: bump version	2019-04-04 09:48:17 -05:00
calebboyd	3692c142fb	doc: describe mangle option	2019-04-04 09:47:20 -05:00
calebboyd	af2e381ed4	feat: ensure output directory exists closes #590	2019-04-04 09:35:15 -05:00
jerry_liu	44393a22da	More flexiable nexe footer search range to fix digital sign binary launch issue Fix #372	2019-04-03 13:37:31 -05:00
jerry_liu	57a08d2cfd	remove compress option	2019-04-03 08:15:21 -05:00
calebboyd	6825cef609	feat: asset option	2019-04-03 08:12:26 -05:00
calebboyd	b3c2d2e764	fix: use hardcoded version for asset url	2019-04-01 16:38:47 -05:00
calebboyd	d73325ba35	chore: analyze resources as entrypoints	2019-03-30 20:18:41 -07:00
calebboyd	6e3cadbe22	chore: dep bump	2019-03-30 13:54:51 -07:00
calebboyd	de42dd94ad	refactor: run download for src and prebuilt before plugins or patches	2019-03-30 13:29:58 -07:00
calebboyd	37192e4ca8	fix: ignore node cli for 11.6.0+	2019-03-28 19:19:03 -07:00
calebboyd	c5cdbd9380	chore: remove unused directories in appveyor	2019-03-09 15:27:25 -06:00
calebboyd	b022cd525d	fix: size on bundled stat	2019-02-21 22:33:44 -06:00
bruce-one	72d9dfebf6	fix(fs): stat file and directories for bundled files (#589 ) Ensure Stat return has correct prototype. In particular to fix `Reflect.apply(Stats.prototype.isFile, stat, [])`.	2019-02-21 18:48:49 -06:00
calebboyd	8849ac0c0c	chore: don't try to upload an existing asset	2019-01-31 19:56:36 -06:00
calebboyd	8ad6641278	chore: update travis vm	2019-01-31 17:54:10 -06:00
calebboyd	1a75bdb058	fix: avoid syncronous errors in compile method	2019-01-23 20:31:11 -06:00
calebboyd	12c77a34fd	chore: update resolve-dependencies	2019-01-05 11:25:36 -06:00
calebboyd	c76edb7c0b	chore: expose build on compiler	2018-12-31 08:51:53 -06:00
calebboyd	09d7093295	fix: ignore parsing errors in node_modules	2018-12-21 19:58:34 -06:00
calebboyd	3a091f45bd	refactor(fs-patches): don't destroy arguments for non bundled files	2018-12-15 16:38:32 -06:00
bruce-one	9575c0811b	refactor: avoid checking DEBUG every log, if set. (#562 )	2018-12-05 19:51:04 -06:00
calebboyd	ab6b540e23	fix: filter parser warnings	2018-11-29 09:47:35 -06:00
calebboyd	dcea374922	fix: input detection and validity closes #556, #548, #547, #533	2018-11-28 20:25:59 -06:00
calebboyd	b3b6c6b936	chore: use npm i	2018-11-21 21:42:22 -06:00
calebboyd	058c34ee8a	chore: update node-cli patches for 10-10.9	2018-11-21 18:31:06 -06:00
calebboyd	9750c70873	chore: update circle-ci caching	2018-11-21 10:58:03 -06:00
calebboyd	7bc3a83667	fix: node 10 cli args	2018-11-20 14:35:35 -06:00
calebboyd	aa93ab6516	chore: update resolve-dependencies	2018-11-15 14:27:36 -06:00
calebboyd	c681a62566	chore: log json error response	2018-10-25 10:06:05 -05:00
calebboyd	2ea0f897d5	chore: bump version	2018-10-23 10:23:34 -05:00
António Nuno Monteiro	cfa3036694	feat: invalidate binary cache when snapshot file changes (#542 )	2018-10-23 09:31:17 -05:00
calebboyd	c3ba3ec872	chore: bump version	2018-10-21 12:25:35 -05:00
António Nuno Monteiro	142338ede6	fix: stringify `compiler.entrypoint` in shims (#541 )	2018-10-21 12:00:06 -05:00
calebboyd	e3f1d6fc74	fix: missing cwd on resolve	2018-10-20 11:31:05 -05:00
calebboyd	0db8122f8f	fix: handle configure script in node 10.11+	2018-10-20 11:23:12 -05:00
António Nuno Monteiro	129c2f86a0	fix: include snapshot in patches (#539 )	2018-10-20 11:16:41 -05:00
calebboyd	db766e2832	fix: use vcBuild and make based on current platform	2018-10-20 10:33:39 -05:00
calebboyd	e6a416cc4f	fix: add internalModuleReadJSON patch	2018-10-17 21:56:37 -05:00
calebboyd	35f4811826	fix: remove spread operator	2018-10-09 14:07:32 -05:00