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

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013-2018 Nexe Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# @depup/nexe
+
+> Dependency-bumped version of [nexe](https://www.npmjs.com/package/nexe)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/nexe
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [nexe](https://www.npmjs.com/package/nexe) @ 5.0.0-beta.4 |
+| Processed | 2026-03-17 |
+| Smoke test | failed |
+| Deps updated | 10 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| @yarnpkg/fslib | ^3.0.0-rc.43 | ^3.1.4 |
+| @yarnpkg/libzip | ^3.0.0-rc.43 | ^3.2.2 |
+| archiver | ^5.3.1 | ^7.0.1 |
+| chalk | ^2.4.2 | ^5.6.2 |
+| globby | ^11.0.2 | ^16.1.1 |
+| got | ^12.6.0 | ^14.6.6 |
+| meriyah | ^4.3.5 | ^7.1.0 |
+| mkdirp | ^1.0.4 | ^3.0.1 |
+| ora | ^3.4.0 | ^9.3.0 |
+| rimraf | ^3.0.2 | ^6.1.3 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/nexe
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,46 @@
+{
+  "bumped": {
+    "@yarnpkg/fslib": {
+      "from": "^3.0.0-rc.43",
+      "to": "^3.1.4"
+    },
+    "@yarnpkg/libzip": {
+      "from": "^3.0.0-rc.43",
+      "to": "^3.2.2"
+    },
+    "archiver": {
+      "from": "^5.3.1",
+      "to": "^7.0.1"
+    },
+    "chalk": {
+      "from": "^2.4.2",
+      "to": "^5.6.2"
+    },
+    "globby": {
+      "from": "^11.0.2",
+      "to": "^16.1.1"
+    },
+    "got": {
+      "from": "^12.6.0",
+      "to": "^14.6.6"
+    },
+    "meriyah": {
+      "from": "^4.3.5",
+      "to": "^7.1.0"
+    },
+    "mkdirp": {
+      "from": "^1.0.4",
+      "to": "^3.0.1"
+    },
+    "ora": {
+      "from": "^3.4.0",
+      "to": "^9.3.0"
+    },
+    "rimraf": {
+      "from": "^3.0.2",
+      "to": "^6.1.3"
+    }
+  },
+  "timestamp": "2026-03-17T19:30:12.638Z",
+  "totalUpdated": 10
+}

package/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+const options = require('./lib/options')
+if (require.main === module) {
+  //fast path for help/version
+  const argv = options.argv
+  const eol = require('os').EOL
+  const showHelp = argv.help || argv._.some(x => x === 'help')
+  const showVersion = argv.version || argv._.some(x => x === 'version')
+  if (showHelp || showVersion) {    
+    process.stderr.write(showHelp ? options.help : options.version + eol)
+  } else {
+    const nexe = require('./lib/nexe')
+    nexe.compile(argv).catch((error) => {
+      const NexeError = require('./lib/compiler').NexeError
+      const chalk = require('chalk')
+      const isSilent = Boolean(argv.silent === true || argv.loglevel === 'silent')
+      if (!isSilent) {
+        if (error instanceof NexeError) {
+          process.stderr.write(eol + chalk.red('Error: ') + error.message + eol
+            + eol + 'See nexe -h for usage..' + eol + eol
+          )
+        } else {
+          process.stderr.write(error.stack + eol)
+        }
+      }
+
+      process.exit(1)
+    })
+  }
+} else {
+  module.exports = require('./lib/nexe')
+}

package/lib/compiler.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+import { ReadStream } from 'fs';
+import { Logger } from './logger';
+import { NexeOptions } from './options';
+import { NexeTarget } from './target';
+import { Readable } from 'stream';
+import { Bundle } from './fs/bundle';
+import { File } from 'resolve-dependencies';
+type StringReplacer = (match: string) => string;
+export interface NexeFile {
+    filename: string;
+    absPath: string;
+    contents: string | Buffer;
+}
+export { NexeOptions };
+export declare class NexeError extends Error {
+    constructor(m: string);
+}
+export declare class NexeCompiler {
+    options: NexeOptions;
+    /**
+     * Epoch of when compilation started
+     */
+    private start;
+    private compileStep;
+    log: Logger;
+    /**
+     * Copy of process.env
+     */
+    env: {
+        [x: string]: string | undefined;
+        TZ?: string | undefined;
+    };
+    /**
+     * Virtual FileSystem
+     */
+    bundle: Bundle;
+    /**
+     * Root directory for the source of the current build
+     */
+    src: string;
+    /**
+     * In memory files that are being manipulated by the compiler
+     */
+    files: NexeFile[];
+    /**
+     * Standalone pieces of code run before the application entrypoint
+     */
+    shims: string[];
+    /**
+     * The last shim (defaults to "require('module').runMain()")
+     */
+    startup: string;
+    /**
+     * The main entrypoint filename for your application - eg. node mainFile.js
+     */
+    entrypoint: string | undefined;
+    /**
+     * Not used
+     */
+    targets: NexeTarget[];
+    /**
+     * Current target of the compiler
+     */
+    target: NexeTarget;
+    /**
+     * Output filename (-o myapp.exe)
+     */
+    output: string;
+    /**
+     * Flag to indicate whether or notstdin was used for input
+     */
+    stdinUsed: boolean;
+    /**
+     * Path to the configure script
+     */
+    configureScript: string;
+    /**
+     * The file path of node binary
+     */
+    nodeSrcBinPath: string;
+    /**
+     * Remote asset path if available
+     */
+    remoteAsset: string;
+    constructor(options: NexeOptions);
+    addResource(absoluteFileName: string, content?: Buffer | string | File): void;
+    readFileAsync(file: string): Promise<NexeFile>;
+    writeFileAsync(file: string, contents: string | Buffer): Promise<void>;
+    replaceInFileAsync(file: string, replace: string | RegExp, value: string | StringReplacer): Promise<void>;
+    setFileContentsAsync(file: string, contents: string | Buffer): Promise<void>;
+    quit(error?: any): Promise<unknown>;
+    assertBuild(): void;
+    getNodeExecutableLocation(target?: NexeTarget): string;
+    private _runBuildCommandAsync;
+    private _configureAsync;
+    build(): Promise<ReadStream>;
+    private _shouldCompileBinaryAsync;
+    compileAsync(target: NexeTarget): Promise<Readable>;
+    code(): string;
+    private _assembleDeliverable;
+}

package/lib/compiler.js

@@ -0,0 +1,289 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.NexeCompiler = exports.NexeError = void 0;
+const path_1 = require("path");
+const buffer_1 = require("buffer");
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const logger_1 = require("./logger");
+const util_1 = require("./util");
+const options_1 = require("./options");
+const stream_1 = require("stream");
+const MultiStream = require("multistream");
+const bundle_1 = require("./fs/bundle");
+const isBsd = Boolean(~process.platform.indexOf('bsd'));
+const make = util_1.isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make';
+const configure = util_1.isWindows ? 'configure' : './configure';
+class NexeError extends Error {
+    constructor(m) {
+        super(m);
+        Object.setPrototypeOf(this, NexeError.prototype);
+    }
+}
+exports.NexeError = NexeError;
+class NexeCompiler {
+    constructor(options) {
+        this.options = options;
+        /**
+         * Epoch of when compilation started
+         */
+        this.start = Date.now();
+        this.log = new logger_1.Logger(this.options.loglevel);
+        /**
+         * Copy of process.env
+         */
+        this.env = Object.assign({}, process.env);
+        /**
+         * In memory files that are being manipulated by the compiler
+         */
+        this.files = [];
+        /**
+         * Standalone pieces of code run before the application entrypoint
+         */
+        this.shims = [];
+        /**
+         * The last shim (defaults to "require('module').runMain()")
+         */
+        this.startup = '';
+        /**
+         * Output filename (-o myapp.exe)
+         */
+        this.output = this.options.output;
+        /**
+         * Flag to indicate whether or notstdin was used for input
+         */
+        this.stdinUsed = false;
+        const { python } = (this.options = options);
+        //SOMEDAY iterate over multiple targets with `--outDir`
+        this.targets = options.targets;
+        this.target = this.targets[0];
+        if (!/https?\:\/\//.test(options.remote)) {
+            throw new NexeError(`Invalid remote URI scheme (must be http or https): ${options.remote}`);
+        }
+        this.remoteAsset = options.remote + this.target.toString();
+        this.src = (0, path_1.join)(this.options.temp, this.target.version);
+        this.configureScript = configure + ((0, util_1.semverGt)(this.target.version, '10.10.0') ? '.py' : '');
+        this.nodeSrcBinPath = util_1.isWindows
+            ? (0, path_1.join)(this.src, 'Release', 'node.exe')
+            : (0, path_1.join)(this.src, 'out', 'Release', 'node');
+        this.log.step('nexe ' + options_1.version, 'info');
+        this.bundle = new bundle_1.Bundle(options);
+        if (util_1.isWindows) {
+            const originalPath = process.env.PATH;
+            delete process.env.PATH;
+            this.env = Object.assign({}, process.env);
+            this.env.PATH = python
+                ? (this.env.PATH = (0, util_1.dequote)((0, path_1.normalize)(python)) + path_1.delimiter + originalPath)
+                : originalPath;
+            process.env.PATH = originalPath;
+        }
+        else {
+            this.env = Object.assign({}, process.env);
+            python && (this.env.PYTHON = python);
+        }
+    }
+    addResource(absoluteFileName, content) {
+        return this.bundle.addResource(absoluteFileName, content);
+    }
+    readFileAsync(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertBuild();
+            let cachedFile = this.files.find((x) => (0, path_1.normalize)(x.filename) === (0, path_1.normalize)(file));
+            if (!cachedFile) {
+                const absPath = (0, path_1.join)(this.src, file);
+                cachedFile = {
+                    absPath,
+                    filename: file,
+                    contents: yield (0, util_1.readFileAsync)(absPath, 'utf-8').catch((x) => {
+                        if (x.code === 'ENOENT')
+                            return '';
+                        throw x;
+                    }),
+                };
+                this.files.push(cachedFile);
+            }
+            return cachedFile;
+        });
+    }
+    writeFileAsync(file, contents) {
+        this.assertBuild();
+        return (0, util_1.writeFileAsync)((0, path_1.join)(this.src, file), contents);
+    }
+    replaceInFileAsync(file, replace, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entry = yield this.readFileAsync(file);
+            entry.contents = entry.contents.toString().replace(replace, value);
+        });
+    }
+    setFileContentsAsync(file, contents) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entry = yield this.readFileAsync(file);
+            entry.contents = contents;
+        });
+    }
+    quit(error) {
+        const time = Date.now() - this.start;
+        this.log.write(`Finished in ${time / 1000}s`, error ? 'red' : 'green');
+        return this.log.flush();
+    }
+    assertBuild() {
+        if (!this.options.build) {
+            throw new NexeError('This feature is only available with `--build`');
+        }
+    }
+    getNodeExecutableLocation(target) {
+        if (this.options.asset) {
+            return (0, path_1.resolve)(this.options.cwd, this.options.asset);
+        }
+        if (target) {
+            return (0, path_1.join)(this.options.temp, target.toString());
+        }
+        return this.nodeSrcBinPath;
+    }
+    _runBuildCommandAsync(command, args) {
+        if (this.log.verbose) {
+            this.compileStep.pause();
+        }
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.spawn)(command, args, {
+                cwd: this.src,
+                env: this.env,
+                shell: true,
+                stdio: this.log.verbose ? 'inherit' : 'ignore',
+            })
+                .once('error', (e) => {
+                if (this.log.verbose) {
+                    this.compileStep.resume();
+                }
+                reject(e);
+            })
+                .once('close', (code) => {
+                if (this.log.verbose) {
+                    this.compileStep.resume();
+                }
+                if (code != 0) {
+                    const error = `${command} ${args.join(' ')} exited with code: ${code}`;
+                    reject(new NexeError(error));
+                }
+                resolve();
+            });
+        });
+    }
+    _configureAsync() {
+        if (util_1.isWindows && (0, util_1.semverGt)(this.target.version, '10.15.99')) {
+            return Promise.resolve();
+        }
+        return this._runBuildCommandAsync(this.env.PYTHON || 'python', [
+            this.configureScript,
+            ...this.options.configure,
+        ]);
+    }
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.compileStep.log(`Configuring node build${this.options.configure.length ? ': ' + this.options.configure : '...'}`);
+            yield this._configureAsync();
+            const buildOptions = this.options.make;
+            this.compileStep.log(`Compiling Node${buildOptions.length ? ' with arguments: ' + buildOptions : '...'}`);
+            yield this._runBuildCommandAsync(make, buildOptions);
+            return (0, fs_1.createReadStream)(this.getNodeExecutableLocation());
+        });
+    }
+    _shouldCompileBinaryAsync(binary, location) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //SOMEDAY combine make/configure/vcBuild/and modified times of included files
+            const { snapshot, build } = this.options;
+            if (!binary) {
+                return true;
+            }
+            if (build && snapshot != null && (yield (0, util_1.pathExistsAsync)(snapshot))) {
+                const snapshotLastModified = (yield (0, util_1.statAsync)(snapshot)).mtimeMs;
+                const binaryLastModified = (yield (0, util_1.statAsync)(location)).mtimeMs;
+                return snapshotLastModified > binaryLastModified;
+            }
+            return false;
+        });
+    }
+    compileAsync(target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const step = (this.compileStep = this.log.step('Compiling result'));
+            const build = this.options.build;
+            const location = this.getNodeExecutableLocation(build ? undefined : target);
+            let binary = (yield (0, util_1.pathExistsAsync)(location)) ? (0, fs_1.createReadStream)(location) : null;
+            if (yield this._shouldCompileBinaryAsync(binary, location)) {
+                binary = yield this.build();
+                step.log('Node binary compiled');
+            }
+            return this._assembleDeliverable(binary);
+        });
+    }
+    code() {
+        return [this.shims.join(''), this.startup].join(';');
+    }
+    _assembleDeliverable(binary) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.options.mangle) {
+                return binary;
+            }
+            const launchCode = this.code();
+            const codeSize = buffer_1.Buffer.byteLength(launchCode);
+            const sentinel = buffer_1.Buffer.from('<nexe~~sentinel>');
+            let vfsSize = 0;
+            const streams = [
+                binary,
+                (0, bundle_1.toStream)(launchCode),
+                this.bundle.toStream().pipe(new stream_1.Transform({
+                    transform: (chunk, _, cb) => {
+                        vfsSize || this.bundle.finalize();
+                        chunk && (vfsSize += chunk.length);
+                        cb(null, chunk);
+                    },
+                })),
+            ];
+            let done = false;
+            return new MultiStream((cb) => {
+                if (done)
+                    cb(null, null);
+                else if (streams.length)
+                    cb(null, streams.shift());
+                else {
+                    done = true;
+                    const trailers = buffer_1.Buffer.alloc(16);
+                    trailers.writeDoubleLE(codeSize, 0);
+                    trailers.writeDoubleLE(vfsSize, 8);
+                    cb(null, (0, bundle_1.toStream)(buffer_1.Buffer.concat([sentinel, trailers])));
+                }
+            });
+        });
+    }
+}
+__decorate([
+    util_1.bound
+], NexeCompiler.prototype, "addResource", null);
+__decorate([
+    util_1.bound
+], NexeCompiler.prototype, "readFileAsync", null);
+__decorate([
+    util_1.bound
+], NexeCompiler.prototype, "writeFileAsync", null);
+__decorate([
+    util_1.bound
+], NexeCompiler.prototype, "replaceInFileAsync", null);
+__decorate([
+    util_1.bound
+], NexeCompiler.prototype, "setFileContentsAsync", null);
+exports.NexeCompiler = NexeCompiler;

package/lib/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`