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

package/lib/fs/SnapshotZipFS.d.ts

@@ -0,0 +1,228 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Libzip } from '@yarnpkg/libzip';
+import { FakeFS, PortablePath, RmdirOptions, OpendirOptions, BasePortableFakeFS, Dirent, MkdirOptions, FSPath, Filename, CustomDir } from '@yarnpkg/fslib';
+import { ZipFS } from '@yarnpkg/libzip';
+export type SnapshotZipFSOptions = {
+    baseFs: FakeFS<PortablePath>;
+    libzip: Libzip | (() => Libzip);
+    zipFs: ZipFS;
+    root: string;
+};
+export declare class SnapshotZipFS extends BasePortableFakeFS {
+    zipFs: ZipFS;
+    baseFs: FakeFS<PortablePath>;
+    root: string;
+    magic: number;
+    constructor(opts: SnapshotZipFSOptions);
+    private readonly fdMap;
+    private nextFd;
+    makeCallPromise<T>(p: FSPath<PortablePath>, discard: () => Promise<T>, accept: (zipFS: ZipFS, zipInfo: {
+        subPath: PortablePath;
+    }) => Promise<T>, { requireSubpath }?: {
+        requireSubpath?: boolean;
+    }): Promise<T>;
+    makeCallSync<T>(p: FSPath<PortablePath>, discard: () => T, accept: (zipFS: ZipFS, zipInfo: {
+        subPath: PortablePath;
+        archivePath: string;
+    }) => T, { requireSubpath }?: {
+        requireSubpath?: boolean;
+    }): T;
+    realpathPromise(p: PortablePath): Promise<PortablePath>;
+    realpathSync(p: PortablePath): PortablePath;
+    findZip(p: PortablePath): {
+        subPath: PortablePath;
+    } | undefined;
+    copyFilePromise(sourceP: PortablePath, destP: PortablePath, flags?: number): Promise<void>;
+    copyFileSync(sourceP: PortablePath, destP: PortablePath, flags?: number): void;
+    readdirPromise(p: PortablePath): Promise<Array<Filename>>;
+    readdirPromise(p: PortablePath, opts: {
+        withFileTypes: false;
+    } | null): Promise<Array<Filename>>;
+    readdirPromise(p: PortablePath, opts: {
+        withFileTypes: true;
+    }): Promise<Array<Dirent>>;
+    readdirPromise(p: PortablePath, opts: {
+        withFileTypes: boolean;
+    }): Promise<Array<Filename> | Array<Dirent>>;
+    readdirSync(p: PortablePath): Array<Filename>;
+    readdirSync(p: PortablePath, opts: {
+        withFileTypes: false;
+    } | null): Array<Filename>;
+    readdirSync(p: PortablePath, opts: {
+        withFileTypes: true;
+    }): Array<Dirent>;
+    readdirSync(p: PortablePath, opts: {
+        withFileTypes: boolean;
+    }): Array<Filename> | Array<Dirent>;
+    mkdirPromise(p: PortablePath, opts?: MkdirOptions): Promise<string | undefined>;
+    mkdirSync(p: PortablePath, opts?: MkdirOptions): string | undefined;
+    rmdirPromise(p: PortablePath, opts?: RmdirOptions): Promise<void>;
+    rmdirSync(p: PortablePath, opts?: RmdirOptions): void;
+    opendirPromise(p: PortablePath, opts?: OpendirOptions): Promise<CustomDir<PortablePath>>;
+    opendirSync(p: PortablePath, opts?: OpendirOptions): CustomDir<PortablePath>;
+    accessPromise: (p: PortablePath, mode?: number | undefined) => Promise<void>;
+    accessSync: (p: PortablePath, mode?: number | undefined) => void;
+    appendFilePromise: (p: FSPath<PortablePath>, content: string | Uint8Array, opts?: import("@yarnpkg/fslib").WriteFileOptions | undefined) => Promise<void>;
+    appendFileSync: (p: FSPath<PortablePath>, content: string | Uint8Array, opts?: import("@yarnpkg/fslib").WriteFileOptions | undefined) => void;
+    chmodPromise: (p: PortablePath, mask: number) => Promise<void>;
+    chmodSync: (p: PortablePath, mask: number) => void;
+    fchmodPromise: (fd: number, mask: number) => Promise<void>;
+    fchmodSync: (fd: number, mask: number) => void;
+    chownPromise: (p: PortablePath, uid: number, gid: number) => Promise<void>;
+    chownSync: (p: PortablePath, uid: number, gid: number) => void;
+    fchownPromise: (fd: number, uid: number, gid: number) => Promise<void>;
+    fchownSync: (fd: number, uid: number, gid: number) => void;
+    closePromise: (fd: number) => Promise<void>;
+    closeSync: (fd: number) => void;
+    createReadStream: (p: PortablePath | null, opts?: Partial<{
+        encoding: BufferEncoding;
+        fd: number;
+    }> | undefined) => import("fs").ReadStream;
+    createWriteStream: (p: PortablePath | null, opts?: Partial<{
+        encoding: BufferEncoding;
+        fd: number;
+        flags: "a";
+    }> | undefined) => import("fs").WriteStream;
+    existsPromise: (p: PortablePath) => Promise<boolean>;
+    existsSync: (p: PortablePath) => boolean;
+    fstatPromise: {
+        (fd: number): Promise<import("fs").Stats>;
+        (fd: number, opts: {
+            bigint: true;
+        }): Promise<import("fs").BigIntStats>;
+        (fd: number, opts?: {
+            bigint: boolean;
+        } | undefined): Promise<import("fs").Stats | import("fs").BigIntStats>;
+    };
+    fstatSync: {
+        (fd: number): import("fs").Stats;
+        (fd: number, opts: {
+            bigint: true;
+        }): import("fs").BigIntStats;
+        (fd: number, opts?: {
+            bigint: boolean;
+        } | undefined): import("fs").Stats | import("fs").BigIntStats;
+    };
+    getExtractHint: (hints: import("@yarnpkg/fslib").ExtractHintOptions) => boolean;
+    getRealPath: () => PortablePath;
+    linkPromise: (existingP: PortablePath, newP: PortablePath) => Promise<void>;
+    linkSync: (existingP: PortablePath, newP: PortablePath) => void;
+    lstatPromise: {
+        (p: PortablePath): Promise<import("fs").Stats>;
+        (p: PortablePath, opts: (import("@yarnpkg/fslib").StatOptions & {
+            bigint?: false | undefined;
+        }) | undefined): Promise<import("fs").Stats>;
+        (p: PortablePath, opts: import("@yarnpkg/fslib").StatOptions & {
+            bigint: true;
+        }): Promise<import("fs").BigIntStats>;
+    };
+    lstatSync: {
+        (p: PortablePath): import("fs").Stats;
+        (p: PortablePath, opts?: (import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry: false;
+        }) | undefined): import("fs").Stats | undefined;
+        (p: PortablePath, opts: import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint: true;
+            throwIfNoEntry: false;
+        }): import("fs").BigIntStats | undefined;
+        (p: PortablePath, opts?: (import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint?: false | undefined;
+        }) | undefined): import("fs").Stats;
+        (p: PortablePath, opts: import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint: true;
+        }): import("fs").BigIntStats;
+        (p: PortablePath, opts: import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint: boolean;
+            throwIfNoEntry?: false | undefined;
+        }): import("fs").Stats | import("fs").BigIntStats;
+    };
+    openPromise: (p: PortablePath, flags: string, mode?: number | undefined) => Promise<number>;
+    openSync: (p: PortablePath, flags: string, mode?: number | undefined) => number;
+    readFilePromise: {
+        (p: FSPath<PortablePath>, encoding?: null | undefined): Promise<Buffer>;
+        (p: FSPath<PortablePath>, encoding: BufferEncoding): Promise<string>;
+        (p: FSPath<PortablePath>, encoding?: BufferEncoding | null | undefined): Promise<string | Buffer>;
+    };
+    readFileSync: {
+        (p: FSPath<PortablePath>, encoding?: null | undefined): Buffer;
+        (p: FSPath<PortablePath>, encoding: BufferEncoding): string;
+        (p: FSPath<PortablePath>, encoding?: BufferEncoding | null | undefined): string | Buffer;
+    };
+    readlinkPromise: (p: PortablePath) => Promise<PortablePath>;
+    readlinkSync: (p: PortablePath) => PortablePath;
+    readPromise: (fd: number, buffer: Buffer, offset: number, length: number, position: number) => Promise<number>;
+    readSync: (fd: number, buffer: Buffer, offset: number, length: number, position: number) => number;
+    renamePromise: (oldP: PortablePath, newP: PortablePath) => Promise<void>;
+    renameSync: (oldP: PortablePath, newP: PortablePath) => void;
+    resolve: (p: PortablePath) => PortablePath;
+    statPromise: {
+        (p: PortablePath): Promise<import("fs").Stats>;
+        (p: PortablePath, opts: (import("@yarnpkg/fslib").StatOptions & {
+            bigint?: false | undefined;
+        }) | undefined): Promise<import("fs").Stats>;
+        (p: PortablePath, opts: import("@yarnpkg/fslib").StatOptions & {
+            bigint: true;
+        }): Promise<import("fs").BigIntStats>;
+        (p: PortablePath, opts?: import("@yarnpkg/fslib").StatOptions | undefined): Promise<import("fs").Stats | import("fs").BigIntStats>;
+    };
+    statSync: {
+        (p: PortablePath): import("fs").Stats;
+        (p: PortablePath, opts?: (import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry: false;
+        }) | undefined): import("fs").Stats | undefined;
+        (p: PortablePath, opts: import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint: true;
+            throwIfNoEntry: false;
+        }): import("fs").BigIntStats | undefined;
+        (p: PortablePath, opts?: (import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint?: false | undefined;
+        }) | undefined): import("fs").Stats;
+        (p: PortablePath, opts: import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint: true;
+        }): import("fs").BigIntStats;
+        (p: PortablePath, opts: import("@yarnpkg/fslib").StatSyncOptions & {
+            bigint: boolean;
+            throwIfNoEntry?: false | undefined;
+        }): import("fs").Stats | import("fs").BigIntStats;
+    };
+    symlinkPromise: (target: PortablePath, p: PortablePath, type?: import("@yarnpkg/fslib").SymlinkType | undefined) => Promise<void>;
+    symlinkSync: (target: PortablePath, p: PortablePath, type?: import("@yarnpkg/fslib").SymlinkType | undefined) => void;
+    truncatePromise: (p: PortablePath, len?: number | undefined) => Promise<void>;
+    truncateSync: (p: PortablePath, len?: number | undefined) => void;
+    ftruncatePromise: (fd: number, len?: number | undefined) => Promise<void>;
+    ftruncateSync: (fd: number, len?: number | undefined) => void;
+    unlinkPromise: (p: PortablePath) => Promise<void>;
+    unlinkSync: (p: PortablePath) => void;
+    unwatchFile: (p: PortablePath, cb?: import("@yarnpkg/fslib").WatchFileCallback | undefined) => void;
+    utimesPromise: (p: PortablePath, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
+    utimesSync: (p: PortablePath, atime: string | number | Date, mtime: string | number | Date) => void;
+    lutimesPromise: (p: PortablePath, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
+    lutimesSync: (p: PortablePath, atime: string | number | Date, mtime: string | number | Date) => void;
+    watch: {
+        (p: PortablePath, cb?: import("@yarnpkg/fslib").WatchCallback | undefined): import("@yarnpkg/fslib").Watcher;
+        (p: PortablePath, opts: import("@yarnpkg/fslib").WatchOptions, cb?: import("@yarnpkg/fslib").WatchCallback | undefined): import("@yarnpkg/fslib").Watcher;
+    };
+    watchFile: {
+        (p: PortablePath, cb: import("@yarnpkg/fslib").WatchFileCallback): import("@yarnpkg/fslib").StatWatcher;
+        (p: PortablePath, opts: Partial<{
+            bigint: boolean;
+            persistent: boolean;
+            interval: number;
+        }>, cb: import("@yarnpkg/fslib").WatchFileCallback): import("@yarnpkg/fslib").StatWatcher;
+    };
+    writeFilePromise: (p: FSPath<PortablePath>, content: string | NodeJS.ArrayBufferView, opts?: import("@yarnpkg/fslib").WriteFileOptions | undefined) => Promise<void>;
+    writeFileSync: (p: FSPath<PortablePath>, content: string | NodeJS.ArrayBufferView, opts?: import("@yarnpkg/fslib").WriteFileOptions | undefined) => void;
+    writePromise: {
+        (fd: number, buffer: Buffer, offset?: number | undefined, length?: number | undefined, position?: number | undefined): Promise<number>;
+        (fd: number, buffer: string, position?: number | undefined): Promise<number>;
+    };
+    writeSync: {
+        (fd: number, buffer: Buffer, offset?: number | undefined, length?: number | undefined, position?: number | undefined): number;
+        (fd: number, buffer: string, position?: number | undefined): number;
+    };
+    remapFd: any;
+}

package/lib/fs/SnapshotZipFS.js

@@ -0,0 +1,283 @@
+"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.SnapshotZipFS = void 0;
+const fslib_1 = require("@yarnpkg/fslib");
+const libzip_1 = require("@yarnpkg/libzip");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const uniqBy = (arr, pick) => {
+    const seen = new Set();
+    return arr.filter((x) => {
+        const key = pick(x);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+};
+function uniqReaddir(arr) {
+    return uniqBy(arr, (s) => (typeof s === 'string' ? s : s.name));
+}
+class SnapshotZipFS extends fslib_1.BasePortableFakeFS {
+    constructor(opts) {
+        super();
+        this.fdMap = new Map();
+        this.nextFd = 3;
+        this.accessPromise = libzip_1.ZipOpenFS.prototype.accessPromise;
+        this.accessSync = libzip_1.ZipOpenFS.prototype.accessSync;
+        this.appendFilePromise = libzip_1.ZipOpenFS.prototype.appendFilePromise;
+        this.appendFileSync = libzip_1.ZipOpenFS.prototype.appendFileSync;
+        this.chmodPromise = libzip_1.ZipOpenFS.prototype.chmodPromise;
+        this.chmodSync = libzip_1.ZipOpenFS.prototype.chmodSync;
+        this.fchmodPromise = libzip_1.ZipOpenFS.prototype.fchmodPromise;
+        this.fchmodSync = libzip_1.ZipOpenFS.prototype.fchmodSync;
+        this.chownPromise = libzip_1.ZipOpenFS.prototype.chownPromise;
+        this.chownSync = libzip_1.ZipOpenFS.prototype.chownSync;
+        this.fchownPromise = libzip_1.ZipOpenFS.prototype.fchownPromise;
+        this.fchownSync = libzip_1.ZipOpenFS.prototype.fchownSync;
+        this.closePromise = libzip_1.ZipOpenFS.prototype.closePromise;
+        this.closeSync = libzip_1.ZipOpenFS.prototype.closeSync;
+        this.createReadStream = libzip_1.ZipOpenFS.prototype.createReadStream;
+        this.createWriteStream = libzip_1.ZipOpenFS.prototype.createWriteStream;
+        this.existsPromise = libzip_1.ZipOpenFS.prototype.existsPromise;
+        this.existsSync = libzip_1.ZipOpenFS.prototype.existsSync;
+        this.fstatPromise = libzip_1.ZipOpenFS.prototype.fstatPromise;
+        this.fstatSync = libzip_1.ZipOpenFS.prototype.fstatSync;
+        this.getExtractHint = libzip_1.ZipOpenFS.prototype.getExtractHint;
+        this.getRealPath = libzip_1.ZipOpenFS.prototype.getRealPath;
+        this.linkPromise = libzip_1.ZipOpenFS.prototype.linkPromise;
+        this.linkSync = libzip_1.ZipOpenFS.prototype.linkSync;
+        this.lstatPromise = libzip_1.ZipOpenFS.prototype.lstatPromise;
+        this.lstatSync = libzip_1.ZipOpenFS.prototype.lstatSync;
+        this.openPromise = libzip_1.ZipOpenFS.prototype.openPromise;
+        this.openSync = libzip_1.ZipOpenFS.prototype.openSync;
+        this.readFilePromise = libzip_1.ZipOpenFS.prototype.readFilePromise;
+        this.readFileSync = libzip_1.ZipOpenFS.prototype.readFileSync;
+        this.readlinkPromise = libzip_1.ZipOpenFS.prototype.readlinkPromise;
+        this.readlinkSync = libzip_1.ZipOpenFS.prototype.readlinkSync;
+        this.readPromise = libzip_1.ZipOpenFS.prototype.readPromise;
+        this.readSync = libzip_1.ZipOpenFS.prototype.readSync;
+        this.renamePromise = libzip_1.ZipOpenFS.prototype.renamePromise;
+        this.renameSync = libzip_1.ZipOpenFS.prototype.renameSync;
+        this.resolve = libzip_1.ZipOpenFS.prototype.resolve;
+        this.statPromise = libzip_1.ZipOpenFS.prototype.statPromise;
+        this.statSync = libzip_1.ZipOpenFS.prototype.statSync;
+        this.symlinkPromise = libzip_1.ZipOpenFS.prototype.symlinkPromise;
+        this.symlinkSync = libzip_1.ZipOpenFS.prototype.symlinkSync;
+        this.truncatePromise = libzip_1.ZipOpenFS.prototype.truncatePromise;
+        this.truncateSync = libzip_1.ZipOpenFS.prototype.truncateSync;
+        this.ftruncatePromise = libzip_1.ZipOpenFS.prototype.ftruncatePromise;
+        this.ftruncateSync = libzip_1.ZipOpenFS.prototype.ftruncateSync;
+        this.unlinkPromise = libzip_1.ZipOpenFS.prototype.unlinkPromise;
+        this.unlinkSync = libzip_1.ZipOpenFS.prototype.unlinkSync;
+        this.unwatchFile = libzip_1.ZipOpenFS.prototype.unwatchFile;
+        this.utimesPromise = libzip_1.ZipOpenFS.prototype.utimesPromise;
+        this.utimesSync = libzip_1.ZipOpenFS.prototype.utimesSync;
+        this.lutimesPromise = libzip_1.ZipOpenFS.prototype.utimesPromise;
+        this.lutimesSync = libzip_1.ZipOpenFS.prototype.utimesSync;
+        this.watch = libzip_1.ZipOpenFS.prototype.watch;
+        this.watchFile = libzip_1.ZipOpenFS.prototype.watchFile;
+        this.writeFilePromise = libzip_1.ZipOpenFS.prototype.writeFilePromise;
+        this.writeFileSync = libzip_1.ZipOpenFS.prototype.writeFileSync;
+        this.writePromise = libzip_1.ZipOpenFS.prototype.writePromise;
+        this.writeSync = libzip_1.ZipOpenFS.prototype.writeSync;
+        // @ts-ignore
+        this.remapFd = libzip_1.ZipOpenFS.prototype.remapFd;
+        this.zipFs = opts.zipFs;
+        this.baseFs = opts.baseFs;
+        this.root = opts.root;
+        this.magic = 0x2a << 24;
+    }
+    makeCallPromise(p, discard, accept, { requireSubpath = true } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof p !== 'string')
+                return yield discard();
+            const normalizedP = this.resolve(p);
+            const zipInfo = this.findZip(normalizedP);
+            if (!zipInfo)
+                return yield discard();
+            if (requireSubpath && zipInfo.subPath === '/')
+                return yield discard();
+            return yield accept(this.zipFs, zipInfo);
+        });
+    }
+    makeCallSync(p, discard, accept, { requireSubpath = true } = {}) {
+        if (typeof p !== 'string')
+            return discard();
+        const normalizedP = this.resolve(p);
+        const zipInfo = this.findZip(normalizedP);
+        if (!zipInfo)
+            return discard();
+        if (requireSubpath && zipInfo.subPath === '/')
+            return discard();
+        return accept(this.zipFs, Object.assign({ archivePath: '' }, zipInfo));
+    }
+    realpathPromise(p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.realpathSync(p);
+        });
+    }
+    realpathSync(p) {
+        return this.makeCallSync(p, () => this.baseFs.realpathSync(p), (zipFs, { subPath }) => {
+            if (zipFs.lstatSync(subPath).isSymbolicLink()) {
+                return zipFs.realpathSync(subPath);
+            }
+            else {
+                // return the original path in case it wasn't under /snapshot, e.g. if it was for a node module - otherwise the node module parent path is the wrong one (and other things resolve relative to that)
+                return p;
+            }
+        });
+    }
+    findZip(p) {
+        p = this.resolve(p);
+        const snapshotPP = fslib_1.npath.toPortablePath('/snapshot');
+        const pathsToTry = Array.from(new Set([
+            p,
+            (0, path_1.resolve)('/snapshot', p),
+            fslib_1.ppath.resolve(snapshotPP, fslib_1.npath.toPortablePath(fslib_1.npath.relative(fslib_1.npath.fromPortablePath(this.root), fslib_1.npath.fromPortablePath(p)))),
+            fslib_1.ppath.resolve(snapshotPP, fslib_1.npath.toPortablePath(fslib_1.npath.relative((0, path_1.toNamespacedPath)(fslib_1.npath.fromPortablePath(this.root)), (0, path_1.toNamespacedPath)(fslib_1.npath.fromPortablePath(p))))),
+            fslib_1.ppath.resolve(snapshotPP, fslib_1.npath.toPortablePath(fslib_1.npath.relative(fslib_1.npath.fromPortablePath(process.cwd()), fslib_1.npath.fromPortablePath(p)))),
+            fslib_1.ppath.resolve(snapshotPP, fslib_1.npath.toPortablePath(fslib_1.npath.relative((0, path_1.toNamespacedPath)(fslib_1.npath.fromPortablePath(process.cwd())), (0, path_1.toNamespacedPath)(fslib_1.npath.fromPortablePath(p))))),
+        ]));
+        for (const path of pathsToTry) {
+            const portablePath = fslib_1.npath.toPortablePath(path);
+            if (this.zipFs.existsSync(portablePath)) {
+                return {
+                    subPath: portablePath,
+                };
+            }
+        }
+    }
+    copyFilePromise(sourceP, destP, flags = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fallback = (sourceFs, sourceP, destFs, destP) => __awaiter(this, void 0, void 0, function* () {
+                if ((flags & fs_1.constants.COPYFILE_FICLONE_FORCE) !== 0)
+                    throw Object.assign(new Error(`EXDEV: cross-device clone not permitted, copyfile '${sourceP}' -> ${destP}'`), { code: `EXDEV` });
+                if (flags & fs_1.constants.COPYFILE_EXCL && (yield this.existsPromise(sourceP)))
+                    throw Object.assign(new Error(`EEXIST: file already exists, copyfile '${sourceP}' -> '${destP}'`), { code: `EEXIST` });
+                let content;
+                try {
+                    content = yield sourceFs.readFilePromise(sourceP);
+                }
+                catch (error) {
+                    throw Object.assign(new Error(`EINVAL: invalid argument, copyfile '${sourceP}' -> '${destP}'`), { code: `EINVAL` });
+                }
+                yield destFs.writeFilePromise(destP, content);
+            });
+            return yield this.makeCallPromise(sourceP, () => __awaiter(this, void 0, void 0, function* () {
+                return yield this.baseFs.copyFilePromise(sourceP, destP, flags);
+            }), (zipFsS, { subPath: subPathS }) => __awaiter(this, void 0, void 0, function* () {
+                return yield fallback(zipFsS, subPathS, this.baseFs, destP);
+            }));
+        });
+    }
+    copyFileSync(sourceP, destP, flags = 0) {
+        const fallback = (sourceFs, sourceP, destFs, destP) => {
+            if ((flags & fs_1.constants.COPYFILE_FICLONE_FORCE) !== 0)
+                throw Object.assign(new Error(`EXDEV: cross-device clone not permitted, copyfile '${sourceP}' -> ${destP}'`), { code: `EXDEV` });
+            if (flags & fs_1.constants.COPYFILE_EXCL && this.existsSync(sourceP))
+                throw Object.assign(new Error(`EEXIST: file already exists, copyfile '${sourceP}' -> '${destP}'`), { code: `EEXIST` });
+            let content;
+            try {
+                content = sourceFs.readFileSync(sourceP);
+            }
+            catch (error) {
+                throw Object.assign(new Error(`EINVAL: invalid argument, copyfile '${sourceP}' -> '${destP}'`), { code: `EINVAL` });
+            }
+            destFs.writeFileSync(destP, content);
+        };
+        return this.makeCallSync(sourceP, () => {
+            return this.baseFs.copyFileSync(sourceP, destP, flags);
+        }, (zipFsS, { subPath: subPathS }) => {
+            return fallback(zipFsS, subPathS, this.baseFs, destP);
+        });
+    }
+    readdirPromise(p, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fallback = () => __awaiter(this, void 0, void 0, function* () {
+                return yield this.baseFs.readdirPromise(p, opts);
+            });
+            return yield this.makeCallPromise(p, fallback, (zipFs, { subPath }) => __awaiter(this, void 0, void 0, function* () {
+                const fallbackPaths = yield fallback().catch(() => []);
+                return Promise.resolve(uniqReaddir(fallbackPaths.concat(yield zipFs.readdirPromise(subPath, opts))));
+            }), {
+                requireSubpath: false,
+            });
+        });
+    }
+    readdirSync(p, opts) {
+        const fallback = () => {
+            return this.baseFs.readdirSync(p, opts);
+        };
+        return this.makeCallSync(p, fallback, (zipFs, { subPath }) => {
+            let fallbackPaths = [];
+            try {
+                fallbackPaths = fallback();
+            }
+            catch (e) { }
+            return fallbackPaths.concat(uniqReaddir(zipFs.readdirSync(subPath, opts)));
+        }, {
+            requireSubpath: false,
+        });
+    }
+    mkdirPromise(p, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.baseFs.mkdirPromise(p, opts);
+        });
+    }
+    mkdirSync(p, opts) {
+        return this.baseFs.mkdirSync(p, opts);
+    }
+    rmdirPromise(p, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.baseFs.rmdirPromise(p, opts);
+        });
+    }
+    rmdirSync(p, opts) {
+        return this.baseFs.rmdirSync(p, opts);
+    }
+    opendirPromise(p, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.opendirSync(p, opts);
+        });
+    }
+    opendirSync(p, opts) {
+        const zipInfo = this.findZip(p);
+        let zipFsDir = null;
+        if (zipInfo) {
+            zipFsDir = this.zipFs.opendirSync(zipInfo.subPath);
+        }
+        let realFsDir = null;
+        try {
+            realFsDir = this.baseFs.opendirSync(p);
+        }
+        catch (e) {
+            if (!zipFsDir)
+                throw e;
+        }
+        const seen = new Set();
+        const nextDirent = () => {
+            const entry = (realFsDir === null || realFsDir === void 0 ? void 0 : realFsDir.readSync()) || (zipFsDir === null || zipFsDir === void 0 ? void 0 : zipFsDir.readSync());
+            if (entry && !seen.has(entry.name)) {
+                seen.add(entry.name);
+                return entry;
+            }
+            return null;
+        };
+        const onClose = () => {
+            zipFsDir === null || zipFsDir === void 0 ? void 0 : zipFsDir.closeSync();
+            realFsDir === null || realFsDir === void 0 ? void 0 : realFsDir.closeSync();
+        };
+        return new fslib_1.CustomDir(p, nextDirent, { onClose });
+    }
+}
+exports.SnapshotZipFS = SnapshotZipFS;

