text: 'use strict'
  // This is adapted from https://github.com/normalize/mz
  // Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
  const u = require('universalify').fromCallback
  const fs = require('graceful-fs')
  
  const api = [
    'access',
    'appendFile',
    'chmod',
    'chown',
    'close',
    'copyFile',
    'fchmod',
    'fchown',
    'fdatasync',
    'fstat',
    'fsync',
    'ftruncate',
    'futimes',
    'lchmod',
    'lchown',
    'link',
    'lstat',
    'mkdir',
    'mkdtemp',
    'open',
    'opendir',
    'readdir',
    'readFile',
    'readlink',
    'realpath',
    'rename',
    'rm',
    'rmdir',
    'stat',
    'symlink',
    'truncate',
    'unlink',
    'utimes',
    'writeFile'
  ].filter(key => {
    // Some commands are not available on some systems. Ex:
    // fs.opendir was added in Node.js v12.12.0
    // fs.rm was added in Node.js v14.14.0
    // fs.lchown is not available on at least some Linux
    return typeof fs[key] === 'function'
  })
  
  // Export cloned fs:
  Object.assign(exports, fs)
  
  // Universalify async methods:
  api.forEach(method => {
    exports[method] = u(fs[method])
  })
  exports.realpath.native = u(fs.realpath.native)
  
  // We differ from mz/fs in that we still ship the old, broken, fs.exists()
  // since we are a drop-in replacement for the native module
  exports.exists = function (filename, callback) {
    if (typeof callback === 'function') {
      return fs.exists(filename, callback)
    }
    return new Promise(resolve => {
      return fs.exists(filename, resolve)
    })
  }
  
  // fs.read(), fs.write(), & fs.writev() need special treatment due to multiple callback args
  
  exports.read = function (fd, buffer, offset, length, position, callback) {
    if (typeof callback === 'function') {
      return fs.read(fd, buffer, offset, length, position, callback)
    }
    return new Promise((resolve, reject) => {
      fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
        if (err) return reject(err)
        resolve({ bytesRead, buffer })
      })
    })
  }
  
  // Function signature can be
  // fs.write(fd, buffer[, offset[, length[, position]]], callback)
  // OR
  // fs.write(fd, string[, position[, encoding]], callback)
  // We need to handle both cases, so we use ...args
  exports.write = function (fd, buffer, ...args) {
    if (typeof args[args.length - 1] === 'function') {
      return fs.write(fd, buffer, ...args)
    }
  
    return new Promise((resolve, reject) => {
      fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
        if (err) return reject(err)
        resolve({ bytesWritten, buffer })
      })
    })
  }
  
  // fs.writev only available in Node v12.9.0+
  if (typeof fs.writev === 'function') {
    // Function signature is
    // s.writev(fd, buffers[, position], callback)
    // We need to handle the optional arg, so we use ...args
    exports.writev = function (fd, buffers, ...args) {
      if (typeof args[args.length - 1] === 'function') {
        return fs.writev(fd, buffers, ...args)
      }
  
      return new Promise((resolve, reject) => {
        fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
          if (err) return reject(err)
          resolve({ bytesWritten, buffers })
        })
      })
    }
  }
  