bump deps

BREAKING: drop support for node < 14

BREAKING: removed snapshot, ico, and rc options

BREAKING: use python3 as default python binary

.editorconfig

@@ -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

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: https://www.paypal.me/calebsboyd

.github/ISSUE_TEMPLATE/bug-report.md

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

.github/ISSUE_TEMPLATE/feature.md

@@ -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**:

.github/PULL_REQUEST_TEMPLATE.md

@@ -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**:

.github/actions/nexe-alpine/Dockerfile

@@ -0,0 +1,4 @@
+FROM node:fermium-alpine3.10
+RUN apk add --no-cache build-base linux-headers bash clang python3
+SHELL ["/bin/bash", "--login", "-c"]
+CMD ["bash"]

.github/actions/nexe-alpine/action.yml

@@ -0,0 +1,16 @@
+# action.yml
+name: 'Hello World'
+description: 'Greet someone and record the time'
+inputs:
+  who-to-greet:  # id of input
+    description: 'Who to greet'
+    required: true
+    default: 'World'
+outputs:
+  time: # id of output
+    description: 'The time we greeted you'
+runs:
+  using: 'docker'
+  image: 'Dockerfile'
+  args:
+    - ${{ inputs.who-to-greet }}

.github/actions/nexe-linux/Dockerfile

@@ -0,0 +1,23 @@
+FROM centos:7
+
+RUN yum install -y which centos-release-scl && \
+  yum install -y devtoolset-9-gcc \
+    devtoolset-9-gcc-c++ \
+    make \
+    wget \
+    python3 && \
+  echo "source /opt/rh/devtoolset-9/enable" >> /etc/bashrc
+
+SHELL ["/bin/bash", "--login", "-c"]
+
+ADD flags.sh flags.sh
+
+ARG NODE_VERSION=14.20.0
+
+RUN wget https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}.tar.gz -O node.tar.gz && \
+  mkdir node && tar -zxf node.tar.gz -C node --strip-components=1 && \
+  rm node.tar.gz && \
+  cd node && \
+  . ../flags.sh && \
+  ./configure $(echo $CONFIGURE_FLAGS) && \
+  make $(echo $MAKE_FLAGS) && make install

.github/actions/nexe-linux/action.yml

@@ -0,0 +1,16 @@
+# action.yml
+name: 'Hello World'
+description: 'Greet someone and record the time'
+inputs:
+  who-to-greet:  # id of input
+    description: 'Who to greet'
+    required: true
+    default: 'World'
+outputs:
+  time: # id of output
+    description: 'The time we greeted you'
+runs:
+  using: 'docker'
+  image: 'Dockerfile'
+  args:
+    - ${{ inputs.who-to-greet }}

.github/actions/nexe-linux/flags.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+ARCH=$(uname -m)
+
+case $ARCH in
+  "x86_64")
+    CONFIGURE_FLAGS="--dest-cpu=x64"
+  ;;
+  "aarch64")
+  ;&
+  "armv7l")
+    CONFIGURE_FLAGS="--openssl-no-asm --dest-cpu=arm --with-arm-float-abi=hard"
+  ;;
+  *)
+    CONFIGURE_FLAGS=""
+  ;;
+esac
+
+MAKE_FLAGS="-j$(getconf _NPROCESSORS_ONLN)"

.github/workflows/auto-close-no-response.yml

@@ -0,0 +1,20 @@
+name: No Response
+
+# Both `issue_comment` and `scheduled` event types are required for this Action
+# to work properly.
+on:
+  issue_comment:
+    types: [created]
+  schedule:
+    - 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

.github/workflows/cd.yml

@@ -0,0 +1,52 @@
+name: Base Builds
+on:
+  push:
+    branches:
+      - refactor-old-node
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        version: ['14.20.0', '16.16.0', '18.5.0']
+        arch: [x64, x86]
+        plat: [arm, macos, windows, linux, alpine]
+        exclude:
+          - plat: arm
+            arch: x86
+          - plat: macos
+            arch: x86
+        include:
+          - plat: arm
+            os: ubuntu-20.04
+          - plat: macos
+            os: macos-12
+          - plat: windows
+            os: windows-2022
+          - plat: linux
+            os: ubuntu-20.04
+          - plat: alpine
+            os: ubuntu-20.04
+    name: 'Target: ${{matrix.plat}}-${{ matrix.arch }}-${{ matrix.version }} on ${{ matrix.os }}'
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Setup Python
+        uses: actions/setup-python@v3.1.2
+        with:
+          python-version: '3.10.4'
+      - name: Setup Nasm
+        if: ${{ matrix.plat == 'windows' }}
+        uses: ilammy/setup-nasm@v1.3.0
+      - uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.version }}
+      - uses: actions/checkout@v3
+        with:
+          node-version: 18
+      - name: 'Install Dependencies'
+        run: npm ci
+      - name: 'Build nexe base binary'
+        env:
+          NEXE_TARGET: ${{ matrix.plat }}-${{ matrix.arch }}-${{ matrix.version }}
+        run: npx ts-node tasks/build.ts

.gitignore

@@ -1,9 +1,12 @@
 .DS_Store
 temp/
 coverage
+nexe
 node_modules
 *.log
 *.exe
+*.bin
+!winsw.exe
 .idea
 .nexe
 lib

.node-version

@@ -0,0 +1 @@
+18.12.1

.swcrc

@@ -0,0 +1,19 @@
+{
+  "module": {
+    "type": "commonjs",
+    "ignoreDynamic": true
+    
+  },
+  "jsc": {
+    "parser": {
+      "syntax": "typescript",
+      "dynamicImport": true,
+      "decorators": true
+    },
+    "transform": {
+      "legacyDecorator": true
+    },
+    "target": "es2019",
+    "externalHelpers": false
+  }
+}

.travis.yml

@@ -1,9 +0,0 @@
-os: osx
-language: node_js
-node_js:
-- '6'
-script: npm run nexe-build
-env:
-  - secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
-notifications:
-  email: false

.vscode/extensions.json

@@ -1,5 +1,6 @@
 {
-    "recommendations": [
+  "recommendations": [
-      "esbenp.prettier-vscode"
+    "esbenp.prettier-vscode",
-    ]
+    "dbaeumer.vscode-eslint"
+  ]
 }

.vscode/settings.json

@@ -1,9 +1,4 @@
 {
-  "typescript.tsdk": "./node_modules/typescript/lib",
-  "prettier.semi": false,
-  "prettier.singleQuote": true,
-  "prettier.typescriptEnable": ["typescript"],
-  "editor.trimAutoWhitespace": true,
   "files.exclude": {
     "**/.git": true,
     "**/.svn": true,
@@ -15,5 +10,33 @@
     "lib/**/*": true,
     "**/node_modules": true,
     "**/bower_components": true
+  },
+  "eslint.workingDirectories": [{ "mode": "auto" }],
+  "eslint.format.enable": true,
+  "editor.formatOnSave": true,
+  "eslint.validate": [
+    "javascript",
+    "javascriptreact",
+    "typescript",
+    "typescriptreact"
+  ],
+  "[javascript]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[javascriptreact]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[typescript]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[typescriptreact]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": true
   }
 }

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2017 Nexe Contributors
+Copyright (c) 2013-2022 Nexe Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -1,67 +1,97 @@
+
 <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/nexe/nexe.svg" alt="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://discord.gg/2qTH52zNcZ"><img src="https://discordapp.com/api/guilds/814334925049561168/widget.png?style=shield"></a>
 </p>
 
-<p align="center"><code>npm i nexe@beta -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">
-  <img src="https://cloud.githubusercontent.com/assets/5818726/26533446/ce19ee5a-43de-11e7-9540-caf7ebd93370.gif"/>
+  <img src="https://user-images.githubusercontent.com/5818726/30999006-df7e0ae0-a497-11e7-96db-9ce87ae67b34.gif"/>
 </p>
 
 ## Motivation and Features
 
-- Supports production ready builds
 - Self contained applications
 - Ability to run multiple applications with *different* node.js runtimes.
 - Distribute binaries without needing node / npm.
 - Idempotent builds
 - Start and deploy faster.
-- Lockdown specific application versions, and easily rollback.
+- Lock-down specific application versions, and easily rollback.
 - Flexible build pipeline
 - Cross platform builds
 
 ## Usage
 
-- Existing application bundle:
+- Application entrypoint:
 
-  `nexe my-app-bundle.js -o my-app`
+  `nexe my-app.js`
 
 - stdin interface
 
-  `rollup -c | nexe --resource ./public/**/* -o my-app.exe`
+  `rollup -c | nexe --resource "./public/**/*" -o my-app.exe`
 
 For more CLI options see: `nexe --help`
 
-## Including Additional Resources
+### Examples
 
-Additional resources can be added to the binary by passing `-r glob/pattern/**/*`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`
+- `nexe server.js -r "public/**/*.html"`
+- `nexe --build`
+- `nexe -t x86-8.0.0`
 
-## Compiling Node
+## Resources
 
-By default `nexe` will attempt to download a pre-built executable. However, some users may want to customize the way node is built, either by changing the flags, providing a different icon, or different executable details. To build node, use the `build` option/flag
+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`.
 
