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

package/lib/fs/patch.d.ts

@@ -0,0 +1,12 @@
+export interface NexeHeader {
+    blobPath: string;
+    layout: {
+        resourceStart: number;
+        resourceSize: number;
+        contentSize: number;
+        contentStart: number;
+    };
+}
+declare function shimFs(binary: NexeHeader, fs?: typeof import('fs')): void;
+declare function restoreFs(): void;
+export { shimFs, restoreFs };

package/lib/fs/patch.js

@@ -0,0 +1,122 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreFs = exports.shimFs = void 0;
+const libzip_1 = require("@yarnpkg/libzip");
+const fslib_1 = require("@yarnpkg/fslib");
+const SnapshotZipFS_1 = require("./SnapshotZipFS");
+const assert = __importStar(require("assert"));
+const constants = __importStar(require("constants"));
+const path_1 = require("path");
+let originalFsMethods = null;
+let lazyRestoreFs = () => { };
+const patches = process.nexe.patches || {};
+const originalPatches = Object.assign({}, patches);
+delete process.nexe;
+function shimFs(binary, fs = require('fs')) {
+    if (originalFsMethods !== null) {
+        return;
+    }
+    originalFsMethods = Object.assign({}, fs);
+    const realFs = Object.assign({}, fs);
+    const nodeFs = new fslib_1.NodeFS(realFs);
+    const blob = Buffer.allocUnsafe(binary.layout.resourceSize);
+    const blobFd = realFs.openSync(binary.blobPath, 'r');
+    const bytesRead = realFs.readSync(blobFd, blob, 0, binary.layout.resourceSize, binary.layout.resourceStart);
+    assert.equal(bytesRead, binary.layout.resourceSize);
+    const zipFs = new libzip_1.ZipFS(blob, { readOnly: true });
+    const snapshotZipFS = new SnapshotZipFS_1.SnapshotZipFS({
+        libzip: (0, libzip_1.getLibzipSync)(),
+        zipFs,
+        baseFs: nodeFs,
+        root: (0, path_1.dirname)(process.argv[0]),
+    });
+    const posixSnapshotZipFs = new fslib_1.PosixFS(snapshotZipFS);
+    (0, fslib_1.patchFs)(fs, posixSnapshotZipFs);
+    let log = (_) => true;
+    if ((process.env.DEBUG || '').toLowerCase().includes('nexe:require')) {
+        process.stderr.write(
+        // @ts-ignore
+        `[nexe] - FILES ${JSON.stringify(Array.from(zipFs.entries.keys()), null, 4)}\n`);
+        process.stderr.write(
+        // @ts-ignore
+        `[nexe] - DIRECTORIES ${JSON.stringify(Array.from(zipFs.listings.keys()), null, 4)}\n`);
+        log = (text) => {
+            return process.stderr.write(`[nexe] - ${text}\n`);
+        };
+    }
+    function internalModuleReadFile(original, ...args) {
+        log(`internalModuleReadFile ${args[0]}`);
+        try {
+            return posixSnapshotZipFs.readFileSync(args[0], 'utf-8');
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    if (patches.internalModuleReadFile) {
+        patches.internalModuleReadFile = internalModuleReadFile;
+    }
+    let returningArray;
+    patches.internalModuleReadJSON = function (original, ...args) {
+        if (returningArray == null)
+            returningArray = Array.isArray(original.call(this, ''));
+        const res = internalModuleReadFile.call(this, original, ...args);
+        return returningArray && !Array.isArray(res)
+            ? res === ''
+                ? []
+                : [res, /"(main|name|type|exports|imports)"/.test(res)]
+            : res;
+    };
+    patches.internalModuleStat = function (original, ...args) {
+        let statPath = args[0];
+        //in node 22, the path arg moved to arg[1]
+        if (typeof args[0] !== 'string')
+            statPath = args[1];
+        let result = 0;
+        try {
+            const stat = posixSnapshotZipFs.statSync(statPath);
+            if (stat.isDirectory())
+                result = 1;
+            else
+                result = 0;
+        }
+        catch (e) {
+            result = -constants.ENOENT;
+        }
+        log(`internalModuleStat ${result} ${statPath}`);
+        return result;
+    };
+    lazyRestoreFs = () => {
+        Object.assign(fs, originalFsMethods);
+        Object.assign(patches, originalPatches);
+        lazyRestoreFs = () => { };
+    };
+}
+exports.shimFs = shimFs;
+function restoreFs() {
+    lazyRestoreFs();
+}
+exports.restoreFs = restoreFs;

package/lib/logger.d.ts

@@ -0,0 +1,18 @@
+export interface LogStep {
+    modify(text: string, color?: string): void;
+    log(text: string, color?: string): void;
+    pause(): void;
+    resume(): void;
+}
+export declare class Logger {
+    verbose: boolean;
+    private silent;
+    private ora;
+    private modify;
+    write: (text: string, color?: string) => void;
+    constructor(level: 'verbose' | 'silent' | 'info');
+    flush(): Promise<unknown>;
+    _write(update: string, color?: string): void;
+    _modify(update: string, color?: any): void;
+    step(text: string, method?: string): LogStep;
+}

package/lib/logger.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const frameLength = 120;
+class Logger {
+    constructor(level) {
+        this.verbose = level === 'verbose';
+        this.silent = level === 'silent';
+        if (!this.silent) {
+            this.ora = (0, ora_1.default)({
+                text: 'Starting...',
+                color: 'blue',
+                spinner: 'dots',
+            });
+            this.ora.stop();
+        }
+        const noop = () => { };
+        this.modify = this.silent ? noop : this._modify.bind(this);
+        this.write = this.silent ? noop : this._write.bind(this);
+    }
+    flush() {
+        !this.silent && this.ora.succeed();
+        return new Promise((resolve) => setTimeout(resolve, frameLength));
+    }
+    _write(update, color = 'green') {
+        this.ora.succeed().text = chalk_1.default[color](update);
+        this.ora.start();
+    }
+    _modify(update, color = this.ora.color) {
+        this.ora.text = update;
+        this.ora.color = color;
+    }
+    step(text, method = 'succeed') {
+        if (this.silent) {
+            return { modify() { }, log() { }, pause() { }, resume() { } };
+        }
+        if (!this.ora.id) {
+            this.ora.start().text = text;
+            if (method !== 'succeed') {
+                this.ora[method]();
+            }
+        }
+        else {
+            this.ora[method]().text = text;
+            this.ora.start();
+        }
+        return {
+            modify: this.modify,
+            log: this.verbose ? this.write : this.modify,
+            pause: () => this.ora.stopAndPersist(),
+            resume: () => this.ora.start(),
+        };
+    }
+}
+exports.Logger = Logger;

package/lib/nexe.d.ts

@@ -0,0 +1,5 @@
+import { NexeCompiler } from './compiler';
+import { NexeOptions } from './options';
+declare function compile(compilerOptions?: Partial<NexeOptions>, callback?: (err: Error | null) => void): Promise<void>;
+export { compile, NexeCompiler };
+export { argv, version, NexeOptions, help } from './options';

package/lib/nexe.js

@@ -0,0 +1,53 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.version = exports.argv = exports.NexeCompiler = exports.compile = void 0;
+const app_builder_1 = require("app-builder");
+const compiler_1 = require("./compiler");
+Object.defineProperty(exports, "NexeCompiler", { enumerable: true, get: function () { return compiler_1.NexeCompiler; } });
+const options_1 = require("./options");
+const resource_1 = __importDefault(require("./steps/resource"));
+const clean_1 = __importDefault(require("./steps/clean"));
+const cli_1 = __importDefault(require("./steps/cli"));
+const bundle_1 = __importDefault(require("./steps/bundle"));
+const download_1 = __importDefault(require("./steps/download"));
+const shim_1 = __importDefault(require("./steps/shim"));
+const artifacts_1 = __importDefault(require("./steps/artifacts"));
+const patches_1 = __importDefault(require("./patches"));
+function compile(compilerOptions, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let error = null, options = null, compiler = null;
+        try {
+            options = (0, options_1.normalizeOptions)(compilerOptions);
+            compiler = new compiler_1.NexeCompiler(options);
+            yield (0, app_builder_1.compose)(clean_1.default, resource_1.default, cli_1.default, bundle_1.default, shim_1.default, download_1.default, options.build ? [artifacts_1.default, ...patches_1.default, ...options.patches] : [], options.plugins)(compiler);
+        }
+        catch (e) {
+            error = e;
+        }
+        if (error) {
+            compiler && compiler.quit(error);
+            if (callback)
+                return callback(error);
+            return Promise.reject(error);
+        }
+        if (callback)
+            callback(null);
+    });
+}
+exports.compile = compile;
+var options_2 = require("./options");
+Object.defineProperty(exports, "argv", { enumerable: true, get: function () { return options_2.argv; } });
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return options_2.version; } });
+Object.defineProperty(exports, "help", { enumerable: true, get: function () { return options_2.help; } });