package/lib/fs/bootstrap.js

@@ -0,0 +1,20 @@
+if (true) {
+  const __nexe_patches = (process.nexe = { patches: {} }).patches
+  const slice = [].slice
+  const __nexe_noop_patch = function (original) {
+    const args = slice.call(arguments, 1)
+    return original.apply(this, args)
+  }
+  const __nexe_patch = function (obj, method, patch) {
+    const original = obj[method]
+    if (!original) return
+    __nexe_patches[method] = patch
+    obj[method] = function() {
+      const args = [original].concat(slice.call(arguments))
+      return __nexe_patches[method].apply(this, args)
+    }
+  }
+  __nexe_patch((process).binding('fs'), 'internalModuleReadFile', __nexe_noop_patch)
+  __nexe_patch((process).binding('fs'), 'internalModuleReadJSON', __nexe_noop_patch)
+  __nexe_patch((process).binding('fs'), 'internalModuleStat', __nexe_noop_patch)
+}

package/lib/fs/bundle.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { File } from 'resolve-dependencies';
+export declare function toStream(content: Buffer | string): Readable;
+export declare class Bundle {
+    cwd: string;
+    files: Set<string>;
+    zip: any;
+    constructor({ cwd }?: {
+        cwd: string;
+    });
+    get list(): string[];
+    addResource(absoluteFileName: string, content?: File | Buffer | string): void;
+    finalize(): any;
+    toStream(): Readable;
+}