-Nexe also exposes its patching pipeline to the user. This allows the application of simple patching of node sources prior to compilation.
+## Compiling the nexe Executable
+
+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 3; you can create a [symlink](https://github.com/nexe/nexe/issues/354#issuecomment-319874486) or use the `--python` parameter (e.g. `nexe --build --python=$(which python3)`).
+
+### 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 python3.8
+```
+Where `2019` is the version of Visual Studio you have (if you have it).
+
+**Notes:**
+- 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
 
-Using Nexe Programatically
-
 #### Example
 
-
 ```javascript
 const { compile } = require('nexe')
 
 compile({
   input: './my-app.js',
-  output: './my-app.exe',
+  build: true, //required to use patches
-  build: true, //builds node
   patches: [
     async (compiler, next) => {
       await compiler.setFileContentsAsync(
@@ -75,92 +105,110 @@ compile({
   console.log('success')
 })
 ```
+## NexeOptions
 
-### `options`
+### `options: object`
 
- - #### `build: boolean`
-    - Build node from source (required in beta)
  - #### `input: string`
     - Input bundle file path
     - default: stdin or the current directory's main file (package.json)
  - #### `output: string`
     - Output executable file path
     - default: same as `name` with an OS specific extension.
- - #### `target: string`
+ - #### `target: string | object`
-    - Dash seperated platform-architecture-version. e.g. `'win32-ia32-6.10.3'`
+    - An object or string describing platform-arch-version. e.g. `'windows-ia32-18.1.0'`
-    - default: `[process.platform, process.arch, process.version.slice(1)].join('-')`
+      - each segment is optional, and will be merged with the current environment
+      - Examples: ([full list](https://github.com/nexe/nexe/releases))
+        - `'win32-x86-18.1.0`
+        - `{ platform: 'alpine' }`
+        - `darwin-14.19.1`
+        - `linux-x64`
+        - `macos-16.15.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.
+    - default: `process`
 - #### `bundle: string | boolean`
     - If a string is provided it must be a valid relative module path
     and should provide an export with the following signature:
     ```typescript
-    export function createBundle (
+    export function createBundle (options: NexeOptions): Promise<string>
-      filename: string,
-      options: { name: string, minify: any, cwd: string }
-    ): Promise<string>`
     ```
-    - default: true, uses the internal fuse-box configuration
+    - default: true
  - #### `name: string`
     - Module friendly name of the application
     - default: basename of the input file, or `nexe_${Date.now()}`
  - #### `cwd: string`
     - Directory nexe will operate on as though it is the cwd
     - default: process.cwd()
- - #### `version: string`
+ - #### `mangle: boolean`
-    - The Node version you're building for
+    - If set to false, nexe will not include the virtual filesystem (your application and resources) on the output.
-    - default: `process.version.slice(1)`
+    - 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 Linux this is the path pointing to your python3 executable
     - On Windows this is the directory where `python` can be accessed
     - default: `null`
- - #### `flags: Array<string>`
+ - #### `flags: string[]`
     - Array of node runtime flags to build node with.
     - Example: `['--expose-gc']`
     - default: `[]`
- - #### `configure: Array<string>`
+ - #### `configure: string[]`
     - Array of arguments for the node build configure step
     - Example: `['--with-dtrace', '--dest-cpu=x64']`
     - default: `[]`
- - #### `make: Array<string>`
+ - #### `make: string[]`
-    - Array of arguments for the node build make step, on windows this step recieves options for vcBuild.bat
+    - Array of arguments for the node build make step
-    - default: `[]` or `['nosign', 'release']` for non windows systems
+    - default: `[]`
- - #### `make: Array<string>`
+ - #### `vcBuild: string[]`
-    - Alias for `make` option
+    - Options for windows build
- - #### `snapshot: string`
+    - default: `['nosign', 'release']`
-    - path to a file to be used as the warmup snapshot for the build
+ - #### `resources: string[]`
-    - default: `null`
- - #### `resources: Array<string>`
     - Array of globs with files to include in the build
     - Example: `['./public/**/*']`
     - default: `[]`
  - #### `temp: string`
     - Path to use for storing nexe's build files
     - Override in the env with `NEXE_TEMP`
-    - default: `./.nexe` in the cwd
+    - default: `~/.nexe`
- - #### `ico: string`
-    - Path to a user provided icon to be used (Windows only).
- - #### `rc: object`
-    - Settings for patching the [node.rc](https://github.com/nodejs/node/blob/master/src/res/node.rc) configuration file (Windows only).
-    - Example: `{ CompanyName: "ACME Corp" }`
-    - default: `{}`
  - #### `clean: boolean`
-    - If included, nexe will remove temporary files for accompanying configuration and exit
+    - If included, nexe will remove temporary files for the accompanying configuration and exit
  - #### `enableNodeCli: boolean`
-    - Enable the original Node CLI (will prevent application cli from working)
+    - Enable the original Node CLI (will prevent application cli from working).
+    - Node CLI arguments passed via the [NODE_OPTIONS](https://nodejs.org/api/cli.html#cli_node_options_options) environment
+      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]'`.
+ - #### `ghToken: string`
+    - Provide a Github Token for accessing nexe releases
+    - This is usually needed in CI environments
+    - default: `process.env.GITHUB_TOKEN`
  - #### `sourceUrl: string`
-    - Provide an alternate url for the node source. Should be a `.tar.gz`
+    - Provide an alternate url for the node source code
+    - Note: temporary files will still be created for this under the specified version
  - #### `loglevel: string`
     - Set the loglevel, info, silent, or verbose
     - default: `'info'`
- - #### `patches: Array<NexePatch>`
+ - #### `patches: NexePatch[]`
     - Userland patches for patching or modifying node source
     - default: `[]`
+ - #### `plugins: NexePatch[]`
+    - Userland plugins for modifying nexe executable behavior
+    - default: `[]`
 
 ### `NexePatch: (compiler: NexeCompiler, next: () => Promise<void>) => Promise<void>`
 
-A patch is just a middleware function that takes two arguments, the `compiler`, and `next`. The compiler is described below, and `next` ensures that the pipeline continues. Its invocation should always be awaited or returned to ensure correct behavior.
+Patches and Plugins are just a middleware functions that take two arguments, the `compiler`, and `next`. The compiler is described below, and `next` ensures that the pipeline continues. Its invocation should always be awaited or returned to ensure correct behavior. Patches also require that [`--build`](#build-boolean) be set, while plugins do not.
 
-For examples, see the built in patches: [src/patches](src/patches)
+For examples, see the built in patches: [src/patches](src/patches).
 
 ### `NexeCompiler`
 
@@ -170,7 +218,9 @@ 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.
- - `files: Array<NexeFile>`
+ - `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.
 
 #### `NexeFile`
@@ -180,19 +230,31 @@ For examples, see the built in patches: [src/patches](src/patches)
 
 Any modifications made to `NexeFile#contents` will be maintained in the cache _without_ the need to explicitly write them back out, e.g. using `NexeCompiler#setFileContentsAsync`.
 
-### Native Modules
+## Native Modules
 
-Nexe has a plugin built for use with [fuse-box](http://fuse-box.org) > 2.2.1. This plugin currently supports modules that require `.node` files and those that use the `bindings` module.
+In order to use native modules, the native binaries must be shipped alongside the binary generated by nexe.
-Take a look at the [example](examples/native-build/build.js)
 
-- [ ] Implement support `node-pre-gyp#find`.
+## Troubleshooting
 
-## Maintainers
+`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-18.1.0`
+		- 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
 
-[![Jared Allard](https://avatars.githubusercontent.com/u/2391349?s=130)](https://jaredallard.me/) | [![Caleb Boyd](https://avatars.githubusercontent.com/u/5818726?s=130)](https://github.com/calebboyd) | [![Christopher Karper](https://avatars.githubusercontent.com/u/653156?s=130)](https://github.com/ckarper) | [![Dustin Greif](https://avatars.githubusercontent.com/u/3026298?s=130)](https://github.com/dgreif) |
+## Contributing
----|---|---|---
-[Jared Allard](https://github.com/jaredallard) | [Caleb Boyd](http://github.com/calebboyd) | [Christopher Karper](https://github.com/ckarper) | [Dustin Greif](https://github.com/dgreif) |
 
-### Former
+Building
+```
+$ git clone git@github.com:nexe/nexe.git
+$ cd nexe
+$ npm i && npm run build
+```
 
-- [Craig Condon](http://crcn.codes/)
+Testing
+```
+$ npm test
+```

appveyor.yml

@@ -1,21 +0,0 @@
-environment:
-  CIRCLE_TOKEN:
-    secure: TQKcepXmTzCNt4+tUBtYpwEQkdSPwFr9A8ugtoMhNbKu/SW1WM1EpjEu6kYXxpQ4
-  TRAVIS_TOKEN:
-    secure: tR7HXYv3x97q90uvPrjUxKZh7R1+uqKct0HdEcqTbsg=
-  GITHUB_TOKEN:
-    secure: 3wuEGJsppSKFvdwhp3jprUA9Zkc3WINlc/9oFXjhAR6J05lYMXP7Fl7lXTKpkGZx
-branches:
-  except:
-    - master
-install:
-  - ps: Install-Product node 6
-  - npm i
-build: off
-test: off
-build_script:
-  - npm run nexe-build
-artifacts:
-  - path: .nexe\**\node.exe
-cache:
-  - node_modules

circle.yml

@@ -1,8 +0,0 @@
-machine:
-  node:
-    version: 6.11.2
-  services:
-    - docker
-test:
-  override:
-    - npm run nexe-build

dockerfiles/linux/Dockerfile

@@ -0,0 +1,13 @@
+FROM centos:7
+
+RUN yum install -y which centos-release-scl \
+  && yum install -y devtoolset-9-gcc \
+    devtoolset-9-gcc-c++ \
+    make \
+    python3 \
+    curl \
+  && curl -sL https://rpm.nodesource.com/setup_16.x | bash - \
+  && yum install -y nodejs && npm install nexe -g \
+  && echo "source /opt/rh/devtoolset-9/enable" >> /etc/bashrc
+
+SHELL ["/bin/bash", "--login", "-c"]

dockerfiles/musl/Dockerfile

@@ -0,0 +1,4 @@
+FROM node:16-alpine
+RUN apk add --no-cache build-base linux-headers bash clang python3
+SHELL ["/bin/bash", "--login", "-c"]
+CMD ["bash"]

examples/native-build/build.js

@@ -1,22 +0,0 @@
-const { FuseBox } = require('fuse-box')
-const { NativeModulePlugin } = require('../../lib/bundling')
-const fuse = FuseBox.init({
-  homeDir: './',
-  cache: false,
-  log: true,
-  debug: true,
-  output: '$name.js',
-  plugins: [
-    new NativeModulePlugin({
-      zmq: {
-        additionalFiles: [
-          '../../windows/lib/x64/libzmq-v100-mt-4_0_4.dll'
-        ]
-      }
-    })
-  ]
-})
-fuse.bundle('app')
-    .target('server')
-    .instructions(`> index.js`)
-fuse.run()

examples/native-build/index.js

@@ -1,19 +0,0 @@
-var zmq = require('zmq')
-var pub = zmq.socket('pub')
-
-pub.bindSync('tcp://127.0.0.1:3000')
-console.log('Publisher bound to port 3000')
-
-setInterval(function(){
-  console.log('sending a multipart message envelope')
-  pub.send(['kitty cats', 'meow!'])
-}, 2500)
-console.log('global', global.require.main)
-var sub = zmq.socket('sub')
-sub.connect('tcp://127.0.0.1:3000')
-sub.subscribe('kitty cats')
-console.log('Subscriber connected to port 3000')
-
-sub.on('message', function(topic, message) {
-  console.log('received a message related to:', topic.toString(), 'containing message:', message.toString())
-})

examples/native-build/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "native-build",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "bundle": "node build",
-    "build-windows": "nexe -i app.js -o app.exe"
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "zmq": "^2.15.3"
-  },
-  "devDependencies": {
-    "fuse-box": "^2.2.1-beta.7"
-  }
-}

index.js

@@ -1,10 +1,45 @@
 #!/usr/bin/env node
-const nexe = require('./lib/nexe')
 
-module.exports = nexe
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+const eol = require('os').EOL
+async function main() {
+  const util = require('./lib/cjs/util.js')
+  await util.initEsm()
+  const color = util.color,
+    options = require('./lib/cjs/options.js'),
+    nexe = require('./lib/cjs/nexe.js'),
+    NexeError = require('./lib/cjs/compiler.js').NexeError,
+    del = eol + eol,
+    argv = options.argv,
+    showHelp = argv.help || argv._.some((x) => x === 'help'),
+    showVersion = argv.version || argv._.some((x) => x === 'version')
+
+  try {
+    if (!(showHelp || showVersion)) {
+      await nexe.compile(argv)
+    } else {
+      process.stderr.write(showHelp ? options.help() : options.version + eol)
+    }
+  } catch (error) {
+    if (argv.loglevel !== 'silent') {
+      if (error instanceof NexeError) {
+        process.stderr.write(
+          `${eol}${color('red', 'Error: ')}${error.message}${del}See nexe -h for usage..${del}`
+        )
+      } else {
+        process.stderr.write(error.stack + eol)
+      }
+    }
+    process.exit(1)
+  }
+  process.exit(0)
+}
 
 if (require.main === module) {
-  nexe.compile(nexe.argv).catch((e) => {
+  main()
-    process.stderr.write(e.stack, () => process.exit(1))
+} else {
-  })
+  process.stderr.write('Cannot require(..) the nexe cli')
+  process.exit(1)
 }

issue_template.md

@@ -1,21 +0,0 @@
-This is a
- - [ ] Bug Report
- - [ ] Feature Request
- - [ ] Other
-
-<br/>
-If this is a bug report, What are the steps to reproduce?
-
-```
-//provide configuration here
-```
-
-<br/><br/>
-Please also provide:
-
-- Platform(OS/Version):
-- Host Node Version:
-- Target Node Version:
-- Nexe version:
-- Python Version:
-

package.json

@@ -2,18 +2,25 @@
   "name": "nexe",
   "description": "Create a single executable out of your Node.js application",
   "license": "MIT",
-  "version": "2.0.0-rc.2",
+  "type": "commonjs",
-  "contributors": [
+  "version": "4.0.0-rc.local",
-    "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
+  "bin": {
-    "Jared Allard <jaredallard@outlook.com>",
+    "nexe": "./index.js"
-    "Caleb Boyd <caleb.boyd@hotmail.com>"
+  },
-  ],
+  "types": "./lib/types/nexe.d.ts",
-  "scripts": {
+  "main": "./lib/cjs/nexe.js",
-    "nexe-build": "ts-node tasks/build",
+  "exports": {
-    "prebuild": "rimraf lib && npm run lint",
+    "./package.json": "./package.json",
-    "prepublish": "npm run build",
+    ".": {
-    "lint": "prettier --parser typescript --no-semi --print-width 100 --single-quote --write \"src/**/*.ts\"",
+      "types": "./lib/types/nexe.d.ts",
-    "build": "tsc --declaration"
+      "node": {
+        "import": "./lib/esm/nexe.js",
+        "require": "./lib/cjs/nexe.js"
+      }
+    }
+  },
+  "engines": {
+    "node": ">=14"
   },
   "repository": {
     "type": "git",
@@ -21,43 +28,97 @@
   },
   "files": [
     "lib",
-    "source-map-support.js"
+    "index.js"
   ],
-  "main": "index.js",
+  "scripts": {
-  "bin": {
+    "lint": "tsc --noEmit && eslint \"{src,tasks,test}/**/*.ts\" --fix",
-    "nexe": "index.js"
+    "test": "vitest run && node test/exports.mjs",
-  },
+    "prepublishOnly": "npm run lint && npm run build && npm test",
-  "engines": {
+    "build": "npm run cjs:build & npm run esm:build",
-    "node": ">=6"
+    "prebuild": "rm -rf lib",
+    "cjs:build": "swc src -d lib/cjs --copy-files",
+    "esm:build": "swc src -d lib/esm --copy-files -C module.type=es6",
+    "postbuild": "node -p \"JSON.stringify({type:'module'})\" > lib/esm/package.json && tsc --emitDeclarationOnly && ts-node tasks/post-build"
   },
+  "contributors": [
+    "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
+    "Jared Allard <jaredallard@outlook.com>",
+    "Caleb Boyd <caleb.boyd@hotmail.com>"
+  ],
   "dependencies": {
-    "app-builder": "^5.1.0",
+    "caw": "^2.0.1",
-    "chalk": "^1.1.3",
+    "chalk": "^5.2.0",
-    "download": "^6.2.0",
+    "download": "^8.0.0",
-    "fuse-box": "^2.2.1",
+    "fast-glob": "^3.2.12",
-    "globby": "^6.1.0",
+    "got": "^12.5.3",
-    "minimist": "^1.2.0",
+    "meriyah": "^4.3.3",
-    "mkdirp": "^0.5.1",
+    "minimist": "^1.2.7",
-    "ora": "^1.2.0",
+    "multistream": "^4.1.0",
-    "pifi": "1.0.0",
+    "ora": "^6.1.2",
-    "rimraf": "^2.6.1",
+    "resolve-dependencies": "^6.0.8"
-    "uglify-js": "3.0.28"
   },
   "devDependencies": {
-    "@types/bluebird": "^3.5.8",
+    "@swc/cli": "^0.1.57",
-    "@types/chalk": "^0.4.31",
+    "@swc/core": "^1.3.24",
-    "@types/execa": "0.7.0",
+    "@types/minimist": "^1.2.2",
-    "@types/globby": "^0.6.0",
+    "@types/multistream": "^4.1.0",
-    "@types/minimist": "^1.2.0",
+    "@typescript-eslint/eslint-plugin": "^5.47.0",
-    "@types/mkdirp": "^0.3.29",
+    "@typescript-eslint/parser": "^5.47.0",
-    "@types/ora": "^0.3.31",
+    "eslint": "^8.30.0",
-    "@types/pify": "0.0.28",
+    "eslint-config-prettier": "~8.5.0",
-    "@types/rimraf": "0.0.28",
+    "eslint-plugin-import": "^2.26.0",
-    "execa": "0.8.0",
+    "eslint-plugin-prettier": "^4.2.1",
-    "got": "^7.1.0",
+    "prettier": "^2.8.1",
-    "mocha": "^3.2.0",
+    "ts-node": "^10.9.1",
-    "prettier": "^1.6.1",
+    "typescript": "^4.9.4",
-    "ts-node": "3.3.0",
+    "vitest": "^0.26.2"
-    "typescript": "^2.4.1"
+  },
+  "prettier": {
+    "parser": "typescript",
+    "semi": false,
+    "singleQuote": true,
+    "printWidth": 100
+  },
+  "eslintConfig": {
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+      "import",
+      "@typescript-eslint"
+    ],
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/recommended",
+      "prettier",
+      "plugin:prettier/recommended"
+    ],
+    "rules": {
+      "@typescript-eslint/consistent-type-imports": [
+        2,
+        {
+          "prefer": "type-imports",
+          "disallowTypeAnnotations": false
+        }
+      ],
+      "import/extensions": [
+        2,
+        "ignorePackages"
+      ],
+      "@typescript-eslint/no-unused-vars": [
+        2,
+        {
+          "args": "after-used",
+          "ignoreRestSiblings": true,
+          "argsIgnorePattern": "^_"
+        }
+      ],
+      "@typescript-eslint/no-use-before-define": 0,
+      "@typescript-eslint/no-explicit-any": 0,
+      "@typescript-eslint/explicit-function-return-type": 0,
+      "no-warning-comments": 1,
+      "one-var": [
+        "error",
+        "consecutive"
+      ]
+    }
   }
 }

src/bundling/bindings-rewrite.ts

@@ -1,162 +0,0 @@
-import * as fs from 'fs'
-import * as path from 'path'
-import * as child from 'child_process'
-import { createHash } from 'crypto'
-
-export interface ExtractNodeModuleOptions {
-  [key: string]: { additionalFiles: string[] } | true
-}
-
-function hashName(name: string | Buffer) {
-  return createHash('md5')
-    .update(name)
-    .digest('hex')
-    .toString()
-    .slice(0, 8)
-}
-
-export function embedDotNode(
-  options: ExtractNodeModuleOptions,
-  file: { contents: string; absPath: string }
-) {
-  const contents = fs.readFileSync(file.absPath)
-  const module = Object.keys(options).find(x =>
-    Boolean(~file.absPath.indexOf(path.join('node_modules', x)))
-  )!
-  const bindingName = path.basename(file.absPath)
-  const settings = options[module]
-  const moduleDir = hashName(contents)
-  file.contents = `
-  var fs=require('fs');var path=require('path');var binding='${contents.toString(
-    'base64'
-  )}';function mkdirp(r,t){t=t||null,r=path.resolve(r);try{fs.mkdirSync(r),t=t||r}catch(c){if("ENOENT"===c.code)t=mkdirp(path.dirname(r),t),mkdirp(r,t);else{var i;try{i=fs.statSync(r)}catch(r){throw c}if(!i.isDirectory())throw c}}return t};`
-
-  if (settings === true) {
-    file.contents += `
-      mkdirp('${moduleDir}');
-      var bindingPath = path.join(process.cwd(), '${moduleDir}', '${bindingName}')
-      require('fs').writeFileSync(bindingPath, Buffer.from(binding, 'base64'))
-      process.dlopen(module, bindingPath)
-    `.trim()
-    return
-  }
-
-  let depth = 0
-  settings.additionalFiles.forEach(file => {
-    let ownDepth = 0
-    file.split('/').forEach(x => x === '..' && ownDepth++)
-    depth = ownDepth > depth ? ownDepth : depth
-  })
-  let segments = [moduleDir]
-  while (depth--) {
-    segments.push(hashName(moduleDir + depth))
-  }
-  segments.push(bindingName)
-
-  file.contents += `
-    var cwd = process.cwd()
-    var bindingFileParts = ${JSON.stringify(segments)};
-    var bindingFile = path.join.apply(path, [cwd].concat(bindingFileParts));
-    mkdirp(path.dirname(bindingFile));
-    fs.writeFileSync(bindingFile, Buffer.from(binding, 'base64'));
-    ${settings.additionalFiles.reduce((code, filename, i) => {
-      const contents = fs.readFileSync(path.join(path.dirname(file.absPath), filename))
-      return (code += `
-        var file${i} = '${contents.toString('base64')}';
-        var filePath${i} = path.join(cwd, bindingFileParts[0], '${filename.split('../').join('')}');
-        mkdirp(path.dirname(filePath${i}));
-        fs.writeFileSync(filePath${i}, Buffer.from(file${i}, 'base64'));
-      `)
-    }, '')};
-    process.dlopen(module, bindingFile)
-  `
-}
-
-function findNativeModulePath(filePath: string, bindingsArg: string) {
-  const dirname = path.dirname(filePath)
-  const tempFile = Math.random() * 100 + '.js'
-  const tempFilePath = path.join(dirname, tempFile)
-  fs.writeFileSync(
-    tempFilePath,
-    `
-    var bindings = require('bindings');
-    var Module = require('module');
-    var originalRequire = Module.prototype.require;
-    Module.prototype.require = function(path) {
-      const mod = originalRequire.apply(this, arguments);
-      process.stdout.write(path)
-      return mod
-    };
-    bindings('${bindingsArg}')
-  `
-  )
-  //using exec because it can be done sync
-  const nativeFileName = child.execSync('node ' + tempFile, { cwd: dirname }).toString()
-  fs.unlinkSync(tempFilePath)
-  const relativePath = './' + path.relative(dirname, nativeFileName).replace(/\\/g, '/')
-  return relativePath
-}
-/**
- * Traverse all nodes in a file and evaluate usages of the bindings module
- * handles two common cases
- */
-export class BindingsRewrite {
-  private bindingsIdNodes: any[] = []
-  public nativeModulePaths: string[] = []
-  public rewrite = false
-
-  isRequireBindings(node: any) {
-    return node.callee.name === 'require' && node.arguments[0].value === 'bindings'
-  }
-
-  onNode(absolutePath: string, node: any, parent: any) {
-    if (node.type === 'CallExpression') {
-      if (this.isRequireBindings(node) && parent.type === 'VariableDeclarator') {
-        /**
-         * const loadBindings = require('bindings');
-         *   -> const loadBindings = String('');
-         */
-        this.bindingsIdNodes.push(parent.id)
-        node.callee.name = 'String'
-        node.arguments[0].value = ''
-        this.rewrite = true
-        return
-      }
-
-      if (this.isRequireBindings(node) && parent.type === 'CallExpression') {
-        /**
-         *const bindings = require('bindings')('native-module')....
-         *  -> const bindings = require('./path/to/native/module.node').....
-         */
-        const bindingsArgNode = parent.arguments[0]
-        if (bindingsArgNode.type === 'Literal') {
-          parent.callee = { type: 'Identifier', name: 'require' }
-          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
-          this.nativeModulePaths.push(bindingsArgNode.value)
-          this.rewrite = true
-          return
-        }
-      }
-
-      const bindingsInvocationIdx = this.bindingsIdNodes.findIndex(x => node.callee.name === x.name)
-
-      if (this.bindingsIdNodes[bindingsInvocationIdx]) {
-        /**
-         * const bindings = loadBindings('native-module')
-         *   -> const bindings = require('./path/to/native/module.node')
-         */
-        const bindingsIdNode = this.bindingsIdNodes[bindingsInvocationIdx]
-        const bindingsArgNode = node.arguments[0]
-        this.bindingsIdNodes.splice(bindingsInvocationIdx, 1)
-
-        if (bindingsArgNode.type === 'Literal') {
-          node.callee.name = 'require'
-          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
-          this.nativeModulePaths.push(bindingsArgNode.value)
-          this.rewrite = true
-          return
-        }
-      }
-    }
-  }
-}

src/bundling/fuse-native-module-plugin.ts

@@ -1,70 +0,0 @@
-import { BindingsRewrite, embedDotNode, ExtractNodeModuleOptions } from './bindings-rewrite'
-
-export interface FuseBoxFile {
-  info: { absPath: string }
-  absPath: string
-  contents: string
-  analysis: {
-    dependencies: string[]
-    requiresRegeneration: boolean
-  }
-  loadContents(): void
-  makeAnalysis(
-    parsingOptions?: any,
-    traversalPlugin?: {
-      plugins: Array<{
-        onNode(file: FuseBoxFile, node: any, parent: any): void
-        onEnd(file: FuseBoxFile): void
-      }>
-    }
-  ): void
-}
-
-export default function(options: ExtractNodeModuleOptions) {
-  return new NativeModulePlugin(options)
-}
-
-export class NativeModulePlugin {
-  public test: RegExp
-  public limit2Project = false
-  private modules: (keyof ExtractNodeModuleOptions)[]
-
-  constructor(public options: ExtractNodeModuleOptions) {
-    this.options = options
-    this.test = new RegExp(`node_modules\/(${Object.keys(options).join('|')}).*\.js|\.node$`)
-  }
-
-  init(context: any) {
-    context.allowExtension('.node')
-  }
-
-  transform(file: FuseBoxFile) {
-    file.loadContents()
-
-    if (file.absPath.endsWith('.node')) {
-      embedDotNode(this.options, file)
-      return
-    }
-
-    const bindingsRewrite = new BindingsRewrite()
-    file.makeAnalysis(null, {
-      plugins: [
-        {
-          onNode(file, node, parent) {
-            bindingsRewrite.onNode(file.absPath, node, parent)
-          },
-          onEnd(file) {
-            if (bindingsRewrite.rewrite) {
-              const index = file.analysis.dependencies.indexOf('bindings')
-              if (~index) {
-                file.analysis.dependencies.splice(index, 1)
-              }
-              file.analysis.dependencies.push(...bindingsRewrite.nativeModulePaths)
-              file.analysis.requiresRegeneration = true
-            }
-          }
-        }
-      ]
-    })
-  }
-}

src/bundling/fuse.ts

@@ -1,57 +0,0 @@
-import { NexeCompiler } from '../compiler'
-import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } from 'fuse-box'
-import { readFileAsync } from '../util'
-//import NativeModulePlugin from './fuse-native-module-plugin'
-
-function createBundle(filename: string, options: { name: string; minify: any; cwd: string }) {
-  const plugins: any = [JSONPlugin(), CSSPlugin(), HTMLPlugin()]
-  if (options.minify) {
-    plugins.push(
-      QuantumPlugin({
-        target: 'server',
-        uglify: true,
-        bakeApiIntoBundle: options.name
-      })
-    )
-  }
-  const fuse = FuseBox.init({
-    cache: false,
-    log: Boolean(process.env.NEXE_BUNDLE_DEBUG) || false,
-    homeDir: options.cwd,
-    sourceMaps: false,
-    writeBundles: false,
-    output: '$name.js',
-    target: 'server',
-    plugins
-  })
-  fuse.bundle(options.name).instructions(`> ${filename}`)
-  return fuse.run().then(x => {
-    let output = ''
-    x.bundles.forEach(y => (output = y.context.output.lastPrimaryOutput.content!.toString()))
-    return output
-  })
-}
-
-export default async function bundle(compiler: NexeCompiler, next: any) {
-  if (!compiler.options.bundle) {
-    compiler.input = await readFileAsync(compiler.options.input, 'utf-8')
-    return next()
-  }
-
-  if (compiler.options.empty || !compiler.options.input) {
-    compiler.input = ''
-    return next()
-  }
-
-  let producer = createBundle
-  if (typeof compiler.options.bundle === 'string') {
-    producer = require(compiler.options.bundle).createBundle
-  }
-
-  compiler.input = await producer(compiler.options.input, {
-    cwd: compiler.options.cwd,
-    name: compiler.options.name,
-    minify: compiler.options.compress
-  })
-  return next()
-}

src/bundling/index.ts

@@ -1 +0,0 @@
-export * from './fuse-native-module-plugin'

src/compiler.ts

@@ -1,227 +1,286 @@
-import { dirname, normalize, join } from 'path'
+import { resolve, normalize, join } from 'node:path'
-import { Buffer } from 'buffer'
+import { Buffer } from 'node:buffer'
-import { createHash } from 'crypto'
+import type { ReadStream } from 'node:fs'
-import { createReadStream } from 'fs'
+import { createReadStream } from 'node:fs'
-import { Readable } from 'stream'
+import { spawn } from 'node:child_process'
-import { spawn } from 'child_process'
-import { Logger } from './logger'
-import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows } from './util'
-import { NexeOptions, nexeVersion } from './options'
-import { NexeTarget } from './target'
-import download = require('download')
-import { getLatestGitRelease } from './releases'
-import { IncomingMessage } from 'http'
 
-const isBsd = Boolean(~process.platform.indexOf('bsd'))
+import type { File } from 'resolve-dependencies'
-const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
+import MultiStream from 'multistream'
-const configure = isWindows ? 'configure' : './configure'
+
+import type { LogStep } from './logger.js'
+import { Logger } from './logger.js'
+import { readFile, writeFile, pathExists, isWindows, bound, wrap } from './util.js'
+import { version } from './options.js'
+import type { NexeOptions } from './options.js'
+import type { NexeTarget } from './target.js'
+import { Bundle, toStream } from './fs/bundle.js'
+
+const isBsd = Boolean(~process.platform.indexOf('bsd')),
+  make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
+
+type StringReplacer = (match: string) => string
 
 export interface NexeFile {
   filename: string
   absPath: string
-  contents: string
+  contents: string | Buffer
 }
 
-interface NexeHeader {
+export { NexeOptions }
-  resources: { [key: string]: number[] }
+
-  version: string
+export class NexeError extends Error {
+  constructor(m: string) {
+    super(m)
+    Object.setPrototypeOf(this, NexeError.prototype)
+  }
 }
 
 export class NexeCompiler {
-  private start = Date.now()
+  /**
-  private env = { ...process.env }
+   * Epoch of when compilation started
-  private compileStep: { modify: Function; log: Function }
+   */
+  private readonly start = Date.now()
+  private compileStep: LogStep | undefined
   public log = new Logger(this.options.loglevel)
-  public src = join(this.options.temp, this.options.version)
+  /**
+   * 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[] = []
-  public input: string
+  /**
-  public bundledInput?: string
+   * Standalone pieces of code run before the application entrypoint
-  public output: string | null
+   */
-
+  public shims: string[] = []
-  public resources: { bundle: string; index: { [key: string]: number[] } } = {
+  /**
-    index: {},
+   * The last shim (defaults to "require('module').runMain()")
-    bundle: ''
+   */
-  }
+  public startup = ''
-  public readFileAsync: (file: string) => Promise<NexeFile>
+  /**
-  public writeFileAsync: (file: string, contents: Buffer | string) => Promise<void>
+   * The main entrypoint filename for your application - eg. node mainFile.js
-  public replaceInFileAsync: (file: string, replacer: any, replaceValue: string) => Promise<void>
+   */
-  public setFileContentsAsync: (file: string, contents: string | Buffer) => Promise<void>
+  public entrypoint: string | undefined
-
+  /**
-  private nodeSrcBinPath = isWindows
+   * Not used
-    ? join(this.src, 'Release', 'node.exe')
+   */
-    : join(this.src, 'out', 'Release', 'node')
+  public targets: NexeTarget[]
+  /**
+   * Current target of the compiler
+   */
+  public target: NexeTarget
+  /**
+   * Output filename (-o myapp.exe)
+   */
+  public output = this.options.output
+  /**
+   * Flag to indicate whether or notstdin was used for input
+   */
+  public stdinUsed = false
+  /**
+   * 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)
-    this.log.step('nexe ' + nexeVersion, 'info')
+    // SOMEDAY iterate over multiple targets with `--outDir`
-    if (python) {
+    this.targets = options.targets as NexeTarget[]
-      if (isWindows) {
+    this.target = this.targets[0]
-        this.env.PATH = '"' + dequote(normalize(python)) + '";' + this.env.PATH
+    if (!/https?:\/\//.test(options.remote)) {
-      } else {
+      throw new NexeError(`Invalid remote URI scheme (must be http or https): ${options.remote}`)
-        this.env.PYTHON = python
-      }
     }
+    this.remoteAsset = options.remote + this.target.toString()
+    this.src = join(this.options.temp, this.target.version)
+    this.nodeSrcBinPath = isWindows
+      ? join(this.src, 'Release', 'node.exe')
+      : join(this.src, 'out', 'Release', 'node')
+    this.log.step('nexe ' + version, 'info')
+    this.bundle = new Bundle(options)
 
-    this.readFileAsync = async (file: string) => {
+    this.env = { ...process.env }
-      let cachedFile = this.files.find(x => normalize(x.filename) === normalize(file))
+    if (python) {
-      if (!cachedFile) {
+      this.env.PYTHON = python
-        const absPath = join(this.src, file)
-        cachedFile = {
-          absPath,
-          filename: file,
-          contents: await readFileAsync(absPath, 'utf-8').catch(x => {
-            if (x.code === 'ENOENT') return ''
-            throw x
-          })
-        }
-        this.files.push(cachedFile)
-      }
-      return cachedFile
-    }
-    this.writeFileAsync = (file, contents) => writeFileAsync(join(this.src, file), contents)
-    this.replaceInFileAsync = async (file, replace: string | RegExp, value: string) => {
-      const entry = await this.readFileAsync(file)
-      entry.contents = entry.contents.replace(replace, value)
-    }
-    this.setFileContentsAsync = async (file: string, contents: string) => {
-      const entry = await this.readFileAsync(file)
-      entry.contents = contents
     }
   }
 
-  quit() {
+  @bound
+  async addResource(absoluteFileName: string, content?: Buffer | string | File) {
+    return await this.bundle.addResource(absoluteFileName, content)
+  }
+
+  @bound
+  async readFileAsync(file: string) {
+    this.assertBuild()
+    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 readFile(absPath, 'utf-8').catch((x) => {
+          if (x.code === 'ENOENT') return ''
+          throw x
+        }),
+      }
+      this.files.push(cachedFile)
+    }
+    return cachedFile
+  }
+
+  @bound
+  async writeFileAsync(file: string, contents: string | Buffer) {
+    this.assertBuild()
+    return await writeFile(join(this.src, file), contents)
+  }
+
+  @bound
+  async replaceInFileAsync(
+    file: string,
+    replace: string | RegExp,
+    value: string | StringReplacer
+  ): Promise<boolean> {
+    const entry = await this.readFileAsync(file)
+    let replaced = false
+    const replacer = (match: string) => {
+      replaced = true
+      if (typeof value === 'function') return value(match)
+      return value
+    }
+    entry.contents = entry.contents.toString().replace(replace, replacer)
+    return replaced
+  }
+
+  @bound
+  async setFileContentsAsync(file: string, contents: string | Buffer) {
+    const entry = await this.readFileAsync(file)
+    entry.contents = contents
+  }
+
+  async quit(error?: any) {
     const time = Date.now() - this.start
-    this.log.write(`Finsihed in ${time / 1000}s`)
+    this.log.write(`Finished in ${time / 1000}s`, error ? 'red' : 'green')
-    return this.log.flush()
+    return await this.log.flush()
+  }
+
+  assertBuild() {
+    if (!this.options.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())
     }
     return this.nodeSrcBinPath
   }
 
-  private _runBuildCommandAsync(command: string, args: string[]) {
+  private async _runBuildCommandAsync(command: string, args: string[]) {
-    return new Promise((resolve, reject) => {
+    if (this.log.verbose) {
+      this.compileStep?.pause()
+    }
+    return await new Promise<void>((resolve, reject) => {
       spawn(command, args, {
         cwd: this.src,
         env: this.env,
-        stdio: 'ignore'
+        stdio: this.log.verbose ? 'inherit' : 'ignore',
       })
-        .once('error', reject)
+        .once('error', (e: Error) => {
-        .once('close', resolve)
+          if (this.log.verbose) {
+            this.compileStep?.resume()
+          }
+          reject(e)
+        })
+        .once('close', (code: number) => {
+          if (this.log.verbose) {
+            this.compileStep?.resume()
+          }
+          if (code != 0) {
+            const error = `${command} ${args.join(' ')} exited with code: ${code}`
+            reject(new NexeError(error))
+          }
+          resolve()
+        })
     })
   }
 
-  private _configureAsync() {
+  private async _configureAsync() {
-    return this._runBuildCommandAsync(this.env.PYTHON || 'python', [
+    if (isWindows) {
-      configure,
+      return await Promise.resolve()
-      ...this.options.configure
+    }
+    return await this._runBuildCommandAsync(this.env.PYTHON || 'python3', [
+      './configure.py',
+      ...this.options.configure,
     ])
   }
 
-  private async _buildAsync() {
+  public async build(): Promise<ReadStream> {
-    this.compileStep.log(
+    this.compileStep?.log(
-      `Configuring node build${this.options.configure.length
+      `Configuring node build${
-        ? ': ' + this.options.configure
+        this.options.configure.length > 0 ? ': ' + this.options.configure : '...'
-        : '...'}`
+      }`
     )
     await this._configureAsync()
     const buildOptions = this.options.make
-    this.compileStep.log(
+    this.compileStep?.log(
-      `Compiling Node${buildOptions.length ? ' with arguments: ' + buildOptions : '...'}`
+      `Compiling Node${buildOptions.length > 0 ? ' with arguments: ' + buildOptions : '...'}`
     )
     await this._runBuildCommandAsync(make, buildOptions)
     return createReadStream(this.getNodeExecutableLocation())
   }
 
-  private async _fetchPrebuiltBinaryAsync(target: NexeTarget) {
-    const downloadOptions: any = {
-      headers: {
-        'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
-      }
-    }
-    const githubRelease = await getLatestGitRelease(downloadOptions)
-    const assetName = target.toString()
-    const asset = githubRelease.assets.find(x => x.name === assetName)
-
-    if (!asset) {
-      throw new Error(`${assetName} not available, create one using --build --empty`)
-    }
-    const filename = this.getNodeExecutableLocation(target)
-    await download(
-      asset.browser_download_url,
-      dirname(filename),
-      downloadOptions
-    ).on('response', (res: IncomingMessage) => {
-      const total = +res.headers['content-length']!
-      let current = 0
-      res.on('data', data => {
-        current += data.length
-        this.compileStep.modify(`Downloading...${(current / total * 100).toFixed()}%`)
-      })
-    })
-    return createReadStream(filename)
-  }
-
-  private _generateHeader() {
-    const version =
-      ['configure', 'vcBuild', 'make'].reduce((a, c) => {
-        return (a += (this.options as any)[c]
-          .slice()
-          .sort()
-          .join())
-      }, '') + this.options.enableNodeCli
-    const header = {
-      resources: this.resources.index,
-      version: createHash('md5')
-        .update(version)
-        .digest('hex')
-    }
-    const serializedHeader = this._serializeHeader(header)
-    return header
-  }
-
-  private _serializeHeader(header: NexeHeader) {
-    return `process.__nexe=${JSON.stringify(header)};`
-  }
-
   async compileAsync(target: NexeTarget) {
-    const step = (this.compileStep = this.log.step('Compiling result'))
+    const step = (this.compileStep = this.log.step('Compiling result')),
-    const build = this.options.build
+      build = this.options.build,
-    const location = this.getNodeExecutableLocation(target)
+      location = this.getNodeExecutableLocation(build ? undefined : target)
-    let binary = (await pathExistsAsync(location)) ? createReadStream(location) : null
+    let binary = (await pathExists(location)) ? createReadStream(location) : null
-    const header = this._generateHeader()
+
-    if (!build && !binary) {
-      step.modify('Fetching prebuilt binary')
-      binary = await this._fetchPrebuiltBinaryAsync(target)
-    }
     if (!binary) {
-      binary = await this._buildAsync()
+      binary = await this.build()
       step.log('Node binary compiled')
     }
-    return this._assembleDeliverable(header, binary)
+    return await this._assembleDeliverable(binary)
   }
 
-  private _assembleDeliverable(header: NexeHeader, binary: NodeJS.ReadableStream) {
+  code() {
-    if (this.options.empty) {
+    return [this.shims.join(''), this.startup].join(';')
+  }
+
+  private async _assembleDeliverable(binary: NodeJS.ReadableStream) {
+    if (!this.options.mangle) {
       return binary
     }
-    const artifact = new Readable({ read() {} })
+    const resources = this.bundle.renderIndex()
-    binary.on('data', (chunk: Buffer) => {
+    this.shims.unshift(wrap(`process.__nexe = ${JSON.stringify({ resources })};\n`))
-      artifact.push(chunk)
+
-    })
+    const code = this.code(),
-    binary.on('close', () => {
+      codeSize = Buffer.byteLength(code),
-      const content = this._serializeHeader(header) + this.input
+      lengths = Buffer.from(Array(16))
-      artifact.push(content)
+
-      artifact.push(this.resources.bundle)
+    lengths.writeDoubleLE(codeSize, 0)
-      const lengths = Buffer.from(Array(16))
+    lengths.writeDoubleLE(this.bundle.size, 8)
-      lengths.writeDoubleLE(Buffer.byteLength(content), 0)
+    return new (MultiStream as any)([
-      lengths.writeDoubleLE(Buffer.byteLength(this.resources.bundle), 8)
+      binary,
-      artifact.push(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths]))
+      toStream(code),
-      artifact.push(null)
+      this.bundle.toStream(),
-    })
+      toStream(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths])),
-    return artifact
+    ])
   }
 }

src/fs/README.md

@@ -0,0 +1,40 @@
+# nexe-fs
+
+### Getting Started:
+
+This module contains a set of patches used to create (and use) the Nexe Virtual FileSystem
+
+In order for NVFS to work with node's `require` method. A custom build of node must be used. If using the `nexe` cli this will be handled automatically
+
+The customization should be applied as early as possbile when node is starting up. 
+
+i.e. The contents of `nexe-fs/bootstrap` should be put [here](https://github.com/nodejs/node/blob/0827c80920311fa9d1e6989c8a73aaaeca962eb7/lib/internal/bootstrap/node.js#L27-L28).
+
+### Creating a NVFS:
+
+To create a virtual file system use the `Bundle` Object, in your build process:
+
+```javascript
+const { Bundle } = require('nexe-fs')
+
+const bundle = new Bundle()
+await bundle.addResource(absoluteFileName)
+
+bundle.toStream().pipe(fs.createWriteStream('./myFsBlob'))
+```
+
+In the entrypoint of your application, the fs patch needs to be applied (executed as early as possible)
+For example, In the build process, the application's entrypoint could be prepended with the following:
+
+```javascript
+const codeToPrependToEntrypoint = fs.readFileSync(require.resolve('nexe-fs/patch'), 'utf-8') + `
+shimFs({
+  blobPath: 'location/of/myFsBlob',
+  resources: ${JSON.stringify(bundle)},
+  layout: {
+    resourceStart: 0 // the offset within the blob that is referenced by the bundle index
+  }
+})`
+```
+
+Since a custom node build is being used. A great place for this code would be the node source file: `_third_party_main.js`

src/fs/bootstrap.js

@@ -0,0 +1,21 @@
+if (true) {
+  const patches = (process.nexe = { patches: {} }).patches
+
+  ;["ReadFile", "ReadJSON", "Stat"].forEach((x) => {
+    patch(process.binding("fs"), "internalModule" + x, noop)
+  })
+
+  function noop(original, ...args) {
+    return original.apply(this, args)
+  }
+
+  function patch(obj, method, patch) {
+    const original = obj[method];
+    if (!original) return
+    patches[method] = patch
+    obj[method] = function (...args) {
+      args.unshift(original)
+      return patches[method].apply(this, args)
+    }
+  }
+}

src/fs/bundle.ts

@@ -0,0 +1,154 @@
+import { lstat, realpath, stat } from 'node:fs/promises'
+import { createReadStream } from 'node:fs'
+import { relative } from 'node:path'
+import { Readable } from 'node:stream'
+
+import type { File } from 'resolve-dependencies'
+import MultiStream from 'multistream'
+
+export type MultiStreams = Array<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() {
+      this.push(content)
+      this.push(null)
+    },
+  })
+  return readable
+}
+
+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
+  }
+
+  get list() {
+    return Object.keys(this.files)
+  }
+
+  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.toString(),
+        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: Array<[string, File]> = [],
+      symLinks: Array<[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 new MultiStream(this.streams)
+  }
+}

src/fs/patch.ts

@@ -0,0 +1,437 @@
+/* eslint-disable prefer-rest-params */
+/* eslint-disable @typescript-eslint/no-var-requires */
+import type { Stats } from 'fs'
+import type { Func } from '../util'
+
+export interface NexeBinary {
+  blobPath: string
+  resources: { [key: string]: number[] }
+  layout: {
+    stat: Stats
+    resourceStart: number
+    contentSize?: number
+    contentStart?: number
+    resourceSize?: number
+  }
+}
+
+let originalFsMethods: any = null,
+  lazyRestoreFs = () => void 0
+
+// optional Win32 file namespace prefix followed by drive letter and colon
+const windowsFullPathRegex = /^(\\{2}\?\\)?([a-zA-Z]):/,
+  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)
+  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,
+    noop = () => void 0
+  const path = require('path')
+  const winPath: (key: string) => string = isWin ? upcaseDriveLetter : (s) => s,
+    baseDir = winPath(path.dirname(process.execPath))
+
+  let log = (_: string) => true,
+    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
+      }
+      return process.stderr.write('[nexe] - ' + text + '\n')
+    }
+  }
+
+  const getKey = function getKey(filepath: string | Buffer | null): string {
+      if (Buffer.isBuffer(filepath)) {
+        filepath = filepath.toString()
+      }
+      if (!isString(filepath)) {
+        return notAFile
+      }
+      const key = path.resolve(baseDir, filepath)
+
+      return winPath(key)
+    },
+    statTime = function () {
+      return {
+        atime: new Date(stat.atime),
+        mtime: new Date(stat.mtime),
+        ctime: new Date(stat.ctime),
+        birthtime: new Date(stat.birthtime),
+      }
+    }
+
+  let BigInt: any
+  try {
+    BigInt = eval('BigInt')
+  } catch (ignored) {
+    void ignored
+  }
+
+  const minBlocks = Math.max(Math.ceil(stat.blksize / 512), 1),
+    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
+      }
+      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
+    },
+    ownStat = function (filepath: any, options: any) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (directories[key]) {
+        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({ size: manifest[key][1] }, options)
+      }
+    },
+    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)
+        }
+      }
+    }
+
+  function makeLong(filepath: string) {
+    return path._makeLong && path._makeLong(filepath)
+  }
+
+  function fileOpts(options: any) {
+    return !options ? {} : isString(options) ? { encoding: options } : options
+  }
+
+  let setupManifest = () => {
+    Object.keys(manifest).forEach((filepath) => {
+      const entry = manifest[filepath],
+        absolutePath = getKey(filepath),
+        longPath = makeLong(absolutePath),
+        normalizedPath = winPath(path.normalize(filepath))
+
+      if (!manifest[absolutePath]) {
+        manifest[absolutePath] = entry
+      }
+      if (longPath && !manifest[longPath]) {
+        manifest[longPath] = entry
+      }
+      if (!manifest[normalizedPath]) {
+        manifest[normalizedPath] = manifest[filepath]
+      }
+
+      let currentDir = path.dirname(absolutePath),
+        prevDir = absolutePath
+
+      while (currentDir !== prevDir) {
+        directories[currentDir] = directories[currentDir] || {}
+        directories[currentDir][path.basename(prevDir)] = true
+        const longDir = makeLong(currentDir)
+        if (longDir && !directories[longDir]) {
+          directories[longDir] = directories[currentDir]
+        }
+        prevDir = currentDir
+        currentDir = path.dirname(currentDir)
+      }
+    })
+    ;(manifest[notAFile] as any) = false
+    ;(directories[notAFile] as any) = false
+    setupManifest = noop
+  }
+
+  // naive patches intended to work for most use cases
+  const nfs: any = {
+    existsSync: function existsSync(filepath: string) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (manifest[key] || directories[key]) {
+        return true
+      }
+      return originalFsMethods.existsSync.apply(fs, arguments)
+    },
+    realpath: function realpath(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.call(fs, filepath, options, cb)
+    },
+    realpathSync: function realpathSync(filepath: any, options: any) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (manifest[key]) {
+        return filepath
+      }
+      return originalFsMethods.realpathSync.call(fs, filepath, options)
+    },
+    readdir: function readdir(filepath: string | Buffer, options: any, callback: any) {
+      setupManifest()
+      const dir = directories[getKey(filepath)]
+      if (dir) {
+        if (typeof options === 'function') {
+          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) {
+      setupManifest()
+      const dir = directories[getKey(filepath)]
+      if (dir) {
+        return Object.keys(dir)
+      }
+      return originalFsMethods.readdirSync.apply(fs, arguments)
+    },
+
+    readFile: function readFile(filepath: any, options: any, callback: any) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.readFile.apply(fs, arguments)
+      }
+      const [offset, length] = entry,
+        resourceOffset = resourceStart + offset,
+        encoding = fileOpts(options).encoding
+      callback = typeof options === 'function' ? options : callback
+
+      originalFsMethods.open(blobPath, 'r', function (err: Error, fd: number) {
+        if (err) return callback(err, 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)
+            })
+          }
+        )
+      })
+    },
+    createReadStream: function createReadStream(filepath: any, options: any) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.createReadStream.apply(fs, arguments)
+      }
+      const [offset, length] = entry,
+        resourceOffset = resourceStart + offset,
+        opts = fileOpts(options)
+
+      return originalFsMethods.createReadStream(
+        blobPath,
+        Object.assign({}, opts, {
+          start: resourceOffset,
+          end: resourceOffset + length - 1,
+        })
+      )
+    },
+    readFileSync: function readFileSync(filepath: any, options: any) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.readFileSync.apply(fs, arguments)
+      }
+      const [offset, length] = entry,
+        resourceOffset = resourceStart + offset,
+        encoding = fileOpts(options).encoding,
+        fd = originalFsMethods.openSync(process.execPath, 'r'),
+        result = Buffer.alloc(length)
+      originalFsMethods.readSync(fd, result, 0, length, resourceOffset)
+      originalFsMethods.closeSync(fd)
+      return encoding ? result.toString(encoding) : result
+    },
+    statSync: function statSync(filepath: string | Buffer, options: any) {
+      const stat = ownStat(filepath, options)
+      if (stat) {
+        return stat
+      }
+      return originalFsMethods.statSync.apply(fs, arguments)
+    },
+    stat: getStat('stat'),
+    lstat: getStat('lstat'),
+    lstatSync: function statSync(filepath: string | Buffer, options: any) {
+      const stat = ownStat(filepath, options)
+      if (stat) {
+        return stat
+      }
+      return originalFsMethods.lstatSync.apply(fs, arguments)
+    },
+  }
+  if (typeof fs.exists === 'function') {
+    nfs.exists = function (filepath: string, cb: Func) {
+      cb = cb || noop
+      const exists = nfs.existsSync(filepath)
+      process.nextTick(() => cb(exists))
+    }
+  }
+
+  const patches = (process as any).nexe.patches || {}
+  delete (process as any).nexe
+  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')
+    }
+    log('read          (miss)       ' + filepath)
+    return original.call(this, ...args)
+  }
+  let returningArray: boolean
+  patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
+    if (!returningArray) 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 = getKey(args[0])
+    if (manifest[filepath]) {
+      log('stat     (hit)              ' + filepath + '   ' + 0)
+      return 0
+    }
+    if (directories[filepath]) {
+      log('stat dir (hit)              ' + filepath + '   ' + 1)
+      return 1
+    }
+    const res = original.call(this, ...args)
+    if (res === 0) {
+      log('stat          (miss)        ' + filepath + '   ' + res)
+    } else if (res === 1) {
+      log('stat dir      (miss)        ' + filepath + '   ' + res)
+    } else {
+      log('stat                 (fail) ' + filepath + '   ' + res)
+    }
+    return res
+  }
+
+  if (typeof fs.exists === 'function') {
+    nfs.exists = function (filepath: string, cb: Func) {
+      cb = cb || noop
+      const exists = nfs.existsSync(filepath)
+      if (!exists) {
+        return originalFsMethods.exists(filepath, cb)
+      }
+      process.nextTick(() => cb(exists))
+    }
+  }
+
+  if (typeof fs.copyFile === 'function') {
+    nfs.copyFile = function (filepath: string, dest: string, flags: number, callback: Func) {
+      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 = () => void 0
+    return void 0
+  }
+  return true
+}
+
+function restoreFs() {
+  lazyRestoreFs()
+}
+
+export { shimFs, restoreFs }

