@depup/nexe 5.0.0-beta.4-depup.0

package/lib/patches/disable-node-cli.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+function disableNodeCli(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (compiler.options.enableNodeCli) {
+            return next();
+        }
+        if ((0, util_1.semverGt)(compiler.target.version, '18.99')) {
+            yield compiler.replaceInFileAsync('src/node.cc', /(?<!static ExitCode )ProcessGlobalArgsInternal\(argv[^;]*;/gm, 'ExitCode::kNoFailure;/*$&*/');
+        }
+        else if ((0, util_1.semverGt)(compiler.target.version, '11.6.0')) {
+            yield compiler.replaceInFileAsync('src/node.cc', /(?<!int )ProcessGlobalArgs\(argv[^;]*;/gm, '0;/*$&*/');
+        }
+        else if ((0, util_1.semverGt)(compiler.target.version, '10.9')) {
+            yield compiler.replaceInFileAsync('src/node.cc', /(?<!void )ProcessArgv\(argv/g, '//$&');
+        }
+        else if ((0, util_1.semverGt)(compiler.target.version, '9.999')) {
+            yield compiler.replaceInFileAsync('src/node.cc', 'int i = 1; i < v8_argc; i++', 'int i = v8_argc; i < v8_argc; i++');
+            let matches = 0;
+            yield compiler.replaceInFileAsync('src/node.cc', /v8_argc > 1/g, (match) => {
+                if (matches++) {
+                    return 'false';
+                }
+                return match;
+            });
+        }
+        else {
+            const nodeccMarker = 'argv[index][0] ==';
+            yield compiler.replaceInFileAsync('src/node.cc', `${nodeccMarker} '-'`, 
+            // allow NODE_OPTIONS, introduced in 8.0
+            (0, util_1.semverGt)(compiler.target.version, '7.99')
+                ? `(${nodeccMarker} (is_env ? '-' : ']'))`
+                : `(${nodeccMarker} ']')`);
+        }
+        return next();
+    });
+}
+exports.default = disableNodeCli;

package/lib/patches/flags.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function flags(compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;

package/lib/patches/flags.js

@@ -0,0 +1,22 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function flags(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nodeflags = compiler.options.flags;
+        if (!nodeflags.length) {
+            return next();
+        }
+        yield compiler.replaceInFileAsync('node.gyp', "'node_v8_options%': ''", `'node_v8_options%': '${nodeflags.join(' ')}'`);
+        return next();
+    });
+}
+exports.default = flags;

package/lib/patches/gyp.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function nodeGyp({ files, replaceInFileAsync }: NexeCompiler, next: () => Promise<void>): Promise<void>;

package/lib/patches/gyp.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function nodeGyp({ files, replaceInFileAsync }, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield next();
+        const nodeGypMarker = "'lib/fs.js',";
+        yield replaceInFileAsync('node.gyp', nodeGypMarker, `
+    ${nodeGypMarker}
+    ${files
+            .filter((x) => x.filename.startsWith('lib'))
+            .map((x) => `'${x.filename}'`)
+            .toString()},
+  `.trim());
+    });
+}
+exports.default = nodeGyp;

package/lib/patches/ico.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function ico(compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;

package/lib/patches/ico.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const util_1 = require("../util");
+function ico(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const iconFile = compiler.options.ico;
+        if (!iconFile) {
+            return next();
+        }
+        yield compiler.setFileContentsAsync('src/res/node.ico', yield (0, util_1.readFileAsync)((0, path_1.normalize)(iconFile)));
+        return next();
+    });
+}
+exports.default = ico;

package/lib/patches/index.d.ts

@@ -0,0 +1,3 @@
+import gyp from './gyp';
+declare const patches: (typeof gyp)[];
+export default patches;

package/lib/patches/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gyp_1 = __importDefault(require("./gyp"));
+const third_party_main_1 = __importDefault(require("./third-party-main"));
+const build_fixes_1 = __importDefault(require("./build-fixes"));
+const disable_node_cli_1 = __importDefault(require("./disable-node-cli"));
+const flags_1 = __importDefault(require("./flags"));
+const ico_1 = __importDefault(require("./ico"));
+const node_rc_1 = __importDefault(require("./node-rc"));
+const snapshot_1 = __importDefault(require("./snapshot"));
+const patches = [gyp_1.default, third_party_main_1.default, build_fixes_1.default, disable_node_cli_1.default, flags_1.default, ico_1.default, node_rc_1.default, snapshot_1.default];
+exports.default = patches;