package/lib/fs/bundle.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bundle = exports.toStream = void 0;
+const path_1 = require("path");
+const stream_1 = require("stream");
+const archiver_1 = __importDefault(require("archiver"));
+function makeRelativeToZip(cwd, path) {
+    return '/snapshot/' + (0, path_1.relative)(cwd, path);
+}
+function toStream(content) {
+    const readable = new stream_1.Readable({
+        read() {
+            this.push(content);
+            this.push(null);
+        },
+    });
+    return readable;
+}
+exports.toStream = toStream;
+class Bundle {
+    constructor({ cwd } = { cwd: process.cwd() }) {
+        this.files = new Set();
+        this.cwd = cwd;
+        this.zip = (0, archiver_1.default)('zip');
+    }
+    get list() {
+        return Array.from(this.files);
+    }
+    addResource(absoluteFileName, content) {
+        const destPath = makeRelativeToZip(this.cwd, absoluteFileName);
+        if (!this.files.has(destPath)) {
+            if (content == null) {
+                this.zip.file(absoluteFileName, { name: destPath });
+            }
+            else {
+                this.zip.append(content, { name: destPath });
+            }
+            this.files.add(destPath);
+        }
+    }
+    finalize() {
+        return this.zip.finalize();
+    }
+    toStream() {
+        return this.zip;
+    }
+}
+exports.Bundle = Bundle;

package/lib/fs/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "nexe-fs",
+  "version": "1.0.1",
+  "description": "Virtual File System used by nexe",
+  "main": "bundle.js",
+  "files": [
+    "*.d.ts",
+    "*.js"
+  ],
+  "author": "Caleb Boyd",
+  "dependencies": {
+    "multistream": "^2.1.1"
+  },
+  "license": "MIT"
+}