package/lib/options.d.ts

@@ -0,0 +1,56 @@
+import parseArgv from 'minimist';
+import { NexeCompiler } from './compiler';
+import { NexeTarget } from './target';
+export declare const version = "{{ version }}";
+export interface NexePatch {
+    (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;
+}
+export interface NexeOptions {
+    build: boolean;
+    input: string;
+    output: string;
+    targets: (string | NexeTarget)[];
+    name: string;
+    remote: string;
+    asset: string;
+    cwd: 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)[];
+    plugins: (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;
+    clean?: boolean;
+    /**
+     * Api Only
+     */
+    downloadOptions: any;
+}
+declare const argv: parseArgv.ParsedArgs;
+declare let help: string;
+export declare function resolveEntry(input: string, cwd: string, maybeEntry: string | undefined, bundle: boolean | string): string;
+declare function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions;
+export { argv, normalizeOptions, help };

package/lib/options.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = exports.normalizeOptions = exports.argv = exports.resolveEntry = exports.version = void 0;
+const minimist_1 = __importDefault(require("minimist"));
+const compiler_1 = require("./compiler");
+const util_1 = require("./util");
+const path_1 = require("path");
+const target_1 = require("./target");
+const os_1 = require("os");
+const chalk_1 = __importDefault(require("chalk"));
+const resolve_dependencies_1 = require("resolve-dependencies");
+const caw = require('caw');
+const c = process.platform === 'win32' ? chalk_1.default.constructor({ enabled: false }) : chalk_1.default;
+exports.version = "5.0.0-beta.4";
+const defaults = {
+    flags: [],
+    cwd: process.cwd(),
+    fs: true,
+    configure: [],
+    mangle: true,
+    make: [],
+    targets: [],
+    vcBuild: util_1.isWindows ? ['nosign', 'release'] : [],
+    enableNodeCli: false,
+    build: false,
+    bundle: true,
+    patches: [],
+    plugins: [],
+    remote: 'https://github.com/nexe/nexe/releases/download/v3.3.3/',
+};
+const alias = {
+    i: 'input',
+    o: 'output',
+    v: 'version',
+    a: 'asset',
+    t: 'target',
+    b: 'build',
+    n: 'name',
+    r: 'resource',
+    p: 'python',
+    f: 'flag',
+    c: 'configure',
+    m: 'make',
+    h: 'help',
+    l: 'loglevel',
+    'fake-argv': 'fakeArgv',
+    'gh-token': 'ghToken',
+};
+const argv = (0, minimist_1.default)(process.argv, { alias, default: Object.assign({}, defaults) });
+exports.argv = argv;
+let help = `
+${c.bold('nexe <entry-file> [options]')}
+
+   ${c.underline.bold('Options:')}
+
+  -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 files (glob) within the binary
+       --remote                     -- alternate location (URL) to download pre-built base (nexe) binaries from
+       --plugin                     -- extend nexe runtime behavior
+
+   ${c.underline.bold('Building from source:')}
+
+  -b   --build                      -- build from source
+  -p   --python                     -- python3 (as python) executable path
+  -f   --flag                       -- *v8 flags to include during compilation
+  -c   --configure                  -- *arguments to the configure step
+  -m   --make                       -- *arguments to the make/build step
+       --patch                      -- module with middleware default export for adding a build patch
+       --no-mangle                  -- used when generating base binaries, or when patching _third_party_main manually
+       --snapshot                   -- path to a warmup snapshot
+       --ico                        -- file name for alternate icon file (windows)
+       --rc-*                       -- populate rc file options (windows)
+       --sourceUrl                  -- pass an alternate source (node.tar.gz) url
+       --enableNodeCli              -- enable node cli enforcement (blocks app cli)
+
+   ${c.underline.bold('Other options:')}
+
+       --bundle                     -- custom bundling module with 'createBundle' export
+       --temp                       -- temp file storage default '~/.nexe'
+       --cwd                        -- set the current working directory for the command
+       --fake-argv                  -- fake argv[1] with entry file
+       --clean                      -- force download of sources
+       --silent                     -- disable logging
+       --verbose                    -- set logging to verbose
+
+       -* variable key name         * option can be used more than once`.trim();
+exports.help = help;
+exports.help = help = os_1.EOL + help + os_1.EOL;
+function flatten(...args) {
+    return [].concat(...args).filter((x) => x);
+}
+/**
+ * Extract keys such as { "rc-CompanyName": "Node.js" } to
+ * { CompanyName: "Node.js" }
+ * @param {*} match
+ * @param {*} options
+ */
+function extractCliMap(match, options) {
+    return Object.keys(options)
+        .filter((x) => match.test(x))
+        .reduce((map, option) => {
+        const key = option.split('-')[1];
+        map[key] = options[option];
+        delete options[option];
+        return map;
+    }, {});
+}
+function extractLogLevel(options) {
+    if (options.loglevel)
+        return options.loglevel;
+    if (options.silent)
+        return 'silent';
+    if (options.verbose)
+        return 'verbose';
+    return 'info';
+}
+function isName(name) {
+    return name && name !== 'index' && name !== util_1.STDIN_FLAG;
+}
+function extractName(options) {
+    let name = options.name;
+    //try and use the input filename as the output filename if its not index
+    if (!isName(name) && typeof options.input === 'string') {
+        name = (0, path_1.basename)(options.input).replace((0, path_1.extname)(options.input), '');
+    }
+    //try and use the directory as the filename
+    if (!isName(name) && (0, path_1.basename)(options.cwd)) {
+        name = (0, path_1.basename)(options.cwd);
+    }
+    return name.replace(/\.exe$/, '');
+}
+function padRelative(input) {
+    let prefix = '';
+    if (!input.startsWith('.')) {
+        prefix = './';
+    }
+    return prefix + input;
+}
+function isEntryFile(filename) {
+    return Boolean(filename && !(0, path_1.isAbsolute)(filename));
+}
+function resolveEntry(input, cwd, maybeEntry, bundle) {
+    let result = null;
+    if (input === '-' || maybeEntry === '-') {
+        return util_1.STDIN_FLAG;
+    }
+    if (input && (0, path_1.isAbsolute)(input)) {
+        return input;
+    }
+    if (input) {
+        const inputPath = padRelative(input);
+        result = (0, resolve_dependencies_1.resolveSync)(cwd, inputPath);
+    }
+    if (isEntryFile(maybeEntry) && (!result || !result.absPath)) {
+        const inputPath = padRelative(maybeEntry);
+        result = (0, resolve_dependencies_1.resolveSync)(cwd, inputPath);
+    }
+    if (!process.stdin.isTTY && (!result || !result.absPath) && bundle === defaults.bundle) {
+        return util_1.STDIN_FLAG;
+    }
+    if (!result || !result.absPath) {
+        result = (0, resolve_dependencies_1.resolveSync)(cwd, '.');
+    }
+    if (!result.absPath) {
+        throw new compiler_1.NexeError(`Entry file "${input || ''}" not found!`);
+    }
+    return result.absPath;
+}
+exports.resolveEntry = resolveEntry;
+function isCli(options) {
+    return argv === options;
+}
+function normalizeOptions(input) {
+    const options = Object.assign({}, defaults, input);
+    const opts = options;
+    const cwd = (options.cwd = (0, path_1.resolve)(options.cwd));
+    options.temp = options.temp
+        ? (0, path_1.resolve)(cwd, options.temp)
+        : process.env.NEXE_TEMP || (0, path_1.join)((0, os_1.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 === util_1.STDIN_FLAG;
+    options.name = extractName(options);
+    options.loglevel = extractLogLevel(options);
+    options.flags = flatten(opts.flag, options.flags);
+    options.targets = flatten(opts.target, options.targets).map(target_1.getTarget);
+    if (!options.targets.length) {
+        options.targets.push((0, target_1.getTarget)());
+    }
+    options.ghToken = options.ghToken || process.env.GITHUB_TOKEN || '';
+    options.make = flatten(util_1.isWindows ? options.vcBuild : options.make);
+    options.configure = flatten(options.configure);
+    options.resources = flatten(opts.resource, options.resources);
+    if (!options.remote.endsWith('/')) {
+        options.remote += '/';
+    }
+    options.downloadOptions = options.downloadOptions || {};
+    options.downloadOptions.headers = options.downloadOptions.headers || {};
+    options.downloadOptions.headers['User-Agent'] = 'nexe (https://www.npmjs.com/package/nexe)';
+    options.downloadOptions.agent = process.env.HTTPS_PROXY
+        ? caw(process.env.HTTPS_PROXY, { protocol: 'https' })
+        : options.downloadOptions.agent || require('https').globalAgent;
+    options.downloadOptions.rejectUnauthorized = process.env.NODE_TLS_REJECT_UNAUTHORIZED
+        ? false
+        : true;
+    options.rc = options.rc || extractCliMap(/^rc-.*/, options);
+    options.output =
+        options.targets[0].platform === 'windows'
+            ? `${(options.output || options.name).replace(/\.exe$/, '')}.exe`
+            : `${options.output || options.name}`;
+    options.output = (0, path_1.resolve)(cwd, options.output);
+    const requireDefault = (x) => {
+        if (typeof x === 'string') {
+            return require(x).default;
+        }
+        return x;
+    };
+    options.mangle = 'mangle' in opts ? opts.mangle : true;
+    options.plugins = flatten(opts.plugin, options.plugins).map(requireDefault);
+    options.patches = flatten(opts.patch, options.patches).map(requireDefault);
+    if ((!options.mangle && !options.bundle) || options.patches.length) {
+        options.build = true;
+    }
+    if (options.build) {
+        const { arch } = options.targets[0];
+        if (util_1.isWindows) {
+            options.make = Array.from(new Set(options.make.concat(arch)));
+        }
+        else {
+            options.configure = Array.from(new Set(options.configure.concat([`--dest-cpu=${arch}`])));
+        }
+    }
+    Object.keys(alias)
+        .filter((k) => k !== 'rc')
+        .forEach((x) => delete opts[x]);
+    return options;
+}
+exports.normalizeOptions = normalizeOptions;

package/lib/patches/boot-nexe.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+declare const fs: any, fd: any, stat: any, tailSize: number, tailWindow: Buffer;
+declare const footerPosition: number;
+declare const footer: Buffer, contentSize: number, resourceSize: number, contentStart: number, resourceStart: number;
+declare const contentBuffer: Buffer, Module: any;

package/lib/patches/boot-nexe.js

@@ -0,0 +1,38 @@
+"use strict";
+const 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));
+fs.readSync(fd, tailWindow, 0, tailSize, stat.size - tailSize);
+const footerPosition = tailWindow.indexOf('<nexe~~sentinel>');
+if (footerPosition == -1) {
+    throw 'Invalid Nexe binary';
+}
+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 = null;
+    return {
+        get: function () {
+            return nexeHeader;
+        },
+        set: function (value) {
+            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)), Module = require('module');
+fs.readSync(fd, contentBuffer, 0, contentSize, contentStart);
+fs.closeSync(fd);
+new Module(process.execPath, null)._compile(contentBuffer.toString(), process.execPath);

package/lib/patches/build-fixes.d.ts

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

package/lib/patches/build-fixes.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 buildFixes(compiler, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!compiler.target.version.startsWith('8.2')) {
+            return next();
+        }
+        const file = yield compiler.readFileAsync('./tools/msvs/find_python.cmd');
+        yield compiler.replaceInFileAsync('./tools/msvs/find_python.cmd', '%p%python.exe -V 2>&1', '"%p%python.exe" -V 2>&1');
+        return next();
+    });
+}
+exports.default = buildFixes;

package/lib/patches/disable-node-cli.d.ts

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