package/lib/patches/node-rc.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function nodeRc(compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;

package/lib/patches/node-rc.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function nodeRc(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const options = compiler.options.rc;
+        if (!options) {
+            return next();
+        }
+        const file = yield compiler.readFileAsync('src/res/node.rc');
+        Object.keys(options).forEach((key) => {
+            let value = options[key];
+            const isVar = /^[A-Z_]+$/.test(value);
+            value = isVar ? value : `"${value}"`;
+            file.contents = file.contents
+                .toString()
+                .replace(new RegExp(`VALUE "${key}",.*`), `VALUE "${key}", ${value}`);
+        });
+        ['PRODUCTVERSION', 'FILEVERSION'].forEach((x) => {
+            if (options[x]) {
+                file.contents = file.contents
+                    .toString()
+                    .replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`);
+            }
+        });
+        return next();
+    });
+}
+exports.default = nodeRc;

package/lib/patches/snapshot.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;

package/lib/patches/snapshot.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const util_1 = require("../util");
+function default_1(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { snapshot, warmup, cwd } = compiler.options;
+        if (!snapshot) {
+            return next();
+        }
+        const variablePrefix = (0, util_1.semverGt)(compiler.target.version, '11.0.0') ? 'v8_' : '';
+        yield compiler.replaceInFileAsync(compiler.configureScript, 'def configure_v8(o):', `def configure_v8(o):\n  o['variables']['${variablePrefix}embed_script'] = r'${(0, path_1.resolve)(cwd, snapshot)}'\n  o['variables']['${variablePrefix}warmup_script'] = r'${(0, path_1.resolve)(cwd, warmup || snapshot)}'`);
+        return next();
+    });
+}
+exports.default = default_1;

package/lib/patches/third-party-main.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function main(compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;

package/lib/patches/third-party-main.js

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const meriyah_1 = require("meriyah");
+const util_1 = require("../util");
+function walkSome(node, visit) {
+    if (!node || typeof node.type !== 'string' || node._visited) {
+        return false;
+    }
+    visit(node);
+    node._visited = true;
+    for (let 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;
+}
+function main(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let bootFile = 'lib/internal/bootstrap_node.js';
+        const { version } = compiler.target;
+        if (version.startsWith('4.')) {
+            bootFile = 'src/node.js';
+        }
+        else if ((0, util_1.semverGt)(version, '18.11.99')) {
+            bootFile = 'lib/internal/process/pre_execution.js';
+        }
+        else if ((0, util_1.semverGt)(version, '11.99')) {
+            bootFile = 'lib/internal/bootstrap/pre_execution.js';
+        }
+        else if ((0, util_1.semverGt)(version, '9.10.1')) {
+            bootFile = 'lib/internal/bootstrap/node.js';
+        }
+        const file = yield compiler.readFileAsync(bootFile), ast = (0, meriyah_1.parse)(file.contents.toString(), {
+            next: true,
+            globalReturn: true,
+            loc: true,
+            specDeviation: true,
+        }), location = { start: { line: 0 } };
+        walkSome(ast, (node) => {
+            if (!location.start.line && node.type === 'BlockStatement') {
+                //Find the first block statement and mark the location
+                Object.assign(location, node.loc);
+                return true;
+            }
+        });
+        const fileLines = file.contents.toString().split('\n');
+        if ((0, util_1.semverGt)(version, '19.99')) {
+            yield compiler.replaceInFileAsync('lib/internal/modules/cjs/loader.js', "'use strict';", "'use strict';\n" + "if (true) {\n  const __nexe_patches = (process.nexe = { patches: {} }).patches\n  const slice = [].slice\n  const __nexe_noop_patch = function (original) {\n    const args = slice.call(arguments, 1)\n    return original.apply(this, args)\n  }\n  const __nexe_patch = function (obj, method, patch) {\n    const original = obj[method]\n    if (!original) return\n    __nexe_patches[method] = patch\n    obj[method] = function() {\n      const args = [original].concat(slice.call(arguments))\n      return __nexe_patches[method].apply(this, args)\n    }\n  }\n  __nexe_patch((process).binding('fs'), 'internalModuleReadFile', __nexe_noop_patch)\n  __nexe_patch((process).binding('fs'), 'internalModuleReadJSON', __nexe_noop_patch)\n  __nexe_patch((process).binding('fs'), 'internalModuleStat', __nexe_noop_patch)\n}\n" + '\n');
+            fileLines.splice(location.start.line, 0, 'expandArgv1 = false;');
+        }
+        else {
+            fileLines.splice(location.start.line, 0, "if (true) {\n  const __nexe_patches = (process.nexe = { patches: {} }).patches\n  const slice = [].slice\n  const __nexe_noop_patch = function (original) {\n    const args = slice.call(arguments, 1)\n    return original.apply(this, args)\n  }\n  const __nexe_patch = function (obj, method, patch) {\n    const original = obj[method]\n    if (!original) return\n    __nexe_patches[method] = patch\n    obj[method] = function() {\n      const args = [original].concat(slice.call(arguments))\n      return __nexe_patches[method].apply(this, args)\n    }\n  }\n  __nexe_patch((process).binding('fs'), 'internalModuleReadFile', __nexe_noop_patch)\n  __nexe_patch((process).binding('fs'), 'internalModuleReadJSON', __nexe_noop_patch)\n  __nexe_patch((process).binding('fs'), 'internalModuleStat', __nexe_noop_patch)\n}\n" +
+                '\n' +
+                ((0, util_1.semverGt)(version, '11.99') ? 'expandArgv1 = false;\n' : ''));
+        }
+        file.contents = fileLines.join('\n');
+        if ((0, util_1.semverGt)(version, '11.99')) {
+            if ((0, util_1.semverGt)(version, '12.17.99')) {
+                yield compiler.replaceInFileAsync(bootFile, 'initializeFrozenIntrinsics();', 'initializeFrozenIntrinsics();\n' + (0, util_1.wrap)("\"use strict\";\nconst fs = require('fs'), fd = fs.openSync(process.execPath, 'r'), stat = fs.statSync(process.execPath), tailSize = Math.min(stat.size, 16000), tailWindow = Buffer.from(Array(tailSize));\nfs.readSync(fd, tailWindow, 0, tailSize, stat.size - tailSize);\nconst footerPosition = tailWindow.indexOf('<nexe~~sentinel>');\nif (footerPosition == -1) {\n    throw 'Invalid Nexe binary';\n}\nconst footer = tailWindow.slice(footerPosition, footerPosition + 32), contentSize = footer.readDoubleLE(16), resourceSize = footer.readDoubleLE(24), contentStart = stat.size - tailSize + footerPosition - resourceSize - contentSize, resourceStart = contentStart + contentSize;\nObject.defineProperty(process, '__nexe', (function () {\n    let nexeHeader = null;\n    return {\n        get: function () {\n            return nexeHeader;\n        },\n        set: function (value) {\n            if (nexeHeader) {\n                throw new Error('This property is readonly');\n            }\n            nexeHeader = Object.assign({}, value, {\n                blobPath: process.execPath,\n                layout: {\n                    stat,\n                    contentSize,\n                    contentStart,\n                    resourceSize,\n                    resourceStart,\n                },\n            });\n            Object.freeze(nexeHeader);\n        },\n        enumerable: false,\n        configurable: false,\n    };\n})());\nconst contentBuffer = Buffer.from(Array(contentSize)), Module = require('module');\nfs.readSync(fd, contentBuffer, 0, contentSize, contentStart);\nfs.closeSync(fd);\nnew Module(process.execPath, null)._compile(contentBuffer.toString(), process.execPath);\n"));
+            }
+            else {
+                yield compiler.replaceInFileAsync(bootFile, 'initializePolicy();', 'initializePolicy();\n' + (0, util_1.wrap)("\"use strict\";\nconst fs = require('fs'), fd = fs.openSync(process.execPath, 'r'), stat = fs.statSync(process.execPath), tailSize = Math.min(stat.size, 16000), tailWindow = Buffer.from(Array(tailSize));\nfs.readSync(fd, tailWindow, 0, tailSize, stat.size - tailSize);\nconst footerPosition = tailWindow.indexOf('<nexe~~sentinel>');\nif (footerPosition == -1) {\n    throw 'Invalid Nexe binary';\n}\nconst footer = tailWindow.slice(footerPosition, footerPosition + 32), contentSize = footer.readDoubleLE(16), resourceSize = footer.readDoubleLE(24), contentStart = stat.size - tailSize + footerPosition - resourceSize - contentSize, resourceStart = contentStart + contentSize;\nObject.defineProperty(process, '__nexe', (function () {\n    let nexeHeader = null;\n    return {\n        get: function () {\n            return nexeHeader;\n        },\n        set: function (value) {\n            if (nexeHeader) {\n                throw new Error('This property is readonly');\n            }\n            nexeHeader = Object.assign({}, value, {\n                blobPath: process.execPath,\n                layout: {\n                    stat,\n                    contentSize,\n                    contentStart,\n                    resourceSize,\n                    resourceStart,\n                },\n            });\n            Object.freeze(nexeHeader);\n        },\n        enumerable: false,\n        configurable: false,\n    };\n})());\nconst contentBuffer = Buffer.from(Array(contentSize)), Module = require('module');\nfs.readSync(fd, contentBuffer, 0, contentSize, contentStart);\nfs.closeSync(fd);\nnew Module(process.execPath, null)._compile(contentBuffer.toString(), process.execPath);\n"));
+            }
+            yield compiler.replaceInFileAsync(bootFile, 'assert(!CJSLoader.hasLoadedAnyUserCJSModule)', '/*assert(!CJSLoader.hasLoadedAnyUserCJSModule)*/');
+            const { contents: nodeccContents } = yield compiler.readFileAsync('src/node.cc');
+            if (nodeccContents.includes('if (env->worker_context() != nullptr) {')) {
+                yield compiler.replaceInFileAsync('src/node.cc', 'if (env->worker_context() != nullptr) {', 'if (env->worker_context() == nullptr) {\n' +
+                    '  return StartExecution(env, "internal/main/run_main_module"); } else {\n');
+            }
+            else {
+                yield compiler.replaceInFileAsync('src/node.cc', 'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {', 'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {\n' +
+                    '  return StartExecution(env, "internal/main/run_main_module");\n');
+            }
+        }
+        else {
+            yield compiler.setFileContentsAsync('lib/_third_party_main.js', "\"use strict\";\nconst fs = require('fs'), fd = fs.openSync(process.execPath, 'r'), stat = fs.statSync(process.execPath), tailSize = Math.min(stat.size, 16000), tailWindow = Buffer.from(Array(tailSize));\nfs.readSync(fd, tailWindow, 0, tailSize, stat.size - tailSize);\nconst footerPosition = tailWindow.indexOf('<nexe~~sentinel>');\nif (footerPosition == -1) {\n    throw 'Invalid Nexe binary';\n}\nconst footer = tailWindow.slice(footerPosition, footerPosition + 32), contentSize = footer.readDoubleLE(16), resourceSize = footer.readDoubleLE(24), contentStart = stat.size - tailSize + footerPosition - resourceSize - contentSize, resourceStart = contentStart + contentSize;\nObject.defineProperty(process, '__nexe', (function () {\n    let nexeHeader = null;\n    return {\n        get: function () {\n            return nexeHeader;\n        },\n        set: function (value) {\n            if (nexeHeader) {\n                throw new Error('This property is readonly');\n            }\n            nexeHeader = Object.assign({}, value, {\n                blobPath: process.execPath,\n                layout: {\n                    stat,\n                    contentSize,\n                    contentStart,\n                    resourceSize,\n                    resourceStart,\n                },\n            });\n            Object.freeze(nexeHeader);\n        },\n        enumerable: false,\n        configurable: false,\n    };\n})());\nconst contentBuffer = Buffer.from(Array(contentSize)), Module = require('module');\nfs.readSync(fd, contentBuffer, 0, contentSize, contentStart);\nfs.closeSync(fd);\nnew Module(process.execPath, null)._compile(contentBuffer.toString(), process.execPath);\n");
+        }
+        return next();
+    });
+}
+exports.default = main;

package/lib/releases.d.ts

@@ -0,0 +1,15 @@
+import { NexeTarget } from './target';
+export { NexeTarget };
+export interface GitAsset {
+    name: string;
+    url: string;
+    browser_download_url: string;
+}
+export interface GitRelease {
+    tag_name: string;
+    assets_url: string;
+    upload_url: string;
+    assets: GitAsset[];
+}
+export declare function getLatestGitRelease(options?: any): Promise<GitRelease>;
+export declare function getUnBuiltReleases(options?: any): Promise<NexeTarget[]>;

package/lib/releases.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnBuiltReleases = exports.getLatestGitRelease = void 0;
+const got = require("got");
+const target_1 = require("./target");
+const versionsToSkip = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 17, 19, 21, 22];
+function getJson(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return JSON.parse((yield got(url, options)).body);
+    });
+}
+function isBuildableVersion(version) {
+    if (version === '12.11.0') {
+        return false;
+    }
+    return !versionsToSkip.includes(Number(version.split('.')[0]));
+}
+function getLatestGitRelease(options) {
+    return getJson('https://api.github.com/repos/nexe/nexe/releases/latest', options);
+}
+exports.getLatestGitRelease = getLatestGitRelease;
+function getUnBuiltReleases(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nodeReleases = yield getJson('https://nodejs.org/download/release/index.json');
+        const existingVersions = (yield getLatestGitRelease(options)).assets.map((x) => (0, target_1.getTarget)(x.name));
+        const versionMap = {};
+        return nodeReleases
+            .reduce((versions, { version }) => {
+            version = version.replace('v', '').trim();
+            if (!isBuildableVersion(version) || versionMap[version]) {
+                return versions;
+            }
+            versionMap[version] = true;
+            target_1.platforms.forEach((platform) => {
+                target_1.architectures.forEach((arch) => {
+                    if (arch === 'x86' && platform === 'mac')
+                        return;
+                    if (arch.includes('arm'))
+                        return;
+                    versions.push((0, target_1.getTarget)({ platform, arch, version }));
+                });
+            });
+            return versions;
+        }, [])
+            .filter((x) => !existingVersions.some((t) => (0, target_1.targetsEqual)(t, x)));
+    });
+}
+exports.getUnBuiltReleases = getUnBuiltReleases;

package/lib/steps/artifacts.d.ts

@@ -0,0 +1,11 @@
+import { NexeCompiler } from '../compiler';
+/**
+ * The artifacts step is where source patches are committed, or written as "artifacts"
+ * Steps:
+ *  - A temporary directory is created in the downloaded source
+ *  - On start, any files in that directory are restored into the source tree
+ *  - After the patch functions have run, the temporary directory is emptied
+ *  - Original versions of sources to be patched are written to the temporary directory
+ *  - Finally, The patched files are written into source.
+ */
+export default function artifacts(compiler: NexeCompiler, next: () => Promise<void>): Promise<void[]>;

package/lib/steps/artifacts.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs = __importStar(require("fs"));
+const util_1 = require("util");
+const util_2 = require("../util");
+const mkdirpAsync = require("mkdirp");
+const unlinkAsync = (0, util_1.promisify)(fs.unlink), readdirAsync = (0, util_1.promisify)(fs.readdir);
+function readDirAsync(dir) {
+    return readdirAsync(dir).then((paths) => {
+        return Promise.all(paths.map((file) => {
+            const path = (0, path_1.join)(dir, file);
+            return (0, util_2.isDirectoryAsync)(path).then((x) => (x ? readDirAsync(path) : path));
+        })).then((result) => {
+            return [].concat(...result);
+        });
+    });
+}
+function maybeReadFileContentsAsync(file) {
+    return (0, util_2.readFileAsync)(file, 'utf-8').catch((e) => {
+        if (e.code === 'ENOENT') {
+            return '';
+        }
+        throw e;
+    });
+}
+/**
+ * The artifacts step is where source patches are committed, or written as "artifacts"
+ * Steps:
+ *  - A temporary directory is created in the downloaded source
+ *  - On start, any files in that directory are restored into the source tree
+ *  - After the patch functions have run, the temporary directory is emptied
+ *  - Original versions of sources to be patched are written to the temporary directory
+ *  - Finally, The patched files are written into source.
+ */
+function artifacts(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { src } = compiler;
+        const temp = (0, path_1.join)(src, 'nexe');
+        yield mkdirpAsync(temp);
+        const tmpFiles = yield readDirAsync(temp);
+        yield Promise.all(tmpFiles.map((path) => __awaiter(this, void 0, void 0, function* () {
+            return compiler.writeFileAsync(path.replace(temp, ''), yield (0, util_2.readFileAsync)(path, 'utf-8'));
+        })));
+        yield next();
+        yield Promise.all(tmpFiles.map((x) => unlinkAsync(x)));
+        return Promise.all(compiler.files.map((file) => __awaiter(this, void 0, void 0, function* () {
+            const sourceFile = (0, path_1.join)(src, file.filename);
+            const tempFile = (0, path_1.join)(temp, file.filename);
+            const fileContents = yield maybeReadFileContentsAsync(sourceFile);
+            yield mkdirpAsync((0, path_1.dirname)(tempFile));
+            yield (0, util_2.writeFileAsync)(tempFile, fileContents);
+            yield compiler.writeFileAsync(file.filename, file.contents);
+        })));
+    });
+}
+exports.default = artifacts;

package/lib/steps/bundle.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function bundle(compiler: NexeCompiler, next: any): Promise<any>;

package/lib/steps/bundle.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const compiler_1 = require("../compiler");
+const path_1 = require("path");
+const resolve_dependencies_1 = __importStar(require("resolve-dependencies"));
+const util_1 = require("../util");
+function getStdIn(stdin) {
+    let out = '';
+    return new Promise((resolve) => {
+        stdin
+            .setEncoding('utf8')
+            .on('readable', () => {
+            let current;
+            while ((current = stdin.read())) {
+                out += current;
+            }
+        })
+            .on('end', () => resolve(out.trim()));
+        setTimeout(() => {
+            if (!out.trim()) {
+                resolve(out.trim());
+            }
+        }, 1000);
+    });
+}
+function bundle(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { bundle: doBundle, cwd, input: inputPath } = compiler.options;
+        let input = inputPath;
+        compiler.entrypoint = './' + (0, path_1.relative)(cwd, input);
+        if ((0, util_1.semverGt)(compiler.target.version, '11.99')) {
+            compiler.startup = '';
+        }
+        else {
+            compiler.startup = ';require("module").runMain();';
+        }
+        if (!doBundle) {
+            yield compiler.addResource((0, path_1.resolve)(cwd, input));
+            return next();
+        }
+        let code = '';
+        if (typeof doBundle === 'string') {
+            code = yield require(doBundle).createBundle(compiler.options);
+        }
+        if (input === util_1.STDIN_FLAG && (code = code || (0, util_1.dequote)(yield getStdIn(process.stdin)))) {
+            compiler.stdinUsed = true;
+            compiler.entrypoint = './__nexe_stdin.js';
+            yield compiler.addResource((0, path_1.resolve)(cwd, compiler.entrypoint), code);
+            return next();
+        }
+        if (input === util_1.STDIN_FLAG) {
+            const maybeInput = (0, resolve_dependencies_1.resolveSync)(cwd, '.');
+            if (!maybeInput || !maybeInput.absPath) {
+                throw new compiler_1.NexeError('No valid input detected');
+            }
+            input = maybeInput.absPath;
+            compiler.entrypoint = './' + (0, path_1.relative)(cwd, input);
+        }
+        const step = compiler.log.step('Resolving dependencies...');
+        const { files, warnings } = yield (0, resolve_dependencies_1.default)(input, ...Object.keys(compiler.bundle.list).filter((x) => x.endsWith('.js') || x.endsWith('.mjs')), { cwd, expand: 'variable', loadContent: false });
+        if (warnings.filter((x) => x.startsWith('Error parsing file') && !x.includes('node_modules')).length) {
+            throw new compiler_1.NexeError('Parsing Error:\n' + warnings.join('\n'));
+        }
+        //TODO: warnings.forEach((x) => console.log(x))
+        yield Promise.all(Object.entries(files).map(([key]) => {
+            step.log(`Including dependency: ${key}`);
+            return compiler.addResource(key);
+        }));
+        return next();
+    });
+}
+exports.default = bundle;

package/lib/steps/clean.d.ts

@@ -0,0 +1,2 @@
+import { NexeCompiler } from '../compiler';
+export default function clean(compiler: NexeCompiler, next: () => Promise<any>): Promise<any>;