src/logger.ts

@@ -1,43 +1,45 @@
-import colors = require('chalk')
+import type { Func } from './util.js'
-import ora = require('ora')
+import { color, esm } from './util.js'
 
 const frameLength = 120
 
 export interface LogStep {
-  modify(text: string, color?: string): void
+  modify: (text: string, color?: string) => void
-  log(text: string, color?: string): void
+  log: (text: string, color?: string) => void
+  pause: () => void
+  resume: () => void
 }
 
 export class Logger {
-  private verbose: boolean
+  public verbose: boolean
-  private silent: boolean
+  private readonly silent: boolean
   private ora: any
-  private modify: Function
+  private readonly modify: Func
   public write: (text: string, color?: string) => void
 
   constructor(level: 'verbose' | 'silent' | 'info') {
     this.verbose = level === 'verbose'
     this.silent = level === 'silent'
     if (!this.silent) {
-      this.ora = ora({
+      this.ora = esm.ora?.default({
         text: 'Starting...',
         color: 'blue',
-        spinner: 'dots'
+        spinner: 'dots',
       })
       this.ora.stop()
     }
-    const noop = () => {}
+    const noop = () => void 0
     this.modify = this.silent ? noop : this._modify.bind(this)
     this.write = this.silent ? noop : this._write.bind(this)
   }
 
-  flush() {
+  async flush() {
     !this.silent && this.ora.succeed()
-    return new Promise(resolve => setTimeout(resolve, frameLength))
+    return await new Promise((resolve) => setTimeout(resolve, frameLength))
   }
 
-  _write(update: string, color = 'green') {
+  _write(update: string, clr = 'green') {
-    this.ora.succeed().text = (colors as any)[color](update)
+    this.ora.succeed().text = color(clr, update)
     this.ora.start()
   }
 
@@ -46,10 +48,12 @@ export class Logger {
     this.ora.color = color
   }
 
-  step(text: string, method: string = 'succeed'): LogStep {
+  step(text: string, method = 'succeed', clr?: string): LogStep {
     if (this.silent) {
-      return { modify() {}, log() {} }
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      return { modify() {}, log() {}, pause() {}, resume() {} }
     }
+    text = color(clr, text)
     if (!this.ora.id) {
       this.ora.start().text = text
       if (method !== 'succeed') {
@@ -62,7 +66,9 @@ export class Logger {
 
     return {
       modify: this.modify,
-      log: this.verbose ? this.write : this.modify
+      log: this.verbose ? this.write : this.modify,
+      pause: () => this.ora.stopAndPersist(),
+      resume: () => this.ora.start(),
     } as LogStep
   }
 }

src/nexe.ts

@@ -1,54 +1,55 @@
-import { compose, PromiseConfig, Middleware } from 'app-builder'
+import { NexeCompiler } from './compiler.js'
-import resource from './steps/resource'
+import type { NexeOptions, NexePatch } from './options.js'
-import { NexeCompiler } from './compiler'
+import { normalizeOptions } from './options.js'
-import {
+
-  argv,
+import resource from './steps/resource.js'
-  nexeVersion as version,
+import clean from './steps/clean.js'
-  normalizeOptionsAsync,
+import cli from './steps/cli.js'
-  NexeOptions,
+import bundle from './steps/bundle.js'
-  NexePatch
+import download from './steps/download.js'
-} from './options'
+import shim from './steps/shim.js'
-import cli from './steps/cli'
+import artifacts from './steps/artifacts.js'
-import bundle from './bundling/fuse'
+import patches from './patches/index.js'
-import download from './steps/download'
+import { initEsm } from './util.js'
-import artifacts from './steps/artifacts'
-import patches from './patches'
-import { rimrafAsync } from './util'
-import { NexeTarget } from './target'
 
 async function compile(
   compilerOptions?: Partial<NexeOptions>,
   callback?: (err: Error | null) => void
 ) {
-  const options = await normalizeOptionsAsync(compilerOptions)
+  await initEsm()
-  const compiler = new NexeCompiler(options)
+  let error: Error | null = null,
-  const build = compiler.options.build
+    options: NexeOptions | null = null,
+    compiler: NexeCompiler | null = null
 
-  if (options.clean) {
+  try {
-    let path = compiler.src
+    options = normalizeOptions(compilerOptions)
-    if (!options.build) {
+    compiler = new NexeCompiler(options)
-      path = compiler.getNodeExecutableLocation(compiler.options.targets[0] as NexeTarget)
+    const plugins = options.plugins as NexePatch[],
-    }
+      buildSteps = options.build ? [artifacts, ...patches, ...(options.patches as NexePatch[])] : []
-    const step = compiler.log.step('Cleaning up nexe build artifacts...')
+    await exec([clean, resource, cli, bundle, shim, download, ...buildSteps, ...plugins], compiler)
-    step.log(`Deleting contents at: ${path}`)
+  } catch (e: any) {
-    await rimrafAsync(path)
+    error = e
-    step.log(`Deleted contents at: ${path}`)
-    return compiler.quit()
   }
 
-  const buildSteps = build
+  if (error) {
-    ? [download, artifacts, ...patches, ...(options.patches as NexePatch[])]
+    compiler?.quit(error)
-    : []
+    if (callback) return callback(error)
-  const nexe = compose(resource, bundle, cli, buildSteps)
+    throw error
-  return callback
+  }
-    ? void nexe(compiler).then(
+
-        () => callback && callback(null),
+  if (callback) callback(null)
-        (e: Error) => {
-          if (callback) callback(e)
-          else throw e
-        }
-      )
-    : nexe(compiler)
 }
 
-export { argv, compile, version }
+export { compile, NexeCompiler }
+export { argv, version, help } from './options.js'
+export type { NexeOptions } from './options.js'
+
+function exec<T>(mw: any[], ctx: T): Promise<void> | void {
+  let i = -1
+  const nxt = (): void | Promise<void> => {
+    if (++i < mw.length) {
+      return mw[i](ctx, nxt)
+    }
+  }
+  return nxt()
+}

src/options.ts

@@ -1,45 +1,60 @@
-import * as parseArgv from 'minimist'
+import { basename, extname, join, isAbsolute, resolve, dirname } from 'node:path'
-import { NexeCompiler } from './compiler'
+import { fileURLToPath } from 'node:url'
-import { isWindows } from './util'
+import { EOL, homedir } from 'node:os'
-import { basename, extname, join, isAbsolute, relative } from 'path'
+import { globalAgent } from 'node:https'
-import { getTarget, NexeTarget } from './target'
+import { createRequire } from 'node:module'
-import { EOL } from 'os'
 
-export const nexeVersion = '2.0.0-rc.2'
+const dir = typeof __dirname === 'string' ? __dirname : dirname(fileURLToPath(import.meta.url)),
+  cjs = createRequire(dir)
 
-export interface NexePatch {
+import { resolveSync } from 'resolve-dependencies'
-  (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
+import parseArgv from 'minimist'
-}
+
+import caw from 'caw'
+
+import type { NexeCompiler } from './compiler.js'
+import { NexeError } from './compiler.js'
+import type { NexeTarget } from './target.js'
+import { getTarget } from './target.js'
+import { isWindows, STDIN_FLAG, esm } from './util.js'
+
+export const version = '{{replace:0}}'
+
+export type NexePatch = (compiler: NexeCompiler, next: () => Promise<void>) => Promise<void>
 
 export interface NexeOptions {
   build: boolean
   input: string
   output: string
-  targets: (string | NexeTarget)[]
+  targets: Array<string | NexeTarget>
   name: string
+  remote: string
+  asset: string
   cwd: string
-  version: string
+  fs: boolean | string[]
   flags: string[]
   configure: string[]
   vcBuild: string[]
   make: string[]
-  snapshot?: string
   resources: string[]
   temp: string
-  rc: { [key: string]: string }
   enableNodeCli: boolean
   bundle: boolean | string
-  patches: (string | NexePatch)[]
+  patches: Array<string | NexePatch>
-  empty: boolean
+  plugins: Array<string | NexePatch>
+  native: any
+  mangle: boolean
+  ghToken: string
   sourceUrl?: string
+  enableStdIn?: boolean
   python?: string
   loglevel: 'info' | 'silent' | 'verbose'
   silent?: boolean
+  fakeArgv?: boolean
   verbose?: boolean
   info?: boolean
-  ico?: string
+  debugBundle?: boolean
   warmup?: string
-  compress?: boolean
   clean?: boolean
   /**
    * Api Only
@@ -47,100 +62,87 @@ export interface NexeOptions {
   downloadOptions: any
 }
 
-function padRight(str: string, l: number) {
-  return (str + ' '.repeat(l)).substr(0, l)
-}
-
 const defaults = {
-  version: process.version.slice(1),
+    flags: [],
-  flags: [],
+    cwd: process.cwd(),
-  cwd: process.cwd(),
+    fs: true,
-  configure: [],
+    configure: [],
-  make: [],
+    mangle: true,
-  targets: [],
+    make: [],
-  vcBuild: isWindows ? ['nosign', 'release'] : [],
+    targets: [],
-  enableNodeCli: false,
+    vcBuild: isWindows ? ['nosign', 'release'] : [],
-  compress: false,
+    enableNodeCli: false,
-  build: false,
+    build: false,
-  bundle: true,
+    bundle: true,
-  patches: []
+    patches: [],
-}
+    plugins: [],
-const alias = {
+    remote: 'https://github.com/nexe/nexe/releases/download/v3.3.3/',
-  i: 'input',
+  },
-  o: 'output',
+  alias = {
-  t: 'target',
+    i: 'input',
-  n: 'name',
+    o: 'output',
-  v: 'version',
+    v: 'version',
-  r: 'resource',
+    a: 'asset',
-  a: 'resource',
+    t: 'target',
-  p: 'python',
+    b: 'build',
-  f: 'flag',
+    n: 'name',
-  c: 'configure',
+    r: 'resource',
-  m: 'make',
+    p: 'python',
-  s: 'snapshot',
+    f: 'flag',
-  h: 'help',
+    c: 'configure',
-  l: 'loglevel'
+    m: 'make',
-}
+    h: 'help',
-const argv = parseArgv(process.argv, { alias, default: defaults })
+    l: 'loglevel',
-const help =
+    'fake-argv': 'fakeArgv',
-  `
+    'gh-token': 'ghToken',
-nexe --help              CLI OPTIONS
+  },
+  argv = parseArgv(process.argv, { alias, default: { ...defaults } }),
+  help = () => {
+    const c = esm.chalk?.default as typeof import('chalk').default
+    return (
+      EOL +
+      `
+${c.bold('nexe <entry-file> [options]')}
 
-  -b   --build                              -- build from source
+   ${c.underline.bold('Options:')}
-  -i   --input      =index.js               -- application entry point
-  -o   --output     =my-app.exe             -- path to output file
-  -t   --target     =win32-x64-6.10.3       -- *target a prebuilt binary
-  -n   --name       =my-app                 -- main app module name
-  -v   --version    =${padRight(process.version.slice(1), 23)}-- node version
-  -p   --python     =/path/to/python2       -- python executable
-  -f   --flag       ="--expose-gc"          -- *v8 flags to include during compilation
-  -c   --configure  ="--with-dtrace"        -- *pass arguments to the configure step
-  -m   --make       ="--loglevel"           -- *pass arguments to the make/build step
-  -s   --snapshot   =/path/to/snapshot      -- build with warmup snapshot
-  -r   --resource   =./paths/**/*           -- *embed file bytes within the binary
-       --bundle     =./path/to/config       -- pass a module path that exports nexeBundle
-       --temp       =./path/to/temp         -- nexe temp files (for downloads and source builds)
-       --no-bundle                          -- set when input is already bundled
-       --cwd                                -- set the current working directory for the command
-       --ico                                -- file name for alternate icon file (windows)
-       --rc-*                               -- populate rc file options (windows)
-       --clean                              -- force download of sources
-       --enableNodeCli                      -- enable node cli enforcement (blocks app cli)
-       --sourceUrl                          -- pass an alternate source (node.tar.gz) url
-       --silent                             -- disable logging
-       --verbose                            -- set logging to verbose
 
-       -* variable key name                 * option can be used more than once`.trim() + EOL
+  -i   --input                      -- application entry point
+  -o   --output                     -- path to output file
+  -t   --target                     --  * node version description
+  -n   --name                       -- main app module name
+  -r   --resource                   --  * embed additional files (glob) within the binary
+       --remote                     -- alternate root directory for pre-built base (nexe) binaries from
+       --plugin                     -- extend nexe runtime behavior
 
-function flattenFilter(...args: any[]): string[] {
+   ${c.underline.bold('Building from source:')}
-  return ([] as string[]).concat(...args).filter(x => x)
-}
 
-/**
+  -b   --build                      -- build from source
- * Extract keys such as { "rc-CompanyName": "Node.js" } to
+  -p   --python                     -- python3 executable path
- * { CompanyName: "Node.js" }
+  -f   --flag                       --  * v8 flags to include during compilation
- * @param {*} match
+  -c   --configure                  --  * arguments to the configure step
- * @param {*} options
+  -m   --make                       --  * arguments to the make/build step
- */
+       --patch                      --  * extend patches applied to source
-function extractCliMap(match: RegExp, options: any) {
+       --no-mangle                  -- used when generating base binaries, or when patching _third_party_main manually
-  return Object.keys(options)
+       --sourceUrl                  -- pass an alternate source tarball (node.tar.gz) url
-    .filter(x => match.test(x))
+       --enableNodeCli              -- enable node cli enforcement (blocks app cli)
-    .reduce((map: { [key: string]: string }, option: keyof NexeOptions) => {
-      const key = option.split('-')[1]
-      map[key] = options[option]
-      delete options[option]
-      return map
-    }, {})
-}
 
-function tryResolveMainFileName(cwd: string) {
+   ${c.underline.bold('Other options:')}
-  let filename
-  try {
-    const file = require.resolve(cwd)
-    filename = basename(file).replace(extname(file), '')
-  } catch (_) {}
 
-  return !filename || filename === 'index' ? 'nexe_' + Date.now() : filename
+       --bundle                     -- custom bundling module with 'createBundle' export
+       --temp                       -- temp file storage default '~/.nexe'
+       --cwd                        -- set the current working directory for the command
+       --fake-argv                  -- fake argv[1] with entry file
+       --clean                      -- force download of sources
+       --silent                     -- disable logging
+       --verbose                    -- set logging to verbose
+
+  "*" indicates an option can be used more than once`.trim() +
+      EOL
+    )
+  }
+
+function flatten(...args: any[]): string[] {
+  return ([] as string[]).concat(...args).filter((x) => x)
 }
 
 function extractLogLevel(options: NexeOptions) {
@@ -150,86 +152,142 @@ function extractLogLevel(options: NexeOptions) {
   return 'info'
 }
 
+function isName(name: string) {
+  return name && name !== 'index' && name !== STDIN_FLAG
+}
+
 function extractName(options: NexeOptions) {
   let name = options.name
-  if (!name && typeof options.input === 'string') {
+  // try and use the input filename as the output filename if its not index
+  if (!isName(name) && typeof options.input === 'string') {
     name = basename(options.input).replace(extname(options.input), '')
   }
-  name = name || tryResolveMainFileName(options.cwd)
+  // try and use the directory as the filename
+  if (!isName(name) && basename(options.cwd)) {
+    name = basename(options.cwd)
+  }
+
   return name.replace(/\.exe$/, '')
 }
 
-function isEntryFile(filename: string) {
+function padRelative(input: string) {
-  return filename && !isAbsolute(filename) && filename !== 'node' && /\.(tsx?|jsx?)$/.test(filename)
+  let prefix = ''
+  if (!input.startsWith('.')) {
+    prefix = './'
+  }
+  return prefix + input
 }
 
-function findInput(input: string, cwd: string) {
+function isEntryFile(filename?: string): filename is string {
-  const maybeInput = argv._.slice().pop() || ''
+  return Boolean(filename && !isAbsolute(filename))
-  if (input) {
+}
+
+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 (isEntryFile(maybeInput)) {
+  if (input) {
-    return maybeInput
+    const inputPath = padRelative(input)
+    result = resolveSync(cwd, inputPath)
   }
-  if (!process.stdin.isTTY) {
+  if (isEntryFile(maybeEntry) && (!result || !result.absPath)) {
-    return ''
+    const inputPath = padRelative(maybeEntry)
+    result = resolveSync(cwd, inputPath)
   }
-  try {
+  if (!process.stdin.isTTY && !result?.absPath && bundle === defaults.bundle) {
-    const main = require.resolve(cwd)
+    return STDIN_FLAG
-    return './' + relative(cwd, main)
-  } catch (e) {
-    void e
   }
-  return ''
+  if (!result?.absPath) {
+    result = resolveSync(cwd, '.')
+  }
+  if (!result.absPath) {
+    throw new NexeError(`Entry file "${input || maybeEntry}" not found!`)
+  }
+  return result.absPath
 }
 
-function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOptions | never> {
+function isCli(options?: Partial<NexeOptions>) {
-  if (argv.help || argv._.some((x: string) => x === 'version') || argv.version === true) {
+  return argv === options
-    return new Promise(() => {
+}
-      process.stderr.write(argv.help ? help : nexeVersion + EOL, () => process.exit(0))
-    })
-  }
-  const options = Object.assign({}, defaults, input) as NexeOptions
-  const opts = options as any
 
-  options.temp = process.env.NEXE_TEMP || join(options.cwd, '.nexe')
+function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
+  const options = Object.assign({}, defaults, input) as NexeOptions,
+    opts = options as any,
+    cwd = (options.cwd = resolve(options.cwd))
+  options.temp = options.temp
+    ? 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.bundle)
+  options.enableStdIn = isCli(input) && options.input === STDIN_FLAG
   options.name = extractName(options)
-  options.input = findInput(options.input, options.cwd)
   options.loglevel = extractLogLevel(options)
-  options.flags = flattenFilter(opts.flag, options.flags)
+  options.flags = flatten(opts.flag, options.flags)
-  options.targets = flattenFilter(opts.target, options.targets)
+  options.targets = flatten(opts.target, options.targets).map(getTarget)
-  options.make = flattenFilter(options.vcBuild, options.make)
+  if (options.targets.length === 0) {
-  options.configure = flattenFilter(options.configure)
+    options.targets.push(getTarget())
-  options.resources = flattenFilter(opts.resource, options.resources)
+  }
-  options.rc = options.rc || extractCliMap(/^rc-.*/, options)
+  options.ghToken = options.ghToken || process.env.GITHUB_TOKEN || ''
+  options.make = flatten(isWindows ? options.vcBuild : options.make)
+  options.configure = flatten(options.configure)
+  options.resources = flatten(opts.resource, options.resources)
 
-  options.targets = options.targets.map(getTarget)
+  if (!options.remote.endsWith('/')) {
+    options.remote += '/'
+  }
 
-  if (options.build && options.targets.length) {
+  options.downloadOptions = options.downloadOptions || {}
+  options.downloadOptions.headers = options.downloadOptions.headers || {}
+  options.downloadOptions.headers['User-Agent'] = 'nexe (https://www.npmjs.com/package/nexe)'
+  options.downloadOptions.agent = process.env.HTTPS_PROXY
+    ? caw(process.env.HTTPS_PROXY, { protocol: 'https' })
+    : options.downloadOptions.agent || globalAgent
+  options.downloadOptions.rejectUnauthorized = !process.env.NODE_TLS_REJECT_UNAUTHORIZED
+
+  options.output =
+    (options.targets[0] as NexeTarget).platform === 'windows'
+      ? `${(options.output || options.name).replace(/\.exe$/, '')}.exe`
+      : `${options.output || options.name}`
+  options.output = resolve(cwd, options.output)
+
+  const requireDefault = (x: string) => {
+    if (typeof x === 'string') {
+      return cjs(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 > 0) {
+    options.build = true
+  }
+
+  if (options.build) {
     const { arch } = options.targets[0] as NexeTarget
     if (isWindows) {
-      options.make = Array.from(new Set(options.make.concat([arch])))
+      options.make = Array.from(new Set(options.make.concat(arch)))
     } else {
       options.configure = Array.from(new Set(options.configure.concat([`--dest-cpu=${arch}`])))
     }
   }
 
-  if (!options.targets.length) {
-    options.targets = [getTarget(options.version)]
-  }
-
-  options.patches = options.patches.map(x => {
-    if (typeof x === 'string') {
-      return require(x).default
-    }
-    return x
-  })
-
   Object.keys(alias)
-    .filter(k => k !== 'rc')
+    .filter((k) => k !== 'rc')
-    .forEach(x => delete opts[x])
+    .forEach((x) => delete opts[x])
 
-  return Promise.resolve(options)
+  return options
 }
 
-export { argv, normalizeOptionsAsync }
+export { argv, normalizeOptions, help }

src/patches/boot-nexe.ts

@@ -0,0 +1,59 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const fs = require('fs')
+const fd = fs.openSync(process.execPath, 'r'),
+  stat = fs.statSync(process.execPath),
+  tailSize = Math.min(stat.size, 16000),
+  tailWindow = Buffer.from(Array(tailSize))
+
+fs.readSync(fd, tailWindow, 0, tailSize, stat.size - tailSize)
+
+const footerPosition = tailWindow.indexOf('<nexe~~sentinel>')
+if (footerPosition == -1) {
+  process.stderr.write('\nInvalid Nexe binary\n')
+  process.exit(1)
+}
+
+const footer = tailWindow.slice(footerPosition, footerPosition + 32),
+  contentSize = footer.readDoubleLE(16),
+  resourceSize = footer.readDoubleLE(24),
+  contentStart = stat.size - tailSize + footerPosition - resourceSize - contentSize,
+  resourceStart = contentStart + contentSize
+
+Object.defineProperty(
+  process,
+  '__nexe',
+  (function () {
+    let nexeHeader: any = null
+    return {
+      get: function () {
+        return nexeHeader
+      },
+      set: function (value: any) {
+        if (nexeHeader) {
+          throw new Error('This property is readonly')
+        }
+        nexeHeader = Object.assign({}, value, {
+          blobPath: process.execPath,
+          layout: {
+            stat,
+            contentSize,
+            contentStart,
+            resourceSize,
+            resourceStart,
+          },
+        })
+        Object.freeze(nexeHeader)
+      },
+      enumerable: false,
+      configurable: false,
+    }
+  })()
+)
+
+const contentBuffer = Buffer.from(Array(contentSize))
+const Module = require('module')
+
+fs.readSync(fd, contentBuffer, 0, contentSize, contentStart)
+fs.closeSync(fd)
+
+new Module(process.execPath, null)._compile(contentBuffer.toString(), process.execPath)

src/patches/build-fixes.ts

@@ -1,17 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function buildFixes(compiler: NexeCompiler, next: () => Promise<void>) {
-  if (!compiler.options.version.startsWith('8.2')) {
-    return next()
-  }
-
-  const file = await compiler.readFileAsync('./tools/msvs/find_python.cmd')
-
-  await compiler.replaceInFileAsync(
-    './tools/msvs/find_python.cmd',
-    '%p%python.exe -V 2>&1',
-    '"%p%python.exe" -V 2>&1'
-  )
-
-  return next()
-}

src/patches/disable-node-cli.ts

@@ -1,12 +1,20 @@
-import { NexeCompiler } from '../compiler'
+import type { NexeCompiler } from '../compiler.js'
+import { NexeError } from '../compiler.js'
+import { semverGt } from '../util.js'
 
 export default async function disableNodeCli(compiler: NexeCompiler, next: () => Promise<void>) {
   if (compiler.options.enableNodeCli) {
-    return next()
+    return await next()
   }
 
-  const nodeccMarker = "argv[index][0] == '-'"
+  const [regex, replacement] = semverGt(compiler.target.version, '18.99')
+      ? [/(?<!int )ProcessGlobalArgsInternal\(argv[^;]*;/gm, 'ExitCode::kNoFailure']
+      : [/(?<!int )ProcessGlobalArgs\(argv[^;]*;/gm, 0],
+    replaced = await compiler.replaceInFileAsync('src/node.cc', regex, `${replacement};/*$&*/`)
 
-  await compiler.replaceInFileAsync('src/node.cc', nodeccMarker, nodeccMarker.replace('-', ']'))
+  if (!replaced) {
-  return next()
+    throw new NexeError('There was an error applying the Node CLI patch. Please open an issue.')
+  }
+
+  return await next()
 }

src/patches/flags.ts

@@ -1,16 +1,21 @@
-import { NexeCompiler } from '../compiler'
+import type { NexeCompiler } from '../compiler.js'
+import { NexeError } from '../compiler.js'
 
 export default async function flags(compiler: NexeCompiler, next: () => Promise<void>) {
   const nodeflags = compiler.options.flags
-  if (!nodeflags.length) {
+  if (nodeflags.length === 0) {
-    return next()
+    return await next()
   }
 
-  await compiler.replaceInFileAsync(
+  const replaced = await compiler.replaceInFileAsync(
     'node.gyp',
     "'node_v8_options%': ''",
     `'node_v8_options%': '${nodeflags.join(' ')}'`
   )
 
-  return next()
+  if (!replaced) {
+    throw new NexeError('Node Flags not applied. Please report an issue')
+  }
+
+  return await next()
 }

src/patches/gyp.ts

@@ -1,21 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function nodeGyp(
-  { files, replaceInFileAsync }: NexeCompiler,
-  next: () => Promise<void>
-) {
-  await next()
-
-  const nodeGypMarker = "'lib/fs.js',"
-  await replaceInFileAsync(
-    'node.gyp',
-    nodeGypMarker,
-    `
-    ${nodeGypMarker}
-    ${files
-      .filter(x => x.filename.startsWith('lib'))
-      .map(x => `'${x.filename}'`)
-      .toString()},
-  `.trim()
-  )
-}

src/patches/ico.ts

@@ -1,12 +0,0 @@
-import { normalize } from 'path'
-import { readFileAsync } from '../util'
-import { NexeCompiler } from '../compiler'
-
-export default async function ico(compiler: NexeCompiler, next: () => Promise<void>) {
-  const iconFile = compiler.options.ico
-  if (!iconFile) {
-    return next()
-  }
-  await compiler.setFileContentsAsync('src/res/node.ico', await readFileAsync(normalize(iconFile)))
-  return next()
-}

src/patches/index.ts

@@ -1,12 +1,7 @@
-import gyp from './gyp'
+import bootNexe from './third-party-main.js'
-import nexePatches from './third-party-main'
+import cli from './disable-node-cli.js'
-import buildFixes from './build-fixes'
+import flags from './flags.js'
-import cli from './disable-node-cli'
-import flags from './flags'
-import ico from './ico'
-import rc from './node-rc'
-import { NexeCompiler } from '../compiler'
 
-const patches = [gyp, nexePatches, buildFixes, cli, flags, ico, rc]
+const patches = [bootNexe, cli, flags]
 
 export default patches

src/patches/node-rc.ts

@@ -1,19 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function nodeRc(compiler: NexeCompiler, next: () => Promise<void>) {
-  const options = compiler.options.rc
-  if (!options) {
-    return next()
-  }
-
-  const file = await compiler.readFileAsync('src/res/node.rc')
-
-  Object.keys(options).forEach(key => {
-    let value = options[key]
-    const isVar = /^[A-Z_]+$/.test(value)
-    value = isVar ? value : `"${value}"`
-    file.contents.replace(new RegExp(`VALUE "${key}",*`), `VALUE "${key}", ${value}`)
-  })
-
-  return next()
-}

src/patches/snapshot.ts

@@ -1,19 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function snapshot(compiler: NexeCompiler, next: () => Promise<void>) {
-  const snapshotFile = compiler.options.snapshot
-  const warmupScript = compiler.options.warmup
-
-  if (!snapshotFile) {
-    return next()
-  }
-
-  await compiler.replaceInFileAsync(
-    'configure',
-    'def configure_v8(o):',
-    `def configure_v8(o):\n  o['variables']['embed_script'] = '${snapshotFile}'\n  o['variables']['warmup_script'] = '${warmupScript ||
-      snapshotFile}'`
-  )
-
-  return next()
-}

src/patches/third-party-main.ts

@@ -1,126 +1,88 @@
-import { NexeCompiler } from '../compiler'
+import { parse } from 'meriyah'
-import { readFileSync } from 'fs'
+import type { NexeCompiler } from '../compiler.js'
-import { join } from 'path'
+import { NexeError } from '../compiler.js'
+import { wrap, semverGt } from '../util.js'
 
 export default async function main(compiler: NexeCompiler, next: () => Promise<void>) {
-  await compiler.setFileContentsAsync(
+  let bootFile = 'lib/internal/bootstrap/pre_execution.js'
-    'lib/_third_party_main.js',
+  if (semverGt(compiler.target.version, '18.11.99')) {
-    `
+    bootFile = 'lib/internal/process/pre_execution.js'
-const fs = require('fs')
-const path = require('path')
-const Buffer = require('buffer').Buffer
-const isString = x => typeof x === 'string' || x instanceof String
-
-const fd = fs.openSync(process.execPath, 'r')
-const size = fs.statSync(process.execPath).size
-const footer = Buffer.from(Array(32))
-fs.readSync(fd, footer, 0, 32, size - 32)
-
-if (!footer.slice(0, 16).equals(Buffer.from('<nexe~~sentinel>'))) {
-  throw 'Invalid Nexe binary'
-}
-
-const contentSize = footer.readDoubleLE(16)
-const resourceSize = footer.readDoubleLE(24)
-const contentStart = size - 32 - resourceSize - contentSize
-const resourceStart = contentStart + contentSize
-
-Object.defineProperty(process, '__nexe', (function () {
-  let nexeHeader = null
-  return {
-    get: function () {
-      return nexeHeader
-    },
-    set: function (value) {
-      if (nexeHeader) {
-        throw new Error('__nexe cannot be reconfigured')
-      }
-      nexeHeader = value
-      Object.freeze(nexeHeader)
-    },
-    enumerable: false,
-    configurable: false
   }
-})());
+  const file = await compiler.readFileAsync(bootFile),
+    ast = parse(file.contents.toString(), {
+      next: true,
+      globalReturn: true,
+      loc: true,
+      specDeviation: true,
+    }),
+    location = { start: { line: 0 } }
 
-if (resourceSize) {
+  walkSome(ast, (node: any) => {
-  const originalReadFile = fs.readFile
+    if (!location.start.line && node.type === 'BlockStatement') {
-  const originalReadFileSync = fs.readFileSync
+      // Find the first block statement and mark the location
-  let setupManifest = () => {
+      Object.assign(location, node.loc)
-    const manifest = process.__nexe && process.__nexe.resources
+      return true
-    if (!manifest) {
-      return
     }
-    Object.keys(manifest).forEach((key) => {
+  })
-      const absolutePath = path.resolve(key)
-      if (!manifest[absolutePath]) {
-        manifest[absolutePath] = manifest[key]
-      }
-      const normalizedPath = path.normalize(key)
-      if (!manifest[normalizedPath]) {
-        manifest[normalizedPath] = manifest[key]
-      }
-    })
-    normalizeManifest = () => {}
-  };
-  fs.readFile = function readFile (file, options, callback) {
-    setupManifest()
-    const manifest = process.__nexe
-    const entry = manifest && manifest.resources[file]
-    if (!manifest || !entry || !isString(file)) {
-      return originalReadFile.apply(fs, arguments)
-    }
-    const [offset, length] = entry
-    const resourceOffset = resourceStart + offset
-    const encoding = isString(options) ? options : null
-    callback = typeof options === 'function' ? options : callback
 
-    fs.open(process.execPath, 'r', function (err, fd) {
+  const fileLines = file.contents.toString().split('\n')
-      if (err) return callback(err, null)
-      fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function (error, bytesRead, buffer) {
-        if (error) {
-          return fs.close(fd, function () {
-            callback(error, null)
-          })
-        }
-        fs.close(fd, function (err) {
-          if (err) {
-            return callback(err, buffer)
-          }
-          const result = Buffer.from(buffer.toString(), 'base64')
-          callback(err, encoding ? result.toString(encoding) : result)
-        })
-      })
-    })
-  }
 
-  fs.readFileSync = function readFileSync (file, options) {
+  fileLines.splice(
-    setupManifest()
+    location.start.line,
-    const manifest = process.__nexe
+    0,
-    const entry = manifest && manifest.resources[file]
+    '{{replace:lib/MOD/fs/bootstrap.js}}' + '\n' + 'expandArgv1 = false;\n'
-    if (!manifest || !entry || !isString(file)) {
-      return originalReadFileSync.apply(fs, arguments)
-    }
-    const [offset, length] = entry
-    const resourceOffset = resourceStart + offset
-    const encoding = isString(options) ? options : null
-    const fd = fs.openSync(process.execPath, 'r')
-    const result = Buffer.alloc(length)
-    fs.readSync(fd, result, 0, length, resourceOffset)
-    fs.closeSync(fd)
-    const contents = Buffer.from(result.toString(), 'base64')
-    return encoding ? contents.toString(encoding) : contents
-  }
-}
-
-const contentBuffer = Buffer.from(Array(contentSize));
-fs.readSync(fd, contentBuffer, 0, contentSize, contentStart);
-fs.closeSync(fd);
-const Module = require('module');
-process.mainModule = new Module(process.execPath, null);
-process.mainModule.loaded = true;
-process.mainModule._compile(contentBuffer.toString(), process.execPath);
-`.trim()
   )
-  return next()
+  file.contents = fileLines.join('\n')
+
+  const boot = await compiler.replaceInFileAsync(
+      bootFile,
+      'initializeFrozenIntrinsics();',
+      'initializeFrozenIntrinsics();\n' + wrap('{{replace:lib/MOD/patches/boot-nexe.js}}')
+    ),
+    userModuleAssertion = await compiler.replaceInFileAsync(
+      bootFile,
+      'assert(!CJSLoader.hasLoadedAnyUserCJSModule)',
+      '/*assert(!CJSLoader.hasLoadedAnyUserCJSModule)*/'
+    ),
+    workerSupport = 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'
+    )
+
+  assertPatches({ boot, userModuleAssertion, workerSupport })
+
+  return await next()
+}
+
+function assertPatches(patches: Record<string, boolean>) {
+  if (!Object.values(patches).every((x) => x)) {
+    let message = ''
+    Object.entries(patches).forEach(([k, v]) => {
+      if (!v) message += `\nFailed to apply patch for: "${k}". Please open an issue.`
+    })
+    throw new NexeError(message.trim())
+  }
+}
+
+function walkSome(node: any, visit: (node: any) => boolean | undefined) {
+  if (!node || typeof node.type !== 'string' || node._visited) {
+    return false
+  }
+  visit(node)
+  node._visited = true
+  for (const childNode in node) {
+    const child = node[childNode]
+    if (Array.isArray(child)) {
+      for (let i = 0; i < child.length; i++) {
+        if (walkSome(child[i], visit)) {
+          return true
+        }
+      }
+    } else if (walkSome(child, visit)) {
+      return true
+    }
+  }
+  return false
 }

src/releases.ts

@@ -1,16 +1,7 @@
-import got = require('got')
+import { platforms, architectures, NexeTarget, getTarget, targetsEqual } from './target.js'
-import download = require('download')
-import {
-  NodePlatform,
-  NodeArch,
-  platforms,
-  architectures,
-  NexeTarget,
-  getTarget,
-  targetsEqual
-} from './target'
 export { NexeTarget }
 
+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
@@ -29,26 +20,30 @@ interface NodeRelease {
 }
 
 async function getJson<T>(url: string, options?: any) {
+  const { default: got } = await import('got')
   return JSON.parse((await got(url, options)).body) as T
 }
 
-//TODO only build the latest of each major...?
 function isBuildableVersion(version: string) {
-  const major = +version.split('.')[0]
+  if (version === '12.11.0') {
-  return !~[0, 1, 2, 3, 4, 5, 7].indexOf(major) || version === '4.8.4'
+    return false
+  }
+  return !versionsToSkip.includes(Number(version.split('.')[0]))
 }
 
-export function getLatestGitRelease(options?: any) {
+export async function getLatestGitRelease(options?: any) {
-  return getJson<GitRelease>('https://api.github.com/repos/nexe/nexe/releases/latest', options)
+  return await getJson<GitRelease>(
+    'https://api.github.com/repos/nexe/nexe/releases/latest',
+    options
+  )
 }
 
 export async function getUnBuiltReleases(options?: any) {
   const nodeReleases = await getJson<NodeRelease[]>(
-    'https://nodejs.org/download/release/index.json'
+      'https://nodejs.org/download/release/index.json'
-  )
+    ),
-  const existingVersions = (await getLatestGitRelease(options)).assets.map(x => getTarget(x.name))
+    existingVersions = (await getLatestGitRelease(options)).assets.map((x) => getTarget(x.name)),
-
+    versionMap: { [key: string]: true } = {}
-  const versionMap: { [key: string]: true } = {}
   return nodeReleases
     .reduce((versions: NexeTarget[], { version }) => {
       version = version.replace('v', '').trim()
@@ -56,13 +51,14 @@ export async function getUnBuiltReleases(options?: any) {
         return versions
       }
       versionMap[version] = true
-      platforms.forEach(platform => {
+      platforms.forEach((platform) => {
-        architectures.forEach(arch => {
+        architectures.forEach((arch) => {
           if (arch === 'x86' && platform === 'mac') return
+          if (arch.includes('arm')) return
           versions.push(getTarget({ platform, arch, version }))
         })
       })
       return versions
     }, [])
-    .filter(x => !existingVersions.some(t => targetsEqual(t, x)))
+    .filter((x) => !existingVersions.some((t) => targetsEqual(t, x)))
 }

src/steps/artifacts.ts

@@ -1,29 +1,22 @@
-import { join, dirname } from 'path'
+import { join, dirname } from 'node:path'
-import { readdir, unlink } from 'fs'
+import { unlink, readdir, mkdir } from 'node:fs/promises'
-import { readFileAsync, writeFileAsync, isDirectoryAsync } from '../util'
-import * as mkdirp from 'mkdirp'
-import { NexeCompiler } from '../compiler'
-import pify = require('pify')
 
-const mkdirpAsync = pify(mkdirp)
+import { readFile, writeFile, isDirectory } from '../util.js'
-const unlinkAsync = pify(unlink)
+import type { NexeCompiler } from '../compiler.js'
-const readdirAsync = pify(readdir)
 
-function readDirAsync(dir: string): Promise<string[]> {
+async function readDirAsync(dir: string): Promise<string[]> {
-  return readdirAsync(dir).then(paths => {
+  return await readdir(dir).then(async (paths) => {
-    return Promise.all(
+    return await Promise.all(
-      paths.map((file: string) => {
+      paths.map(async (file: string) => {
         const path = join(dir, file)
-        return isDirectoryAsync(path).then(x => (x ? readDirAsync(path) : path as any))
+        return await isDirectory(path).then((x) => (x ? readDirAsync(path) : (path as any)))
       })
-    ).then(result => {
+    ).then((result) => result.flat())
-      return [].concat(...(result as any))
-    })
   })
 }
 
-function maybeReadFileContentsAsync(file: string) {
+async function maybeReadFileContentsAsync(file: string) {
-  return readFileAsync(file, 'utf-8').catch(e => {
+  return await readFile(file, 'utf-8').catch((e) => {
     if (e.code === 'ENOENT') {
       return ''
     }
@@ -39,31 +32,30 @@ function maybeReadFileContentsAsync(file: string) {
  *  - After the patch functions have run, the temporary directory is emptied
  *  - Original versions of sources to be patched are written to the temporary directory
  *  - Finally, The patched files are written into source.
- *
  */
 export default async function artifacts(compiler: NexeCompiler, next: () => Promise<void>) {
-  const { src } = compiler
+  const { src } = compiler,
-  const temp = join(src, 'nexe')
+    temp = join(src, 'nexe')
-  await mkdirpAsync(temp)
+  await mkdir(temp, { recursive: true })
   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'))
+      return await compiler.writeFileAsync(path.replace(temp, ''), await readFile(path, 'utf-8'))
     })
   )
 
   await next()
 
-  await Promise.all(tmpFiles.map(x => unlinkAsync(x)))
+  await Promise.all(tmpFiles.map(async (x) => await unlink(x)))
-  return Promise.all(
+  return await Promise.all(
-    compiler.files.map(async file => {
+    compiler.files.map(async (file) => {
-      const sourceFile = join(src, file.filename)
+      const sourceFile = join(src, file.filename),
-      const tempFile = join(temp, file.filename)
+        tempFile = join(temp, file.filename),
-      const fileContents = await maybeReadFileContentsAsync(sourceFile)
+        fileContents = await maybeReadFileContentsAsync(sourceFile)
 
-      await mkdirpAsync(dirname(tempFile))
+      await mkdir(dirname(tempFile), { recursive: true })
-      await writeFileAsync(tempFile, fileContents)
+      await writeFile(tempFile, fileContents)
       await compiler.writeFileAsync(file.filename, file.contents)
     })
   )

src/steps/bundle.ts

@@ -0,0 +1,84 @@
+import { resolve, relative } from 'node:path'
+import type { Readable } from 'node:stream'
+import resolveFiles, { resolveSync } from 'resolve-dependencies'
+
+import type { NexeCompiler } from '../compiler.js'
+import { NexeError } from '../compiler.js'
+import { dequote, STDIN_FLAG } from '../util.js'
+
+async function getStdIn(stdin: Readable): Promise<string> {
+  let out = ''
+  return await 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: doBundle, cwd, input: inputPath } = compiler.options
+  let input = inputPath
+  compiler.entrypoint = './' + relative(cwd, input)
+  compiler.startup = ''
+
+  if (!doBundle) {
+    await compiler.addResource(resolve(cwd, input))
+    return next()
+  }
+
+  let code = ''
+  if (typeof doBundle === 'string') {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    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()
+  }
+
+  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 > 0
+  ) {
+    throw new NexeError('Parsing Error:\n' + warnings.join('\n'))
+  }
+
+  warnings.forEach((x: string) => compiler.log.step('[WARNING]: ' + x, 'stopAndPersist', 'yellow'))
+
+  await Promise.all(
+    Object.entries(files).map(async ([key, file]) => {
+      return await compiler.addResource(key, file)
+    })
+  )
+
+  return next()
+}

src/steps/clean.ts

@@ -0,0 +1,20 @@
+import { rm } from 'node:fs/promises'
+
+import type { NexeCompiler } from '../compiler.js'
+import type { NexeTarget } from '../target.js'
+
+export default async function clean(compiler: NexeCompiler, next: () => Promise<any>) {
+  const { options } = compiler
+  if (options.clean) {
+    let path = compiler.src
+    if (!options.build) {
+      path = compiler.getNodeExecutableLocation(compiler.options.targets[0] as NexeTarget)
+    }
+    const step = compiler.log.step('Cleaning up nexe build artifacts...')
+    step.log(`Deleting contents at: ${path}`)
+    await rm(path, { recursive: true, force: true })
+    step.log(`Deleted contents at: ${path}`)
+    return await compiler.quit()
+  }
+  return await next()
+}

src/steps/cli.ts

@@ -1,21 +1,8 @@
-import { normalize } from 'path'
+import { dirname, normalize, relative, resolve } from 'node:path'
-import { Readable } from 'stream'
+import { createWriteStream, chmodSync, statSync, mkdirSync } from 'node:fs'
-import { createWriteStream, chmodSync } from 'fs'
+import type { NexeCompiler } from '../compiler.js'
-import { readFileAsync, dequote, isWindows } from '../util'
+import type { NexeTarget } from '../target.js'
-import { NexeCompiler } from '../compiler'
+import { STDIN_FLAG } from '../util.js'
-import { NexeTarget } from '../target'
-
-function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
-  return new Promise(resolve => {
-    let input = ''
-    stream.setEncoding('utf-8')
-    stream.on('data', (x: string) => {
-      input += x
-    })
-    stream.once('end', () => resolve(dequote(input)))
-    stream.resume && stream.resume()
-  })
-}
 
 /**
  * The "cli" step detects the appropriate input. If no input options are passed,
@@ -23,44 +10,48 @@ function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<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 { output } = compiler.options
-  const { log, input: bundledInput } = compiler
-
-  if (!process.stdin.isTTY) {
-    log.step('Using stdin as input')
-    compiler.input = await readStreamAsync(process.stdin)
-  }
-
   await next()
+  const { log } = compiler,
+    target = compiler.options.targets.shift() as NexeTarget,
+    deliverable = await compiler.compileAsync(target),
+    output = normalize(compiler.output)
 
-  compiler.output = isWindows
+  mkdirSync(dirname(output), { recursive: true })
-    ? `${(output || compiler.options.name).replace(/\.exe$/, '')}.exe`
-    : `${output || compiler.options.name}`
 
-  const target = compiler.options.targets.shift() as NexeTarget
+  return await new Promise((res, rej) => {
-  const deliverable = await compiler.compileAsync(target)
-
-  return new Promise((resolve, reject) => {
     const step = log.step('Writing result to file')
     deliverable
-      .pipe(createWriteStream(normalize(compiler.output!)))
+      .pipe(createWriteStream(output))
-      .on('error', reject)
+      .on('error', rej)
       .once('close', (e: Error) => {
         if (e) {
-          reject(e)
+          rej(e)
         } else if (compiler.output) {
-          chmodSync(compiler.output, '755')
+          const output = compiler.output,
-          step.log(`Executable written to: ${compiler.output}`)
+            mode = statSync(output).mode | 0o111,
-          resolve(compiler.quit())
+            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))
+          step.log(
+            `Entry: '${
+              compiler.stdinUsed
+                ? compiler.options.mangle
+                  ? STDIN_FLAG
+                  : '[none]'
+                : inputFileLogOutput
+            }' written to: ${outputFileLogOutput}`
+          )
+          compiler.quit()
+          res(output)
         }
       })
   })

src/steps/download.ts

@@ -1,18 +1,23 @@
-import download = require('download')
+import { dirname } from 'node:path'
-import { pathExistsAsync } from '../util'
+
-import { LogStep } from '../logger'
+import download from 'download'
-import { IncomingMessage } from 'http'
+
-import { NexeCompiler } from '../compiler'
+import { pathExists } from '../util.js'
+import type { LogStep } from '../logger.js'
+import type { NexeCompiler } from '../compiler.js'
+import { NexeError } from '../compiler.js'
+
+import type { IncomingMessage } from 'node:http'
 
 function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options = {}) {
   const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
   return download(url, dest, Object.assign(options, { extract: true, strip: 1 }))
     .on('response', (res: IncomingMessage) => {
-      const total = +res.headers['content-length']!
+      const total = Number(res.headers['content-length'])
       let current = 0
-      res.on('data', data => {
+      res.on('data', (data) => {
         current += data.length
-        setText(current / total * 100)
+        setText((current / total) * 100)
         if (current === total) {
           step.log('Extracting Node...')
         }
@@ -21,24 +26,57 @@ 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 = Number(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 } = compiler
+  const { src, log, target } = compiler,
-  const { version, sourceUrl, downloadOptions } = compiler.options
+    { version } = target,
-  const url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`
+    { sourceUrl, downloadOptions, build } = compiler.options,
-  const step = log.step(`Downloading Node.js source from: ${url}`)
+    url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`,
-  if (await pathExistsAsync(src)) {
+    step = log.step(
-    step.log('Source already downloaded')
+      `Downloading ${build ? '' : 'pre-built '}Node.js${build ? ` source from: ${url}` : ''}`
-    return next()
+    ),
+    exeLocation = compiler.getNodeExecutableLocation(build ? undefined : target),
+    downloadExists = await pathExists(build ? src : exeLocation)
+
+  if (downloadExists) {
+    step.log('Already downloaded...')
+    return await next()
   }
 
-  if (compiler.options.build) {
+  if (build) {
     await fetchNodeSourceAsync(src, url, step, downloadOptions)
+  } else {
+    await fetchPrebuiltBinary(compiler, step)
   }
 
-  return next()
+  return await next()
 }

src/steps/resource.ts

@@ -1,32 +1,34 @@
-import { readFileAsync, isDirectoryAsync, each } from '../util'
+import { relative } from 'node:path'
-import { Buffer } from 'buffer'
-import * as globs from 'globby'
-import { NexeCompiler } from '../compiler'
 
-export default async function resource(compiler: NexeCompiler, next: () => Promise<void>) {
+import fg from 'fast-glob'
-  const resources = compiler.resources
 
-  if (!compiler.options.resources.length) {
+import { each } from '../util.js'
-    return next()
+import type { NexeCompiler } from '../compiler.js'
+
+export default async function resource(compiler: NexeCompiler, next: () => Promise<any>) {
+  const { cwd, resources } = compiler.options
+  if (resources.length === 0) {
+    return await next()
   }
-  const step = compiler.log.step('Bundling Resources...')
   let count = 0
-  await each(globs(compiler.options.resources), async file => {
+
-    if (await isDirectoryAsync(file)) {
+  resources.forEach((x: string) => {
-      return
+    if (x.includes('node_modules/**')) {
+      compiler.log.step(
+        `[WARNING]: pattern "${x}" will include many files, consider narrowing the pattern`,
+        'stopAndPersist',
+        'yellow'
+      )
     }
-    count++
-    step.log(`Including file: ${file}`)
-    const contents = await readFileAsync(file)
-    const commentSafeContents = contents.toString('base64')
-    resources.index[file] = [
-      Buffer.byteLength(resources.bundle),
-      Buffer.byteLength(commentSafeContents)
-    ]
-    resources.bundle += commentSafeContents
   })
-  step.log(
+
-    `Included ${count} file(s). ${(Buffer.byteLength(resources.bundle) / 1e6).toFixed(3)} MB`
+  const step = compiler.log.step('Bundling Resources...')
-  )
+
-  return next()
+  await each(fg(resources, { cwd, absolute: true, onlyFiles: true }), async (file) => {
+    count++
+    step.log(`Including file: ${relative(cwd, file)}`)
+    await compiler.addResource(file)
+  })
+  compiler.log.step(`Included ${count} file(s)`, 'stopAndPersist')
+  return await next()
 }

src/steps/shim.ts

@@ -0,0 +1,35 @@
+import type { NexeCompiler } from '../compiler.js'
+import { wrap } from '../util.js'
+
+export default async function (compiler: NexeCompiler, next: () => Promise<void>) {
+  await next()
+  compiler.shims.push(
+    wrap(
+      '' +
+        '{{replace:lib/MOD/fs/patch.js}}' +
+        '\nshimFs(process.__nexe)' +
+        `\n${compiler.options.fs ? '' : 'restoreFs()'}`
+    )
+  )
+  compiler.shims.push(
+    wrap(`
+    if (process.argv[1] && process.env.NODE_UNIQUE_ID) {
+      const cluster = require('cluster')
+      cluster._setupWorker()
+      delete process.env.NODE_UNIQUE_ID
+    }
+  `)
+  )
+
+  compiler.shims.push(
+    wrap(`
+      if (!process.send) {
+        const path = require('path')
+        const entry = path.resolve(path.dirname(process.execPath),${JSON.stringify(
+          compiler.entrypoint
+        )})
+        process.argv.splice(1,0, entry)
+      }
+    `)
+  )
+}

src/target.ts

@@ -1,42 +1,47 @@
 export type NodePlatform = 'windows' | 'mac' | 'alpine' | 'linux'
-export type NodeArch = 'x86' | 'x64'
+export type NodeArch = 'x86' | 'x64' | 'arm' | 'arm64'
 
 const platforms: NodePlatform[] = ['windows', 'mac', 'alpine', 'linux'],
-  architectures: NodeArch[] = ['x86', 'x64']
+  architectures: NodeArch[] = ['x86', 'x64', 'arm', 'arm64']
 
 export { platforms, architectures }
 
 export interface NexeTarget {
   version: string
-  platform: NodePlatform
+  platform: NodePlatform | string
-  arch: NodeArch
+  arch: NodeArch | string
 }
 
-//TODO bsd
 const prettyPlatform: { [key: string]: NodePlatform } = {
-  win32: 'windows',
+    win32: 'windows',
-  windows: 'windows',
+    windows: 'windows',
-  darwin: 'mac',
+    win: 'windows',
-  macos: 'mac',
+    darwin: 'mac',
-  mac: 'mac',
+    macos: 'mac',
-  linux: 'linux',
+    mac: 'mac',
-  static: 'alpine',
+    linux: 'linux',
-  alpine: 'alpine'
+    static: 'alpine',
-}
+    alpine: 'alpine',
-
+  },
-//TODO arm
+  prettyArch: { [key: string]: NodeArch } = {
-const prettyArch: { [key: string]: NodeArch } = {
+    x86: 'x86',
-  x86: 'x86',
+    arm6: 'arm',
-  ia32: 'x86',
+    arm64: 'arm64',
-  x32: 'x86',
+    arm6l: 'arm',
-  x64: 'x64'
+    arm: 'arm',
-}
+    arm7: 'arm',
+    arm7l: 'arm',
+    amd64: 'x64',
+    ia32: 'x86',
+    x32: 'x86',
+    x64: 'x64',
+  }
 
 function isVersion(x: string) {
   if (!x) {
     return false
   }
-  return /\d/.test(x.replace(/v|\./g, ''))
+  return /^[\d]+$/.test(x.replace(/v|\.|\s+/g, ''))
 }
 
 function isPlatform(x: string): x is NodePlatform {
@@ -52,6 +57,7 @@ class Target implements NexeTarget {
   toJSON() {
     return this.toString()
   }
+
   toString() {
     return `${this.platform}-${this.arch}-${this.version}`
   }
@@ -61,8 +67,9 @@ export function targetsEqual(a: NexeTarget, b: NexeTarget) {
   return a.arch === b.arch && a.platform === b.platform && a.version === b.version
 }
 
-export function getTarget(target: string | NexeTarget = ''): NexeTarget {
+export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget {
-  let arch = process.arch as NodeArch,
+  const currentArch = process.arch
+  let arch = currentArch in prettyArch ? prettyArch[process.arch] : (process.arch as NodeArch),
     platform = prettyPlatform[process.platform],
     version = process.version.slice(1)
 
@@ -73,9 +80,9 @@ export function getTarget(target: string | NexeTarget = ''): NexeTarget {
   target
     .toLowerCase()
     .split('-')
-    .forEach(x => {
+    .forEach((x) => {
       if (isVersion(x)) {
-        version = x
+        version = x.replace(/v/g, '')
       }
       if (isPlatform(x)) {
         platform = prettyPlatform[x]

src/types.d.ts

@@ -3,11 +3,14 @@ declare module 'got' {
     (url: string, options?: any): Promise<{ body: string }>
     stream(url: string, optoins?: any): any
   }
-  function got(url: string, options?: any): Promise<{ body: string }>
+  const got: GotFn
-  export = got as GotFn
+  export = got
 }
+
+declare module 'caw'
+
 declare module 'download' {
-  import { Duplex } from 'stream'
+  import type { Duplex } from 'stream'
   interface DownloadOptions {
     extract?: boolean
     strip?: number

src/util.ts

@@ -1,18 +1,44 @@
-import { readFile, writeFile, stat } from 'fs'
+import { readFile, writeFile, stat } from 'node:fs/promises'
-import { execFile } from 'child_process'
+import { execFile as exec } from 'node:child_process'
-import pify = require('pify')
+import { promisify } from 'node:util'
-import rimraf = require('rimraf')
 
-const rimrafAsync = pify(rimraf)
+export const STDIN_FLAG = '[stdin]'
+
+export const esm: {
+  chalk: typeof import('chalk') | null
+  ora: typeof import('ora') | null
+  got: typeof import('got') | null
+} = {
+  got: null,
+  chalk: null,
+  ora: null,
+}
+
+export async function initEsm() {
+  await Promise.all(
+    (['chalk', 'got', 'ora'] as const).map(async (x) => {
+      esm[x] = await import(x)
+    })
+  )
+}
+
+const id = (x: any) => x
+export function color(color?: string, text?: string) {
+  return !color ? text : ((esm.chalk?.default as any)[color] || id)(text)
+}
+
+export type Func<T = any, Args = any> = (...args: Args[]) => T
 
 export async function each<T>(
   list: T[] | Promise<T[]>,
   action: (item: T, index: number, list: T[]) => Promise<any>
 ) {
   const l = await list
-  for (let i = 0; i < l.length; i++) {
+  return await Promise.all(l.map(action))
-    await action(l[i], i, l)
+}
-  }
+
+export function wrap(code: string) {
+  return '!(function () {' + code + '})();'
 }
 
 function falseOnEnoent(e: any) {
@@ -22,10 +48,34 @@ function falseOnEnoent(e: any) {
   throw e
 }
 
+function padRight(str: string, l: number) {
+  return (str + ' '.repeat(l)).slice(0, l)
+}
+
+const bound: MethodDecorator = function bound<T>(
+  target: object,
+  propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<T>
+) {
+  const configurable = true
+  return {
+    configurable,
+    get(this: T) {
+      const value = (descriptor.value as any).bind(this)
+      Object.defineProperty(this, propertyKey as string, {
+        configurable,
+        value,
+        writable: true,
+      })
+      return value
+    },
+  }
+}
+
 function dequote(input: string) {
   input = input.trim()
-  const singleQuote = input.startsWith("'") && input.endsWith("'")
+  const singleQuote = input.startsWith("'") && input.endsWith("'"),
-  const doubleQuote = input.startsWith('"') && input.endsWith('"')
+    doubleQuote = input.startsWith('"') && input.endsWith('"')
   if (singleQuote || doubleQuote) {
     return input.slice(1).slice(0, -1)
   }
@@ -37,32 +87,44 @@ export interface ReadFileAsync {
   (path: string, encoding: string): Promise<string>
 }
 
-const readFileAsync = pify(readFile)
+const execFile = promisify(exec),
-const writeFileAsync = pify(writeFile)
+  isWindows = process.platform === 'win32'
-const statAsync = pify(stat)
-const execFileAsync = pify(execFile)
-const isWindows = process.platform === 'win32'
 
-function pathExistsAsync(path: string) {
+async function pathExists(path: string) {
-  return statAsync(path)
+  return await stat(path)
-    .then(x => true)
+    .then(() => true)
     .catch(falseOnEnoent)
 }
 
-function isDirectoryAsync(path: string) {
+async function isDirectory(path: string) {
-  return statAsync(path)
+  return await stat(path)
-    .then(x => x.isDirectory())
+    .then((x) => x.isDirectory())
     .catch(falseOnEnoent)
 }
 
+function semverGt(version: string, operand: string) {
+  const [cMajor, cMinor, cPatch] = version.split('.').map(Number)
+  let [major, minor, patch] = operand.split('.').map(Number)
+  major = Number(major)
+  if (!minor) minor = 0
+  if (!patch) patch = 0
+  return (
+    cMajor > major ||
+    (cMajor === major && cMinor > minor) ||
+    (cMajor === major && cMinor === minor && cPatch > patch)
+  )
+}
+
 export {
   dequote,
+  padRight,
+  bound,
   isWindows,
-  rimrafAsync,
+  stat,
-  statAsync,
+  execFile,
-  execFileAsync,
+  readFile,
-  readFileAsync,
+  pathExists,
-  pathExistsAsync,
+  isDirectory,
-  isDirectoryAsync,
+  writeFile,
-  writeFileAsync
+  semverGt,
 }

tasks/build.ts

@@ -1,105 +1,65 @@
-import * as nexe from '../src/nexe'
+import { env } from 'node:process'
-import {
+import { execSync } from 'node:child_process'
-  getUnBuiltReleases,
+import { buildArm, buildAlpine } from './docker.js'
-  getLatestGitRelease
-} from '../src/releases'
-import * as ci from './ci'
-import { runAlpineBuild } from './docker'
-import { getTarget } from '../src/target'
-import { pathExistsAsync, statAsync, readFileAsync, execFileAsync } from '../src/util'
-import got = require('got')
 
-const env = process.env,
+export async function build(target = env.NEXE_TARGET || null) {
-  branchName = env.CIRCLE_BRANCH || env.APPVEYOR_REPO_BRANCH || env.TRAVIS_BRANCH || '',
+  if (!target?.trim()) {
-  isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD || env.NEXE_TRIGGERED),
+    throw new Error('Environment variable NEXE_TARGET not found. Received: ' + target)
-  isLinux = Boolean(env.CIRCLECI),
-  isWindows = Boolean(env.APPVEYOR),
-  isMac = Boolean(env.TRAVIS),
-  isPullRequest = Boolean(env.CIRCLE_PR_NUMBER)
-    || Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) 
-    || Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
-  headers = { 
-    'Authorization': 'token ' + env.GITHUB_TOKEN,
-    'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
   }
 
-if (require.main === module) {
+  const done = keepalive()
-  if (!isPullRequest) {
+  let file = ''
-    build().catch(x => {
+  try {
-      console.error(x)
+    if (target.includes('alpine')) {
-      process.exit(1)
+      file = await buildAlpine(target)
-    })
+    } else if (target.includes('arm')) {
-  }
+      file = await buildArm(target)
-}
-
-async function build () {
-  if (isScheduled) {
-    const releases = await getUnBuiltReleases({ headers })
-    if (!releases.length) {
-      return
-    }
-    const windowsBuild = releases.find(x => x.platform === 'windows')
-    const macBuild = releases.find(x => x.platform === 'mac')
-    const linuxOrAlpine = releases.find(x => x.platform === 'linux' || x.platform === 'alpine')
-
-    if (linuxOrAlpine) {
-      await ci.triggerDockerBuild(linuxOrAlpine, branchName)
-    }
-    if (macBuild) {
-      await ci.triggerMacBuild(macBuild, branchName)
-    }
-    if (windowsBuild) {
-      await ci.triggerWindowsBuild(windowsBuild)
-    }
-  }
-
-  if (env.NEXE_VERSION) {
-    const
-      target = getTarget(env.NEXE_VERSION),
-      output = isWindows ? './out.exe' : './out',
-      options = {
-        empty: true,
-        build: true,
-        target,
-        output
-      }
-    
-    const stop = keepalive()
-    if (target.platform === 'alpine') {
-      await runAlpineBuild(target, nexe.version.split('.')[0])
     } else {
-      await nexe.compile(options)      
+      file = await nexeBuild(target)
-    }
+      assertNexeBinary(file)
-    stop()
-    
-    
-    if (await pathExistsAsync(output)) {
-      await assertNexeBinary(output)
-      const gitRelease = await getLatestGitRelease({ headers })
-      await got(gitRelease.upload_url.split('{')[0], {
-        query: { name: target.toString() },
-        body: await readFileAsync(output),
-        headers: {
-          'Authorization': 'token ' + env.GITHUB_TOKEN,
-          'Content-Type': 'application/octet-stream',
-          'User-Agent': 'nexe (https://www.npmjs.com/package/nexe)'
-        }
-      })
-      console.log(target + ' uploaded.')
     }
+  } catch (e: any) {
+    done()
+    throw e
   }
+
+  if (!file) {
+    throw new Error('Binary failed to build')
+  }
+
+  uploadBinary(target, file)
 }
 
-function keepalive () {
+function nexeBuild(target: string) {
+  console.log('building: ' + target)
+  return Promise.resolve('')
+}
+
+function uploadBinary(target: string, file: string) {
+  void file
+  console.log('uploading to release')
+}
+
+function keepalive() {
   const keepalive = setInterval(() => console.log('Building...'), 300 * 1000)
   return () => clearInterval(keepalive)
 }
 
-function assertNexeBinary (file: string) {
+function assertNexeBinary(file: string) {
-  return execFileAsync(file).catch(e => {
+  if (!file) throw new Error('Invalid filename: "' + file + '"')
+  let result = ''
+  try {
+    result = execSync(file).toString('utf8')
+  } catch (e: any) {
     if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
       return
     }
     throw e
-  })
+  }
+  throw new Error('Not a bare nexe binary: ' + result)
 }
+
+build().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})

tasks/ci.ts

@@ -1,48 +0,0 @@
-import { NexeTarget } from '../src/releases'
-import got = require('got')
-import * as assert from 'assert'
-const { env } = process
-
-export function triggerMacBuild(release: NexeTarget, branch: string) {
-  assert.ok(env.TRAVIS_TOKEN)
-  const travis = `https://api.travis-ci.org/repo/nexe%2Fnexe/requests`
-  return got(travis, {
-    json: true,
-    body: {
-      request: {
-        branch: branch,
-        config: {
-          merge_mode: 'deep_merge',
-          env: {
-            NEXE_VERSION: release.toString()
-          }
-        }
-      }
-    },
-    headers: {
-      'Travis-API-Version': '3',
-      'Authorization': `token ${env.TRAVIS_TOKEN}`
-    }
-  })
-}
-
-export function triggerDockerBuild (release: NexeTarget, branch: string) {
-  assert.ok(env.CIRCLE_TOKEN)
-  const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/${branch}?circle-token=${env.CIRCLE_TOKEN}`
-  return got(circle, {
-    json: true,
-    body: {
-      build_parameters: {
-        NEXE_VERSION: release.toString()
-      }
-    }
-  })
-}
-
-export function triggerWindowsBuild (release: NexeTarget) {
-  const hasVersion = 'NEXE_VERSION' in env
-  env.NEXE_VERSION = hasVersion 
-    ? env.NEXE_VERSION!.trim() 
-    : release.toString() 
-  return Promise.resolve()
-}

tasks/docker.d.ts

@@ -0,0 +1,2 @@
+export declare function buildArm(target: string): Promise<string>
+export declare function buildAlpine(target: string): Promise<string>

tasks/docker.ts

@@ -1,73 +1,9 @@
-import { NexeTarget } from '../src/target'
+export function buildArm(target: string) {
-import { writeFileAsync, readFileAsync } from '../src/util'
+  console.log('building arm: ' + target)
-import { spawn } from 'child_process'
+  return Promise.resolve('')
-import got = require('got')
-import { createWriteStream, WriteStream } from 'fs'
-
-function alpine (target: NexeTarget, nexeVersion: string) {  
-  return `
-FROM i386/alpine:3.4
-RUN apk add --no-cache curl make gcc g++ binutils-gold python linux-headers paxctl libgcc libstdc++ git vim tar gzip wget
-ENV NODE_VERSION=${target.version}
-ENV NEXE_VERSION=beta
-WORKDIR /
-
-RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
-  cd /node-v\${NODE_VERSION} && \
-  ./configure --prefix=/usr --fully-static && \
-  make -j$(getconf _NPROCESSORS_ONLN) && \
-  make install && \
-  paxctl -cm /usr/bin/node
-
-RUN mkdir /nexe_temp && mv node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
-  npm install -g nexe@\${NEXE_VERSION} && \
-  nexe --build --empty --temp /nexe_temp -c="--fully-static" -o out
-`.trim()
 }
 
-export async function runAsync (command: string, output: WriteStream) {
+export function buildAlpine(target: string) {
-  const commands = command.split(/\r?\n/)
+  console.log('building alpine: ' + target)
-    .filter(x => x.trim())
+  return Promise.resolve('')
-    .map(x => x.trim().split(' '))
-  const sequence = Promise.resolve()
-  for (const command of commands) {
-    await new Promise((resolve, reject) => {
-      const cp = spawn(command.shift() as string, command)
-      cp.stderr.pipe(output)
-      cp.stdout.pipe(output)
-      const close = function (this: any, e: Error) {
-        this.kill()
-        e ? reject(e) : resolve()
-      }
-      cp.on('error', (e) => {
-        output.write(e.stack)
-      })
-      .on('close', close)
-      .on('exit', close)
-    })
-  }
-}
-
-export async function runAlpineBuild (target: NexeTarget, nexeVersion: string) {
-  await writeFileAsync('Dockerfile', alpine(target, nexeVersion))
-  const outFilename = 'nexe-alpine-build-log.txt'
-  const output = createWriteStream(outFilename)
-  try {
-    await runAsync(`
-    docker build -t nexe-alpine .
-    docker run -d --name nexe nexe-alpine sh
-    docker cp nexe:/out out
-    docker rm nexe
-  `, output)
-  } catch(e) {
-    console.log(e)
-  } finally {
-    output.close()
-    await got(`https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`, {
-      body: await readFileAsync(outFilename),
-      method: 'PUT'
-    })
-    .then(x => console.log(x.body))
-    .catch(e => console.log('Error posting log', e))
-  }
 }

tasks/post-build.ts

@@ -0,0 +1,41 @@
+import { writeFileSync, readFileSync } from 'node:fs'
+import { equal } from 'node:assert'
+
+/**
+ * post build step to insert code files into code files (naively).
+ * '{{replace:path/to/file}}' => "file contents"
+ * And the package.json version.
+ */
+const totalReplacements = 8
+let replaced = 0
+const mods = ['cjs', 'esm'] as const
+
+mods.forEach((x) => {
+  inject(x, `lib/${x}/patches/third-party-main.js`)
+  inject(x, `lib/${x}/steps/shim.js`)
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  inject(x, `lib/${x}/options.js`, JSON.stringify(require('../package.json').version))
+})
+
+function inject(mod: typeof mods[number], filename: string, ...replacements: string[]) {
+  let contents = readFileSync(filename, 'utf8')
+  contents = contents.replace(/('{{(.*)}}')/g, (substring: string, ...matches: string[]) => {
+    if (!matches || !matches[1]) {
+      return substring
+    }
+    const [replace, file] = matches[1].split(':')
+    if (replace !== 'replace') {
+      return substring
+    }
+    ++replaced
+    console.log('Replacing: ', substring)
+
+    return replacements[+file]
+      ? replacements[+file]
+      : JSON.stringify(readFileSync(file.replace('MOD', mod), 'utf8').replace('"use strict";', ''))
+  })
+  writeFileSync(filename, contents)
+  console.log(`Wrote: ${filename}`)
+}
+
+equal(replaced, totalReplacements, `Expected to replace ${totalReplacements} things`)

test/exports.mjs

@@ -0,0 +1,15 @@
+import * as nexeEsm from '../lib/esm/nexe.js'
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+import { ok } from 'node:assert'
+
+const cjs = createRequire(fileURLToPath(import.meta.url)),
+  nexeCjs = cjs('../lib/cjs/nexe.js'),
+  exports = ['NexeCompiler', 'argv', 'compile', 'help', 'version']
+
+for (const exp of exports) {
+  ok(exp in nexeCjs)
+  ok(exp in nexeEsm)
+}
+
+console.log('esm and cjs modules match')

test/fixture/dependency.js

@@ -0,0 +1 @@
+module.exports = 'abc'

test/fixture/entry.js

@@ -0,0 +1 @@
+console.log('hello world', require('./dependency'))

test/fixture/package.json

@@ -0,0 +1,3 @@
+{
+  "main": "entry.js"
+}

test/options.spec.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest'
+import * as path from 'path'
+
+import { normalizeOptions } from '../src/options.js'
+
+const ext = process.platform === 'win32' ? '.exe' : ''
+
+describe('options', () => {
+  describe('cwd', () => {
+    it('should use process.cwd() if nothing is provided', () => {
+      const options = normalizeOptions()
+      expect(options.cwd).to.equal(process.cwd())
+    })
+    it('should use the main module in a package directory (if not in a TTY)', () => {
+      const options = normalizeOptions()
+      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' })
+      expect(options.input).to.equal(path.resolve('./test/fixture/entry.js'))
+    })
+    it('should accept a module entry as input', () => {
+      const options = normalizeOptions({ input: 'test/fixture' })
+      expect(options.input).to.equal(path.resolve('./test/fixture/entry.js'))
+    })
+    it('should resolve pathed options against cwd', () => {
+      const cwd = path.join(process.cwd(), 'test/fixture'),
+        options = normalizeOptions({
+          cwd,
+          input: 'entry',
+          output: 'abc',
+          temp: './d',
+        })
+      expect(options.temp).to.equal(path.resolve(cwd, './d'))
+      expect(options.input).to.equal(path.resolve(cwd, 'entry.js'))
+      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({
+        output: './some-output',
+      })
+      expect(options.output).to.equal(path.resolve(`./some-output${ext}`))
+    })
+    it('should default to the input file name if not index', () => {
+      const options = normalizeOptions({
+        input: './test/fixture',
+      })
+      expect(options.output).to.equal(path.resolve(`./entry${ext}`))
+    })
+    it('should default to the folder/project name if filename is index', () => {
+      const options = normalizeOptions({ cwd: './test/fixture2' })
+      expect(options.output).to.equal(path.resolve(`./test/fixture2/fixture2${ext}`))
+    })
+  })
+})

test/target.spec.d.ts

@@ -0,0 +1 @@
+export {}

test/target.spec.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest'
+import chalk from 'chalk'
+
+import { padRight } from '../src/util.js'
+import { getTarget } from '../src/target.js'
+
+const b = chalk.blue,
+  arch = process.arch === 'ia32' ? 'x86' : process.arch
+
+describe('Targets', () => {
+  ;[
+    ['win-ia32-6.11.2', 'windows-x86-6.11.2'],
+    [{ version: '6.11.2', platform: 'win', arch: 'ia32' }, 'windows-x86-6.11.2'],
+    ['win32-x64-6.11.2', 'windows-x64-6.11.2'],
+    ['win-amd64-6.11.2', 'windows-x64-6.11.2'],
+    ['darwin-x64-v8.4.0', 'mac-x64-8.4.0'],
+    ['macos-x64-v8.4.0', 'mac-x64-8.4.0'],
+    ['static-x86-6.10.3', 'alpine-x86-6.10.3'],
+    ['linux-x32', `linux-x86-${process.version.slice(1)}`],
+    ['alpine-notsupported-6.10.3', `alpine-${arch}-6.10.3`],
+    ['not-a-thing', getTarget(process).toString()],
+  ].forEach(([input, expected]) => {
+    it(`should accept: ${padRight(JSON.stringify(input), 53)} ${b('->')}   ${expected}`, () => {
+      expect(getTarget(input).toString()).to.equal(expected)
+    })
+  })
+
+  it('should stringify and toString', () => {
+    expect(JSON.stringify(getTarget(process))).to.equal(`"${getTarget(process)}"`)
+  })
+})

tsconfig.json

@@ -1,12 +1,25 @@
 {
   "compilerOptions": {
-    "target":"es5",
+    "outDir": "./lib/types",
-    "lib": ["es2017"],
+    "target":"es2020",
-    "module": "commonjs",
+    "lib": ["es2020"],
-    "outDir": "./lib",
+    "module": "es2020",
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
     "strict": true
   },
   "include":[
-    "src/**/*.ts"
+    "src/**/*.ts",
-  ]
+  ],
+  "ts-node": {
+    "transpileOnly": true,
+    "transpiler": "ts-node/transpilers/swc",
+    "compilerOptions": {
+      "esModuleInterop": true,
+      "module": "commonjs"
+    }
+  }
 }