@atlaspack/fs 2.15.25 → 2.15.27-dev-ts-project-refs-d30e9754f.0

package/dist/MemoryFS.js

@@ -0,0 +1,804 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Dirent_mode;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = exports.FSError = exports.MemoryFS = void 0;
+exports.makeShared = makeShared;
+const path_1 = __importDefault(require("path"));
+const stream_1 = require("stream");
+const build_cache_1 = require("@atlaspack/build-cache");
+const package_json_1 = __importDefault(require("../package.json"));
+const workers_1 = __importDefault(require("@atlaspack/workers"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const events_1 = __importDefault(require("events"));
+const find_1 = require("./find");
+const instances = new Map();
+let id = 0;
+class MemoryFS {
+    constructor(workerFarm) {
+        this._numWorkerInstances = 0;
+        this._workerRegisterResolves = [];
+        this._emitter = new events_1.default();
+        this.farm = workerFarm;
+        this._cwd = path_1.default.resolve(path_1.default.sep);
+        this.dirs = new Map([[this._cwd, new Directory()]]);
+        this.files = new Map();
+        this.symlinks = new Map();
+        this.watchers = new Map();
+        this.events = [];
+        this.id = id++;
+        this._workerHandles = [];
+        this._eventQueue = [];
+        instances.set(this.id, this);
+        this._emitter.on('allWorkersRegistered', () => {
+            for (let resolve of this._workerRegisterResolves) {
+                resolve();
+            }
+            this._workerRegisterResolves = [];
+        });
+    }
+    static deserialize(opts) {
+        let existing = instances.get(opts.id);
+        if (existing != null) {
+            // Correct the count of worker instances since serialization assumes a new instance is created
+            workers_1.default.getWorkerApi().runHandle(opts.handle, [
+                'decrementWorkerInstance',
+                [],
+            ]);
+            return existing;
+        }
+        let fs = new WorkerFS(opts.id, (0, nullthrows_1.default)(opts.handle));
+        fs.dirs = opts.dirs;
+        fs.files = opts.files;
+        fs.symlinks = opts.symlinks;
+        return fs;
+    }
+    serialize() {
+        if (!this.handle) {
+            this.handle = this.farm.createReverseHandle((fn, args) => {
+                // @ts-expect-error TS7053
+                return this[fn](...args);
+            });
+        }
+        // If a worker instance already exists, it will decrement this number
+        this._numWorkerInstances++;
+        return {
+            // @ts-expect-error TS2353
+            $$raw: false,
+            id: this.id,
+            handle: this.handle,
+            dirs: this.dirs,
+            files: this.files,
+            symlinks: this.symlinks,
+        };
+    }
+    decrementWorkerInstance() {
+        this._numWorkerInstances--;
+        if (this._numWorkerInstances === this._workerHandles.length) {
+            this._emitter.emit('allWorkersRegistered');
+        }
+    }
+    cwd() {
+        return this._cwd;
+    }
+    chdir(dir) {
+        this._cwd = dir;
+    }
+    _normalizePath(filePath, realpath = true) {
+        filePath = path_1.default.normalize(filePath);
+        if (!filePath.startsWith(this.cwd())) {
+            filePath = path_1.default.resolve(this.cwd(), filePath);
+        }
+        // get realpath by following symlinks
+        if (realpath) {
+            let { root, dir, base } = path_1.default.parse(filePath);
+            let parts = dir.slice(root.length).split(path_1.default.sep).concat(base);
+            let res = root;
+            for (let part of parts) {
+                res = path_1.default.join(res, part);
+                let symlink = this.symlinks.get(res);
+                if (symlink) {
+                    res = symlink;
+                }
+            }
+            return res;
+        }
+        return filePath;
+    }
+    async writeFile(filePath, contents, options) {
+        filePath = this._normalizePath(filePath);
+        if (this.dirs.has(filePath)) {
+            throw new FSError('EISDIR', filePath, 'is a directory');
+        }
+        let dir = path_1.default.dirname(filePath);
+        if (!this.dirs.has(dir)) {
+            throw new FSError('ENOENT', dir, 'does not exist');
+        }
+        let buffer = makeShared(contents);
+        let file = this.files.get(filePath);
+        let mode = (options && options.mode) || 0o666;
+        if (file) {
+            file.write(buffer, mode);
+            this.files.set(filePath, file);
+        }
+        else {
+            this.files.set(filePath, new File(buffer, mode));
+        }
+        await this._sendWorkerEvent({
+            type: 'writeFile',
+            path: filePath,
+            entry: this.files.get(filePath),
+        });
+        this._triggerEvent({
+            type: file ? 'update' : 'create',
+            path: filePath,
+        });
+    }
+    // eslint-disable-next-line require-await
+    async readFile(filePath, encoding) {
+        return this.readFileSync(filePath, encoding);
+    }
+    readFileSync(filePath, encoding) {
+        filePath = this._normalizePath(filePath);
+        let file = this.files.get(filePath);
+        if (file == null) {
+            throw new FSError('ENOENT', filePath, 'does not exist');
+        }
+        let buffer = file.read();
+        if (encoding) {
+            return buffer.toString(encoding);
+        }
+        return buffer;
+    }
+    async copyFile(source, destination) {
+        let contents = await this.readFile(source);
+        await this.writeFile(destination, contents);
+    }
+    statSync(filePath) {
+        filePath = this._normalizePath(filePath);
+        let dir = this.dirs.get(filePath);
+        if (dir) {
+            return dir.stat();
+        }
+        let file = this.files.get(filePath);
+        if (file == null) {
+            throw new FSError('ENOENT', filePath, 'does not exist');
+        }
+        return file.stat();
+    }
+    // eslint-disable-next-line require-await
+    async stat(filePath) {
+        return this.statSync(filePath);
+    }
+    readdirSync(dir, opts) {
+        dir = this._normalizePath(dir);
+        if (!this.dirs.has(dir)) {
+            throw new FSError('ENOENT', dir, 'does not exist');
+        }
+        if (!dir.endsWith(path_1.default.sep)) {
+            dir += path_1.default.sep;
+        }
+        let res = [];
+        for (let [filePath, entry] of this.dirs) {
+            if (filePath === dir) {
+                continue;
+            }
+            if (filePath.startsWith(dir) &&
+                filePath.indexOf(path_1.default.sep, dir.length) === -1) {
+                let name = filePath.slice(dir.length);
+                if (opts?.withFileTypes) {
+                    res.push(new Dirent(name, entry));
+                }
+                else {
+                    res.push(name);
+                }
+            }
+        }
+        for (let [filePath, entry] of this.files) {
+            if (filePath.startsWith(dir) &&
+                filePath.indexOf(path_1.default.sep, dir.length) === -1) {
+                let name = filePath.slice(dir.length);
+                if (opts?.withFileTypes) {
+                    res.push(new Dirent(name, entry));
+                }
+                else {
+                    res.push(name);
+                }
+            }
+        }
+        for (let [from] of this.symlinks) {
+            if (from.startsWith(dir) && from.indexOf(path_1.default.sep, dir.length) === -1) {
+                let name = from.slice(dir.length);
+                if (opts?.withFileTypes) {
+                    res.push(new Dirent(name, { mode: S_IFLNK }));
+                }
+                else {
+                    res.push(name);
+                }
+            }
+        }
+        return res;
+    }
+    // eslint-disable-next-line require-await
+    async readdir(dir, opts) {
+        return this.readdirSync(dir, opts);
+    }
+    async unlink(filePath) {
+        filePath = this._normalizePath(filePath);
+        if (!this.files.has(filePath) && !this.dirs.has(filePath)) {
+            throw new FSError('ENOENT', filePath, 'does not exist');
+        }
+        this.files.delete(filePath);
+        this.dirs.delete(filePath);
+        this.watchers.delete(filePath);
+        await this._sendWorkerEvent({
+            type: 'unlink',
+            path: filePath,
+        });
+        this._triggerEvent({
+            type: 'delete',
+            path: filePath,
+        });
+        return Promise.resolve();
+    }
+    async mkdirp(dir) {
+        dir = this._normalizePath(dir);
+        if (this.dirs.has(dir)) {
+            return Promise.resolve();
+        }
+        if (this.files.has(dir)) {
+            throw new FSError('ENOENT', dir, 'is not a directory');
+        }
+        let root = path_1.default.parse(dir).root;
+        while (dir !== root) {
+            if (this.dirs.has(dir)) {
+                break;
+            }
+            this.dirs.set(dir, new Directory());
+            await this._sendWorkerEvent({
+                type: 'mkdir',
+                path: dir,
+            });
+            this._triggerEvent({
+                type: 'create',
+                path: dir,
+            });
+            dir = path_1.default.dirname(dir);
+        }
+        return Promise.resolve();
+    }
+    async rimraf(filePath) {
+        filePath = this._normalizePath(filePath);
+        if (this.dirs.has(filePath)) {
+            let dir = filePath + path_1.default.sep;
+            for (let filePath of this.files.keys()) {
+                if (filePath.startsWith(dir)) {
+                    this.files.delete(filePath);
+                    await this._sendWorkerEvent({
+                        type: 'unlink',
+                        path: filePath,
+                    });
+                    this._triggerEvent({
+                        type: 'delete',
+                        path: filePath,
+                    });
+                }
+            }
+            for (let dirPath of this.dirs.keys()) {
+                if (dirPath.startsWith(dir)) {
+                    this.dirs.delete(dirPath);
+                    this.watchers.delete(dirPath);
+                    await this._sendWorkerEvent({
+                        type: 'unlink',
+                        path: filePath,
+                    });
+                    this._triggerEvent({
+                        type: 'delete',
+                        path: dirPath,
+                    });
+                }
+            }
+            for (let filePath of this.symlinks.keys()) {
+                if (filePath.startsWith(dir)) {
+                    this.symlinks.delete(filePath);
+                    await this._sendWorkerEvent({
+                        type: 'unlink',
+                        path: filePath,
+                    });
+                }
+            }
+            this.dirs.delete(filePath);
+            await this._sendWorkerEvent({
+                type: 'unlink',
+                path: filePath,
+            });
+            this._triggerEvent({
+                type: 'delete',
+                path: filePath,
+            });
+        }
+        else if (this.files.has(filePath)) {
+            this.files.delete(filePath);
+            await this._sendWorkerEvent({
+                type: 'unlink',
+                path: filePath,
+            });
+            this._triggerEvent({
+                type: 'delete',
+                path: filePath,
+            });
+        }
+        return Promise.resolve();
+    }
+    async ncp(source, destination) {
+        source = this._normalizePath(source);
+        if (this.dirs.has(source)) {
+            if (!this.dirs.has(destination)) {
+                this.dirs.set(destination, new Directory());
+                await this._sendWorkerEvent({
+                    type: 'mkdir',
+                    path: destination,
+                });
+                this._triggerEvent({
+                    type: 'create',
+                    path: destination,
+                });
+            }
+            let dir = source + path_1.default.sep;
+            for (let dirPath of this.dirs.keys()) {
+                if (dirPath.startsWith(dir)) {
+                    let destName = path_1.default.join(destination, dirPath.slice(dir.length));
+                    if (!this.dirs.has(destName)) {
+                        this.dirs.set(destName, new Directory());
+                        await this._sendWorkerEvent({
+                            type: 'mkdir',
+                            path: destination,
+                        });
+                        this._triggerEvent({
+                            type: 'create',
+                            path: destName,
+                        });
+                    }
+                }
+            }
+            for (let [filePath, file] of this.files) {
+                if (filePath.startsWith(dir)) {
+                    let destName = path_1.default.join(destination, filePath.slice(dir.length));
+                    let exists = this.files.has(destName);
+                    this.files.set(destName, file);
+                    await this._sendWorkerEvent({
+                        type: 'writeFile',
+                        path: destName,
+                        entry: file,
+                    });
+                    this._triggerEvent({
+                        type: exists ? 'update' : 'create',
+                        path: destName,
+                    });
+                }
+            }
+        }
+        else {
+            await this.copyFile(source, destination);
+        }
+    }
+    createReadStream(filePath) {
+        return new ReadStream(this, filePath);
+    }
+    createWriteStream(filePath, options) {
+        this.mkdirp(path_1.default.dirname(filePath));
+        return new WriteStream(this, filePath, options);
+    }
+    realpathSync(filePath) {
+        return this._normalizePath(filePath);
+    }
+    // eslint-disable-next-line require-await
+    async realpath(filePath) {
+        return this.realpathSync(filePath);
+    }
+    async symlink(target, path) {
+        target = this._normalizePath(target);
+        path = this._normalizePath(path);
+        this.symlinks.set(path, target);
+        await this._sendWorkerEvent({
+            type: 'symlink',
+            path,
+            target,
+        });
+    }
+    existsSync(filePath) {
+        filePath = this._normalizePath(filePath);
+        return this.files.has(filePath) || this.dirs.has(filePath);
+    }
+    // eslint-disable-next-line require-await
+    async exists(filePath) {
+        return this.existsSync(filePath);
+    }
+    _triggerEvent(event) {
+        this.events.push(event);
+        if (this.watchers.size === 0) {
+            return;
+        }
+        // Batch events
+        this._eventQueue.push(event);
+        clearTimeout(this._watcherTimer);
+        // @ts-expect-error TS2322
+        this._watcherTimer = setTimeout(() => {
+            let events = this._eventQueue;
+            this._eventQueue = [];
+            for (let [dir, watchers] of this.watchers) {
+                if (!dir.endsWith(path_1.default.sep)) {
+                    dir += path_1.default.sep;
+                }
+                const relevantEvents = events.filter((event) => event.path.startsWith(dir));
+                if (relevantEvents.length > 0) {
+                    for (let watcher of watchers) {
+                        watcher.trigger(relevantEvents);
+                    }
+                }
+            }
+        }, 50);
+    }
+    _registerWorker(handle) {
+        this._workerHandles.push(handle);
+        if (this._numWorkerInstances === this._workerHandles.length) {
+            this._emitter.emit('allWorkersRegistered');
+        }
+    }
+    async _sendWorkerEvent(event) {
+        // Wait for worker instances to register their handles
+        while (this._workerHandles.length < this._numWorkerInstances) {
+            await new Promise((resolve) => 
+            // @ts-expect-error TS2345
+            this._workerRegisterResolves.push(resolve));
+        }
+        await Promise.all(this._workerHandles.map((workerHandle) => this.farm.workerApi.runHandle(workerHandle, [event])));
+    }
+    watch(dir, fn, opts) {
+        dir = this._normalizePath(dir);
+        let watcher = new Watcher(fn, opts);
+        let watchers = this.watchers.get(dir);
+        if (!watchers) {
+            watchers = new Set();
+            this.watchers.set(dir, watchers);
+        }
+        watchers.add(watcher);
+        return Promise.resolve({
+            unsubscribe: () => {
+                watchers = (0, nullthrows_1.default)(watchers);
+                watchers.delete(watcher);
+                if (watchers.size === 0) {
+                    this.watchers.delete(dir);
+                }
+                return Promise.resolve();
+            },
+        });
+    }
+    async getEventsSince(dir, snapshot, opts) {
+        let contents = await this.readFile(snapshot, 'utf8');
+        let len = Number(contents);
+        let events = this.events.slice(len);
+        let ignore = opts.ignore;
+        if (ignore) {
+            events = events.filter((event) => !ignore.some((i) => event.path.startsWith(i + path_1.default.sep)));
+        }
+        return events;
+    }
+    async writeSnapshot(dir, snapshot) {
+        await this.mkdirp(path_1.default.dirname(snapshot));
+        await this.writeFile(snapshot, '' + this.events.length);
+    }
+    findAncestorFile(fileNames, fromDir, root) {
+        return (0, find_1.findAncestorFile)(this, fileNames, fromDir, root);
+    }
+    findNodeModule(moduleName, fromDir) {
+        return (0, find_1.findNodeModule)(this, moduleName, fromDir);
+    }
+    findFirstFile(filePaths) {
+        return (0, find_1.findFirstFile)(this, filePaths);
+    }
+}
+exports.MemoryFS = MemoryFS;
+class Watcher {
+    constructor(fn, options) {
+        this.fn = fn;
+        this.options = options;
+    }
+    trigger(events) {
+        let ignore = this.options.ignore;
+        if (ignore) {
+            events = events.filter((event) => !ignore.some((i) => event.path.startsWith(i + path_1.default.sep)));
+        }
+        if (events.length > 0) {
+            this.fn(null, events);
+        }
+    }
+}
+class FSError extends Error {
+    constructor(code, path, message) {
+        super(`${code}: ${path} ${message}`);
+        this.name = 'FSError';
+        this.code = code;
+        this.path = path;
+        Error.captureStackTrace?.(this, this.constructor);
+    }
+}
+exports.FSError = FSError;
+class ReadStream extends stream_1.Readable {
+    constructor(fs, filePath) {
+        super();
+        this.fs = fs;
+        this.filePath = filePath;
+        this.reading = false;
+        this.bytesRead = 0;
+    }
+    _read() {
+        if (this.reading) {
+            return;
+        }
+        this.reading = true;
+        this.fs.readFile(this.filePath).then((res) => {
+            this.bytesRead += res.byteLength;
+            this.push(res);
+            this.push(null);
+        }, (err) => {
+            this.emit('error', err);
+        });
+    }
+}
+class WriteStream extends stream_1.Writable {
+    constructor(fs, filePath, options) {
+        super({ emitClose: true, autoDestroy: true });
+        this.fs = fs;
+        this.filePath = filePath;
+        this.options = options;
+        this.buffer = Buffer.alloc(0);
+    }
+    _write(chunk, encoding, callback) {
+        let c = typeof chunk === 'string' ? Buffer.from(chunk, encoding) : chunk;
+        this.buffer = Buffer.concat([this.buffer, c]);
+        callback();
+    }
+    _final(callback) {
+        this.fs
+            .writeFile(this.filePath, this.buffer, this.options)
+            // @ts-expect-error TS2345
+            .then(callback)
+            .catch(callback);
+    }
+}
+const S_IFREG = 0o100000;
+const S_IFDIR = 0o040000;
+const S_IFLNK = 0o120000;
+const S_IFMT = 0o170000;
+class Entry {
+    constructor(mode) {
+        this.mode = mode;
+        let now = Date.now();
+        this.atime = now;
+        this.mtime = now;
+        this.ctime = now;
+        this.birthtime = now;
+    }
+    access() {
+        let now = Date.now();
+        this.atime = now;
+        this.ctime = now;
+    }
+    modify(mode) {
+        let now = Date.now();
+        this.mtime = now;
+        this.ctime = now;
+        this.mode = mode;
+    }
+    getSize() {
+        return 0;
+    }
+    stat() {
+        return new Stat(this);
+    }
+}
+class Stat {
+    constructor(entry) {
+        this.dev = 0;
+        this.ino = 0;
+        this.nlink = 0;
+        this.uid = 0;
+        this.gid = 0;
+        this.rdev = 0;
+        this.blksize = 0;
+        this.blocks = 0;
+        this.mode = entry.mode;
+        this.size = entry.getSize();
+        this.atimeMs = entry.atime;
+        this.mtimeMs = entry.mtime;
+        this.ctimeMs = entry.ctime;
+        this.birthtimeMs = entry.birthtime;
+        this.atime = new Date(entry.atime);
+        this.mtime = new Date(entry.mtime);
+        this.ctime = new Date(entry.ctime);
+        this.birthtime = new Date(entry.birthtime);
+    }
+    isFile() {
+        return Boolean(this.mode & S_IFREG);
+    }
+    isDirectory() {
+        return Boolean(this.mode & S_IFDIR);
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isSymbolicLink() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
+class Dirent {
+    constructor(name, entry) {
+        _Dirent_mode.set(this, void 0);
+        this.name = name;
+        __classPrivateFieldSet(this, _Dirent_mode, entry.mode, "f");
+    }
+    isFile() {
+        return (__classPrivateFieldGet(this, _Dirent_mode, "f") & S_IFMT) === S_IFREG;
+    }
+    isDirectory() {
+        return (__classPrivateFieldGet(this, _Dirent_mode, "f") & S_IFMT) === S_IFDIR;
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isSymbolicLink() {
+        return (__classPrivateFieldGet(this, _Dirent_mode, "f") & S_IFMT) === S_IFLNK;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
+_Dirent_mode = new WeakMap();
+class File extends Entry {
+    constructor(buffer, mode) {
+        super(S_IFREG | mode);
+        this.buffer = buffer;
+    }
+    read() {
+        super.access();
+        return Buffer.from(this.buffer);
+    }
+    write(buffer, mode) {
+        super.modify(S_IFREG | mode);
+        this.buffer = buffer;
+    }
+    getSize() {
+        return this.buffer.byteLength;
+    }
+}
+exports.File = File;
+class Directory extends Entry {
+    constructor() {
+        super(S_IFDIR);
+    }
+}
+function makeShared(contents) {
+    if (typeof contents !== 'string' &&
+        contents.buffer instanceof SharedArrayBuffer) {
+        return contents;
+    }
+    let contentsBuffer = contents;
+    // @ts-expect-error TS2339
+    if (process.browser) {
+        // For the polyfilled buffer module, it's faster to always convert once so that the subsequent
+        // operations are fast (.byteLength and using .set instead of .write)
+        contentsBuffer =
+            contentsBuffer instanceof Buffer
+                ? contentsBuffer
+                : Buffer.from(contentsBuffer);
+    }
+    let length = Buffer.byteLength(contentsBuffer);
+    let shared = new SharedArrayBuffer(length);
+    let buffer = Buffer.from(shared);
+    if (length > 0) {
+        if (typeof contentsBuffer === 'string') {
+            buffer.write(contentsBuffer);
+        }
+        else {
+            buffer.set(contentsBuffer);
+        }
+    }
+    return buffer;
+}
+class WorkerFS extends MemoryFS {
+    constructor(id, handle) {
+        // TODO Make this not a subclass
+        // @ts-expect-error TS2554
+        super();
+        this.id = id;
+        this.handleFn = (methodName, args) => workers_1.default.getWorkerApi().runHandle(handle, [methodName, args]);
+        this.handleFn('_registerWorker', [
+            workers_1.default.getWorkerApi().createReverseHandle((event) => {
+                switch (event.type) {
+                    case 'writeFile':
+                        this.files.set(event.path, event.entry);
+                        break;
+                    case 'unlink':
+                        this.files.delete(event.path);
+                        this.dirs.delete(event.path);
+                        this.symlinks.delete(event.path);
+                        break;
+                    case 'mkdir':
+                        this.dirs.set(event.path, new Directory());
+                        break;
+                    case 'symlink':
+                        this.symlinks.set(event.path, event.target);
+                        break;
+                }
+            }),
+        ]);
+    }
+    static deserialize(opts) {
+        return (0, nullthrows_1.default)(instances.get(opts.id));
+    }
+    serialize() {
+        // @ts-expect-error TS2739
+        return {
+            id: this.id,
+        };
+    }
+    writeFile(filePath, contents, options) {
+        super.writeFile(filePath, contents, options);
+        let buffer = makeShared(contents);
+        return this.handleFn('writeFile', [filePath, buffer, options]);
+    }
+    unlink(filePath) {
+        super.unlink(filePath);
+        return this.handleFn('unlink', [filePath]);
+    }
+    mkdirp(dir) {
+        super.mkdirp(dir);
+        return this.handleFn('mkdirp', [dir]);
+    }
+    rimraf(filePath) {
+        super.rimraf(filePath);
+        return this.handleFn('rimraf', [filePath]);
+    }
+    ncp(source, destination) {
+        super.ncp(source, destination);
+        return this.handleFn('ncp', [source, destination]);
+    }
+    symlink(target, path) {
+        super.symlink(target, path);
+        return this.handleFn('symlink', [target, path]);
+    }
+}
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:MemoryFS`, MemoryFS);
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:WorkerFS`, WorkerFS);
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:Stat`, Stat);
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:File`, File);
+(0, build_cache_1.registerSerializableClass)(`${package_json_1.default.version}:Directory`, Directory);