@atlaspack/fs 2.15.11-dev-eae8c193d.0 → 2.15.11-typescript-de860656a.0

package/lib/MemoryFS.js

@@ -0,0 +1,829 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MemoryFS = exports.File = exports.FSError = void 0;
+exports.makeShared = makeShared;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+var _package = _interopRequireDefault(require("../package.json"));
+function _workers() {
+  const data = _interopRequireWildcard(require("@atlaspack/workers"));
+  _workers = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _events() {
+  const data = _interopRequireDefault(require("events"));
+  _events = function () {
+    return data;
+  };
+  return data;
+}
+var _find = require("./find");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const instances = new Map();
+let id = 0;
+class MemoryFS {
+  _numWorkerInstances = 0;
+  _workerRegisterResolves = [];
+  _emitter = new (_events().default)();
+  constructor(workerFarm) {
+    this.farm = workerFarm;
+    this._cwd = _path().default.resolve(_path().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().default.getWorkerApi().runHandle(opts.handle, ['decrementWorkerInstance', []]);
+      return existing;
+    }
+    let fs = new WorkerFS(opts.id, (0, _nullthrows().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) => {
+        // $FlowFixMe
+        return this[fn](...args);
+      });
+    }
+
+    // If a worker instance already exists, it will decrement this number
+    this._numWorkerInstances++;
+    return {
+      $$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().default.normalize(filePath);
+    if (!filePath.startsWith(this.cwd())) {
+      filePath = _path().default.resolve(this.cwd(), filePath);
+    }
+
+    // get realpath by following symlinks
+    if (realpath) {
+      let {
+        root,
+        dir,
+        base
+      } = _path().default.parse(filePath);
+      let parts = dir.slice(root.length).split(_path().default.sep).concat(base);
+      let res = root;
+      for (let part of parts) {
+        res = _path().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().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().default.sep)) {
+      dir += _path().default.sep;
+    }
+    let res = [];
+    for (let [filePath, entry] of this.dirs) {
+      if (filePath === dir) {
+        continue;
+      }
+      if (filePath.startsWith(dir) && filePath.indexOf(_path().default.sep, dir.length) === -1) {
+        let name = filePath.slice(dir.length);
+        if (opts !== null && opts !== void 0 && 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().default.sep, dir.length) === -1) {
+        let name = filePath.slice(dir.length);
+        if (opts !== null && opts !== void 0 && 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().default.sep, dir.length) === -1) {
+        let name = from.slice(dir.length);
+        if (opts !== null && opts !== void 0 && 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().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().default.dirname(dir);
+    }
+    return Promise.resolve();
+  }
+  async rimraf(filePath) {
+    filePath = this._normalizePath(filePath);
+    if (this.dirs.has(filePath)) {
+      let dir = filePath + _path().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().default.sep;
+      for (let dirPath of this.dirs.keys()) {
+        if (dirPath.startsWith(dir)) {
+          let destName = _path().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().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().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);
+    this._watcherTimer = setTimeout(() => {
+      let events = this._eventQueue;
+      this._eventQueue = [];
+      for (let [dir, watchers] of this.watchers) {
+        if (!dir.endsWith(_path().default.sep)) {
+          dir += _path().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 => 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().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().default.sep)));
+    }
+    return events;
+  }
+  async writeSnapshot(dir, snapshot) {
+    await this.mkdirp(_path().default.dirname(snapshot));
+    await this.writeFile(snapshot, '' + this.events.length);
+  }
+  findAncestorFile(fileNames, fromDir, root) {
+    return (0, _find.findAncestorFile)(this, fileNames, fromDir, root);
+  }
+  findNodeModule(moduleName, fromDir) {
+    return (0, _find.findNodeModule)(this, moduleName, fromDir);
+  }
+  findFirstFile(filePaths) {
+    return (0, _find.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().default.sep)));
+    }
+    if (events.length > 0) {
+      this.fn(null, events);
+    }
+  }
+}
+class FSError extends Error {
+  constructor(code, path, message) {
+    var _Error$captureStackTr;
+    super(`${code}: ${path} ${message}`);
+    this.name = 'FSError';
+    this.code = code;
+    this.path = path;
+    (_Error$captureStackTr = Error.captureStackTrace) === null || _Error$captureStackTr === void 0 || _Error$captureStackTr.call(Error, this, this.constructor);
+  }
+}
+exports.FSError = FSError;
+class ReadStream extends _stream().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().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).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 {
+  dev = 0;
+  ino = 0;
+  nlink = 0;
+  uid = 0;
+  gid = 0;
+  rdev = 0;
+  blksize = 0;
+  blocks = 0;
+  constructor(entry) {
+    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 {
+  #mode;
+  constructor(name, entry) {
+    this.name = name;
+    this.#mode = entry.mode;
+  }
+  isFile() {
+    return (this.#mode & S_IFMT) === S_IFREG;
+  }
+  isDirectory() {
+    return (this.#mode & S_IFMT) === S_IFDIR;
+  }
+  isBlockDevice() {
+    return false;
+  }
+  isCharacterDevice() {
+    return false;
+  }
+  isSymbolicLink() {
+    return (this.#mode & S_IFMT) === S_IFLNK;
+  }
+  isFIFO() {
+    return false;
+  }
+  isSocket() {
+    return false;
+  }
+}
+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 _utils().SharedBuffer) {
+    return contents;
+  }
+  let contentsBuffer = contents;
+  // $FlowFixMe
+  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 (_utils().SharedBuffer)(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
+    // $FlowFixMe
+    super();
+    this.id = id;
+    this.handleFn = (methodName, args) => _workers().default.getWorkerApi().runHandle(handle, [methodName, args]);
+    this.handleFn('_registerWorker', [_workers().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().default)(instances.get(opts.id));
+  }
+  serialize() {
+    // $FlowFixMe
+    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, _buildCache().registerSerializableClass)(`${_package.default.version}:MemoryFS`, MemoryFS);
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:WorkerFS`, WorkerFS);
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:Stat`, Stat);
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:File`, File);
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:Directory`, Directory);