@vercel/ruby 1.3.74 → 1.3.76

package/dist/index.js

@@ -4420,6 +4420,979 @@ function patch (fs) {
 }
 
 
+/***/ }),
+
+/***/ 3016:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = clone
+
+var getPrototypeOf = Object.getPrototypeOf || function (obj) {
+  return obj.__proto__
+}
+
+function clone (obj) {
+  if (obj === null || typeof obj !== 'object')
+    return obj
+
+  if (obj instanceof Object)
+    var copy = { __proto__: getPrototypeOf(obj) }
+  else
+    var copy = Object.create(null)
+
+  Object.getOwnPropertyNames(obj).forEach(function (key) {
+    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+  })
+
+  return copy
+}
+
+
+/***/ }),
+
+/***/ 7156:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var fs = __webpack_require__(5747)
+var polyfills = __webpack_require__(4692)
+var legacy = __webpack_require__(6465)
+var clone = __webpack_require__(3016)
+
+var util = __webpack_require__(1669)
+
+/* istanbul ignore next - node 0.x polyfill */
+var gracefulQueue
+var previousSymbol
+
+/* istanbul ignore else - node 0.x polyfill */
+if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
+  gracefulQueue = Symbol.for('graceful-fs.queue')
+  // This is used in testing by future versions
+  previousSymbol = Symbol.for('graceful-fs.previous')
+} else {
+  gracefulQueue = '___graceful-fs.queue'
+  previousSymbol = '___graceful-fs.previous'
+}
+
+function noop () {}
+
+function publishQueue(context, queue) {
+  Object.defineProperty(context, gracefulQueue, {
+    get: function() {
+      return queue
+    }
+  })
+}
+
+var debug = noop
+if (util.debuglog)
+  debug = util.debuglog('gfs4')
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+  debug = function() {
+    var m = util.format.apply(util, arguments)
+    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
+    console.error(m)
+  }
+
+// Once time initialization
+if (!fs[gracefulQueue]) {
+  // This queue can be shared by multiple loaded instances
+  var queue = global[gracefulQueue] || []
+  publishQueue(fs, queue)
+
+  // Patch fs.close/closeSync to shared queue version, because we need
+  // to retry() whenever a close happens *anywhere* in the program.
+  // This is essential when multiple graceful-fs instances are
+  // in play at the same time.
+  fs.close = (function (fs$close) {
+    function close (fd, cb) {
+      return fs$close.call(fs, fd, function (err) {
+        // This function uses the graceful-fs shared queue
+        if (!err) {
+          resetQueue()
+        }
+
+        if (typeof cb === 'function')
+          cb.apply(this, arguments)
+      })
+    }
+
+    Object.defineProperty(close, previousSymbol, {
+      value: fs$close
+    })
+    return close
+  })(fs.close)
+
+  fs.closeSync = (function (fs$closeSync) {
+    function closeSync (fd) {
+      // This function uses the graceful-fs shared queue
+      fs$closeSync.apply(fs, arguments)
+      resetQueue()
+    }
+
+    Object.defineProperty(closeSync, previousSymbol, {
+      value: fs$closeSync
+    })
+    return closeSync
+  })(fs.closeSync)
+
+  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+    process.on('exit', function() {
+      debug(fs[gracefulQueue])
+      __webpack_require__(2357).equal(fs[gracefulQueue].length, 0)
+    })
+  }
+}
+
+if (!global[gracefulQueue]) {
+  publishQueue(global, fs[gracefulQueue]);
+}
+
+module.exports = patch(clone(fs))
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+    module.exports = patch(fs)
+    fs.__patched = true;
+}
+
+function patch (fs) {
+  // Everything that references the open() function needs to be in here
+  polyfills(fs)
+  fs.gracefulify = patch
+
+  fs.createReadStream = createReadStream
+  fs.createWriteStream = createWriteStream
+  var fs$readFile = fs.readFile
+  fs.readFile = readFile
+  function readFile (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    return go$readFile(path, options, cb)
+
+    function go$readFile (path, options, cb, startTime) {
+      return fs$readFile(path, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$writeFile = fs.writeFile
+  fs.writeFile = writeFile
+  function writeFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    return go$writeFile(path, data, options, cb)
+
+    function go$writeFile (path, data, options, cb, startTime) {
+      return fs$writeFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$appendFile = fs.appendFile
+  if (fs$appendFile)
+    fs.appendFile = appendFile
+  function appendFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    return go$appendFile(path, data, options, cb)
+
+    function go$appendFile (path, data, options, cb, startTime) {
+      return fs$appendFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$copyFile = fs.copyFile
+  if (fs$copyFile)
+    fs.copyFile = copyFile
+  function copyFile (src, dest, flags, cb) {
+    if (typeof flags === 'function') {
+      cb = flags
+      flags = 0
+    }
+    return go$copyFile(src, dest, flags, cb)
+
+    function go$copyFile (src, dest, flags, cb, startTime) {
+      return fs$copyFile(src, dest, flags, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$readdir = fs.readdir
+  fs.readdir = readdir
+  var noReaddirOptionVersions = /^v[0-5]\./
+  function readdir (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    var go$readdir = noReaddirOptionVersions.test(process.version)
+      ? function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+      : function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, options, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+
+    return go$readdir(path, options, cb)
+
+    function fs$readdirCallback (path, options, cb, startTime) {
+      return function (err, files) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([
+            go$readdir,
+            [path, options, cb],
+            err,
+            startTime || Date.now(),
+            Date.now()
+          ])
+        else {
+          if (files && files.sort)
+            files.sort()
+
+          if (typeof cb === 'function')
+            cb.call(this, err, files)
+        }
+      }
+    }
+  }
+
+  if (process.version.substr(0, 4) === 'v0.8') {
+    var legStreams = legacy(fs)
+    ReadStream = legStreams.ReadStream
+    WriteStream = legStreams.WriteStream
+  }
+
+  var fs$ReadStream = fs.ReadStream
+  if (fs$ReadStream) {
+    ReadStream.prototype = Object.create(fs$ReadStream.prototype)
+    ReadStream.prototype.open = ReadStream$open
+  }
+
+  var fs$WriteStream = fs.WriteStream
+  if (fs$WriteStream) {
+    WriteStream.prototype = Object.create(fs$WriteStream.prototype)
+    WriteStream.prototype.open = WriteStream$open
+  }
+
+  Object.defineProperty(fs, 'ReadStream', {
+    get: function () {
+      return ReadStream
+    },
+    set: function (val) {
+      ReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  Object.defineProperty(fs, 'WriteStream', {
+    get: function () {
+      return WriteStream
+    },
+    set: function (val) {
+      WriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+
+  // legacy names
+  var FileReadStream = ReadStream
+  Object.defineProperty(fs, 'FileReadStream', {
+    get: function () {
+      return FileReadStream
+    },
+    set: function (val) {
+      FileReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  var FileWriteStream = WriteStream
+  Object.defineProperty(fs, 'FileWriteStream', {
+    get: function () {
+      return FileWriteStream
+    },
+    set: function (val) {
+      FileWriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+
+  function ReadStream (path, options) {
+    if (this instanceof ReadStream)
+      return fs$ReadStream.apply(this, arguments), this
+    else
+      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
+  }
+
+  function ReadStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        if (that.autoClose)
+          that.destroy()
+
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+        that.read()
+      }
+    })
+  }
+
+  function WriteStream (path, options) {
+    if (this instanceof WriteStream)
+      return fs$WriteStream.apply(this, arguments), this
+    else
+      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
+  }
+
+  function WriteStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        that.destroy()
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+      }
+    })
+  }
+
+  function createReadStream (path, options) {
+    return new fs.ReadStream(path, options)
+  }
+
+  function createWriteStream (path, options) {
+    return new fs.WriteStream(path, options)
+  }
+
+  var fs$open = fs.open
+  fs.open = open
+  function open (path, flags, mode, cb) {
+    if (typeof mode === 'function')
+      cb = mode, mode = null
+
+    return go$open(path, flags, mode, cb)
+
+    function go$open (path, flags, mode, cb, startTime) {
+      return fs$open(path, flags, mode, function (err, fd) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  return fs
+}
+
+function enqueue (elem) {
+  debug('ENQUEUE', elem[0].name, elem[1])
+  fs[gracefulQueue].push(elem)
+  retry()
+}
+
+// keep track of the timeout between retry() calls
+var retryTimer
+
+// reset the startTime and lastTime to now
+// this resets the start of the 60 second overall timeout as well as the
+// delay between attempts so that we'll retry these jobs sooner
+function resetQueue () {
+  var now = Date.now()
+  for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+    // entries that are only a length of 2 are from an older version, don't
+    // bother modifying those since they'll be retried anyway.
+    if (fs[gracefulQueue][i].length > 2) {
+      fs[gracefulQueue][i][3] = now // startTime
+      fs[gracefulQueue][i][4] = now // lastTime
+    }
+  }
+  // call retry to make sure we're actively processing the queue
+  retry()
+}
+
+function retry () {
+  // clear the timer and remove it to help prevent unintended concurrency
+  clearTimeout(retryTimer)
+  retryTimer = undefined
+
+  if (fs[gracefulQueue].length === 0)
+    return
+
+  var elem = fs[gracefulQueue].shift()
+  var fn = elem[0]
+  var args = elem[1]
+  // these items may be unset if they were added by an older graceful-fs
+  var err = elem[2]
+  var startTime = elem[3]
+  var lastTime = elem[4]
+
+  // if we don't have a startTime we have no way of knowing if we've waited
+  // long enough, so go ahead and retry this item now
+  if (startTime === undefined) {
+    debug('RETRY', fn.name, args)
+    fn.apply(null, args)
+  } else if (Date.now() - startTime >= 60000) {
+    // it's been more than 60 seconds total, bail now
+    debug('TIMEOUT', fn.name, args)
+    var cb = args.pop()
+    if (typeof cb === 'function')
+      cb.call(null, err)
+  } else {
+    // the amount of time between the last attempt and right now
+    var sinceAttempt = Date.now() - lastTime
+    // the amount of time between when we first tried, and when we last tried
+    // rounded up to at least 1
+    var sinceStart = Math.max(lastTime - startTime, 1)
+    // backoff. wait longer than the total time we've been retrying, but only
+    // up to a maximum of 100ms
+    var desiredDelay = Math.min(sinceStart * 1.2, 100)
+    // it's been long enough since the last retry, do it again
+    if (sinceAttempt >= desiredDelay) {
+      debug('RETRY', fn.name, args)
+      fn.apply(null, args.concat([startTime]))
+    } else {
+      // if we can't do this job yet, push it to the end of the queue
+      // and let the next iteration check again
+      fs[gracefulQueue].push(elem)
+    }
+  }
+
+  // schedule our next run if one isn't already scheduled
+  if (retryTimer === undefined) {
+    retryTimer = setTimeout(retry, 0)
+  }
+}
+
+
+/***/ }),
+
+/***/ 6465:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Stream = __webpack_require__(2413).Stream
+
+module.exports = legacy
+
+function legacy (fs) {
+  return {
+    ReadStream: ReadStream,
+    WriteStream: WriteStream
+  }
+
+  function ReadStream (path, options) {
+    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+
+    Stream.call(this);
+
+    var self = this;
+
+    this.path = path;
+    this.fd = null;
+    this.readable = true;
+    this.paused = false;
+
+    this.flags = 'r';
+    this.mode = 438; /*=0666*/
+    this.bufferSize = 64 * 1024;
+
+    options = options || {};
+
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
+
+    if (this.encoding) this.setEncoding(this.encoding);
+
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.end === undefined) {
+        this.end = Infinity;
+      } else if ('number' !== typeof this.end) {
+        throw TypeError('end must be a Number');
+      }
+
+      if (this.start > this.end) {
+        throw new Error('start must be <= end');
+      }
+
+      this.pos = this.start;
+    }
+
+    if (this.fd !== null) {
+      process.nextTick(function() {
+        self._read();
+      });
+      return;
+    }
+
+    fs.open(this.path, this.flags, this.mode, function (err, fd) {
+      if (err) {
+        self.emit('error', err);
+        self.readable = false;
+        return;
+      }
+
+      self.fd = fd;
+      self.emit('open', fd);
+      self._read();
+    })
+  }
+
+  function WriteStream (path, options) {
+    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+
+    Stream.call(this);
+
+    this.path = path;
+    this.fd = null;
+    this.writable = true;
+
+    this.flags = 'w';
+    this.encoding = 'binary';
+    this.mode = 438; /*=0666*/
+    this.bytesWritten = 0;
+
+    options = options || {};
+
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
+
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.start < 0) {
+        throw new Error('start must be >= zero');
+      }
+
+      this.pos = this.start;
+    }
+
+    this.busy = false;
+    this._queue = [];
+
+    if (this.fd === null) {
+      this._open = fs.open;
+      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+      this.flush();
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 4692:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var constants = __webpack_require__(7619)
+
+var origCwd = process.cwd
+var cwd = null
+
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
+
+process.cwd = function() {
+  if (!cwd)
+    cwd = origCwd.call(process)
+  return cwd
+}
+try {
+  process.cwd()
+} catch (er) {}
+
+// This check is needed until node.js 12 is required
+if (typeof process.chdir === 'function') {
+  var chdir = process.chdir
+  process.chdir = function (d) {
+    cwd = null
+    chdir.call(process, d)
+  }
+  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
+}
+
+module.exports = patch
+
+function patch (fs) {
+  // (re-)implement some things that are known busted or missing.
+
+  // lchmod, broken prior to 0.6.2
+  // back-port the fix here.
+  if (constants.hasOwnProperty('O_SYMLINK') &&
+      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+    patchLchmod(fs)
+  }
+
+  // lutimes implementation, or no-op
+  if (!fs.lutimes) {
+    patchLutimes(fs)
+  }
+
+  // https://github.com/isaacs/node-graceful-fs/issues/4
+  // Chown should not fail on einval or eperm if non-root.
+  // It should not fail on enosys ever, as this just indicates
+  // that a fs doesn't support the intended operation.
+
+  fs.chown = chownFix(fs.chown)
+  fs.fchown = chownFix(fs.fchown)
+  fs.lchown = chownFix(fs.lchown)
+
+  fs.chmod = chmodFix(fs.chmod)
+  fs.fchmod = chmodFix(fs.fchmod)
+  fs.lchmod = chmodFix(fs.lchmod)
+
+  fs.chownSync = chownFixSync(fs.chownSync)
+  fs.fchownSync = chownFixSync(fs.fchownSync)
+  fs.lchownSync = chownFixSync(fs.lchownSync)
+
+  fs.chmodSync = chmodFixSync(fs.chmodSync)
+  fs.fchmodSync = chmodFixSync(fs.fchmodSync)
+  fs.lchmodSync = chmodFixSync(fs.lchmodSync)
+
+  fs.stat = statFix(fs.stat)
+  fs.fstat = statFix(fs.fstat)
+  fs.lstat = statFix(fs.lstat)
+
+  fs.statSync = statFixSync(fs.statSync)
+  fs.fstatSync = statFixSync(fs.fstatSync)
+  fs.lstatSync = statFixSync(fs.lstatSync)
+
+  // if lchmod/lchown do not exist, then make them no-ops
+  if (fs.chmod && !fs.lchmod) {
+    fs.lchmod = function (path, mode, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchmodSync = function () {}
+  }
+  if (fs.chown && !fs.lchown) {
+    fs.lchown = function (path, uid, gid, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchownSync = function () {}
+  }
+
+  // on Windows, A/V software can lock the directory, causing this
+  // to fail with an EACCES or EPERM if the directory contains newly
+  // created files.  Try again on failure, for up to 60 seconds.
+
+  // Set the timeout this long because some Windows Anti-Virus, such as Parity
+  // bit9, may lock files for up to a minute, causing npm package install
+  // failures. Also, take care to yield the scheduler. Windows scheduling gives
+  // CPU to a busy looping process, which can cause the program causing the lock
+  // contention to be starved of CPU by node, so the contention doesn't resolve.
+  if (platform === "win32") {
+    fs.rename = typeof fs.rename !== 'function' ? fs.rename
+    : (function (fs$rename) {
+      function rename (from, to, cb) {
+        var start = Date.now()
+        var backoff = 0;
+        fs$rename(from, to, function CB (er) {
+          if (er
+              && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY")
+              && Date.now() - start < 60000) {
+            setTimeout(function() {
+              fs.stat(to, function (stater, st) {
+                if (stater && stater.code === "ENOENT")
+                  fs$rename(from, to, CB);
+                else
+                  cb(er)
+              })
+            }, backoff)
+            if (backoff < 100)
+              backoff += 10;
+            return;
+          }
+          if (cb) cb(er)
+        })
+      }
+      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename)
+      return rename
+    })(fs.rename)
+  }
+
+  // if read() returns EAGAIN, then just try it again.
+  fs.read = typeof fs.read !== 'function' ? fs.read
+  : (function (fs$read) {
+    function read (fd, buffer, offset, length, position, callback_) {
+      var callback
+      if (callback_ && typeof callback_ === 'function') {
+        var eagCounter = 0
+        callback = function (er, _, __) {
+          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+            eagCounter ++
+            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+          }
+          callback_.apply(this, arguments)
+        }
+      }
+      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+    }
+
+    // This ensures `util.promisify` works as it does for native `fs.read`.
+    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
+    return read
+  })(fs.read)
+
+  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
+  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+    var eagCounter = 0
+    while (true) {
+      try {
+        return fs$readSync.call(fs, fd, buffer, offset, length, position)
+      } catch (er) {
+        if (er.code === 'EAGAIN' && eagCounter < 10) {
+          eagCounter ++
+          continue
+        }
+        throw er
+      }
+    }
+  }})(fs.readSync)
+
+  function patchLchmod (fs) {
+    fs.lchmod = function (path, mode, callback) {
+      fs.open( path
+             , constants.O_WRONLY | constants.O_SYMLINK
+             , mode
+             , function (err, fd) {
+        if (err) {
+          if (callback) callback(err)
+          return
+        }
+        // prefer to return the chmod error, if one occurs,
+        // but still try to close, and report closing errors if they occur.
+        fs.fchmod(fd, mode, function (err) {
+          fs.close(fd, function(err2) {
+            if (callback) callback(err || err2)
+          })
+        })
+      })
+    }
+
+    fs.lchmodSync = function (path, mode) {
+      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
+
+      // prefer to return the chmod error, if one occurs,
+      // but still try to close, and report closing errors if they occur.
+      var threw = true
+      var ret
+      try {
+        ret = fs.fchmodSync(fd, mode)
+        threw = false
+      } finally {
+        if (threw) {
+          try {
+            fs.closeSync(fd)
+          } catch (er) {}
+        } else {
+          fs.closeSync(fd)
+        }
+      }
+      return ret
+    }
+  }
+
+  function patchLutimes (fs) {
+    if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+      fs.lutimes = function (path, at, mt, cb) {
+        fs.open(path, constants.O_SYMLINK, function (er, fd) {
+          if (er) {
+            if (cb) cb(er)
+            return
+          }
+          fs.futimes(fd, at, mt, function (er) {
+            fs.close(fd, function (er2) {
+              if (cb) cb(er || er2)
+            })
+          })
+        })
+      }
+
+      fs.lutimesSync = function (path, at, mt) {
+        var fd = fs.openSync(path, constants.O_SYMLINK)
+        var ret
+        var threw = true
+        try {
+          ret = fs.futimesSync(fd, at, mt)
+          threw = false
+        } finally {
+          if (threw) {
+            try {
+              fs.closeSync(fd)
+            } catch (er) {}
+          } else {
+            fs.closeSync(fd)
+          }
+        }
+        return ret
+      }
+
+    } else if (fs.futimes) {
+      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+      fs.lutimesSync = function () {}
+    }
+  }
+
+  function chmodFix (orig) {
+    if (!orig) return orig
+    return function (target, mode, cb) {
+      return orig.call(fs, target, mode, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
+
+  function chmodFixSync (orig) {
+    if (!orig) return orig
+    return function (target, mode) {
+      try {
+        return orig.call(fs, target, mode)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+
+  function chownFix (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid, cb) {
+      return orig.call(fs, target, uid, gid, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
+
+  function chownFixSync (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid) {
+      try {
+        return orig.call(fs, target, uid, gid)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+  function statFix (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options, cb) {
+      if (typeof options === 'function') {
+        cb = options
+        options = null
+      }
+      function callback (er, stats) {
+        if (stats) {
+          if (stats.uid < 0) stats.uid += 0x100000000
+          if (stats.gid < 0) stats.gid += 0x100000000
+        }
+        if (cb) cb.apply(this, arguments)
+      }
+      return options ? orig.call(fs, target, options, callback)
+        : orig.call(fs, target, callback)
+    }
+  }
+
+  function statFixSync (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options) {
+      var stats = options ? orig.call(fs, target, options)
+        : orig.call(fs, target)
+      if (stats) {
+        if (stats.uid < 0) stats.uid += 0x100000000
+        if (stats.gid < 0) stats.gid += 0x100000000
+      }
+      return stats;
+    }
+  }
+
+  // ENOSYS means that the fs doesn't support the op. Just ignore
+  // that, because it doesn't matter.
+  //
+  // if there's no getuid, or if getuid() is something other
+  // than 0, and the error is EINVAL or EPERM, then just ignore
+  // it.
+  //
+  // This specific case is a silent failure in cp, install, tar,
+  // and most other unix tools that manage permissions.
+  //
+  // When running as root, or if other types of errors are
+  // encountered, then it's strict.
+  function chownErOk (er) {
+    if (!er)
+      return true
+
+    if (er.code === "ENOSYS")
+      return true
+
+    var nonroot = !process.getuid || process.getuid() !== 0
+    if (nonroot) {
+      if (er.code === "EINVAL" || er.code === "EPERM")
+        return true
+    }
+
+    return false
+  }
+}
+
+
 /***/ }),
 
 /***/ 1611:
@@ -4624,7 +5597,7 @@ function sync (path, options) {
 
 var _fs
 try {
-  _fs = __webpack_require__(1317)
+  _fs = __webpack_require__(7156)
 } catch (_) {
   _fs = __webpack_require__(5747)
 }
@@ -8769,25 +9742,25 @@ async function matchPaths(configPatterns, workPath) {
         return [];
     }
     const patternPaths = await Promise.all(patterns.map(async (pattern) => {
-        const files = await build_utils_1.glob(pattern, workPath);
+        const files = await (0, build_utils_1.glob)(pattern, workPath);
         return Object.keys(files);
     }));
     return patternPaths.reduce((a, b) => a.concat(b), []);
 }
 async function bundleInstall(bundlePath, bundleDir, gemfilePath) {
-    build_utils_1.debug(`running "bundle install --deployment"...`);
-    const bundleAppConfig = await build_utils_1.getWriteableDirectory();
-    const gemfileContent = await fs_extra_1.readFile(gemfilePath, 'utf8');
+    (0, build_utils_1.debug)(`running "bundle install --deployment"...`);
+    const bundleAppConfig = await (0, build_utils_1.getWriteableDirectory)();
+    const gemfileContent = await (0, fs_extra_1.readFile)(gemfilePath, 'utf8');
     if (gemfileContent.includes('ruby "~> 2.7.x"')) {
         // Gemfile contains "2.7.x" which will cause an error message:
         // "Your Ruby patchlevel is 0, but your Gemfile specified -1"
         // See https://github.com/rubygems/bundler/blob/3f0638c6c8d340c2f2405ecb84eb3b39c433e36e/lib/bundler/errors.rb#L49
         // We must correct to the actual version in the build container.
-        await fs_extra_1.writeFile(gemfilePath, gemfileContent.replace('ruby "~> 2.7.x"', 'ruby "~> 2.7.0"'));
+        await (0, fs_extra_1.writeFile)(gemfilePath, gemfileContent.replace('ruby "~> 2.7.x"', 'ruby "~> 2.7.0"'));
     }
-    await execa_1.default(bundlePath, ['install', '--deployment', '--gemfile', gemfilePath, '--path', bundleDir], {
+    await (0, execa_1.default)(bundlePath, ['install', '--deployment', '--gemfile', gemfilePath, '--path', bundleDir], {
         stdio: 'pipe',
-        env: build_utils_1.cloneEnv(process.env, {
+        env: (0, build_utils_1.cloneEnv)(process.env, {
             BUNDLE_SILENCE_ROOT_WARNING: '1',
             BUNDLE_APP_CONFIG: bundleAppConfig,
             BUNDLE_JOBS: '4',
@@ -8796,50 +9769,50 @@ async function bundleInstall(bundlePath, bundleDir, gemfilePath) {
 }
 exports.version = 3;
 async function build({ workPath, files, entrypoint, config, meta = {}, }) {
-    await build_utils_1.download(files, workPath, meta);
-    const entrypointFsDirname = path_1.join(workPath, path_1.dirname(entrypoint));
+    await (0, build_utils_1.download)(files, workPath, meta);
+    const entrypointFsDirname = (0, path_1.join)(workPath, (0, path_1.dirname)(entrypoint));
     const gemfileName = 'Gemfile';
-    const gemfilePath = await build_utils_1.walkParentDirs({
+    const gemfilePath = await (0, build_utils_1.walkParentDirs)({
         base: workPath,
         start: entrypointFsDirname,
         filename: gemfileName,
     });
     const gemfileContents = gemfilePath
-        ? await fs_extra_1.readFile(gemfilePath, 'utf8')
+        ? await (0, fs_extra_1.readFile)(gemfilePath, 'utf8')
         : '';
-    const { gemHome, bundlerPath, vendorPath, runtime } = await install_ruby_1.installBundler(meta, gemfileContents);
+    const { gemHome, bundlerPath, vendorPath, runtime } = await (0, install_ruby_1.installBundler)(meta, gemfileContents);
     process.env.GEM_HOME = gemHome;
-    build_utils_1.debug(`Checking existing vendor directory at "${vendorPath}"`);
-    const vendorDir = path_1.join(workPath, vendorPath);
-    const bundleDir = path_1.join(workPath, 'vendor', 'bundle');
-    const relativeVendorDir = path_1.join(entrypointFsDirname, vendorPath);
-    const hasRootVendorDir = await fs_extra_1.pathExists(vendorDir);
-    const hasRelativeVendorDir = await fs_extra_1.pathExists(relativeVendorDir);
+    (0, build_utils_1.debug)(`Checking existing vendor directory at "${vendorPath}"`);
+    const vendorDir = (0, path_1.join)(workPath, vendorPath);
+    const bundleDir = (0, path_1.join)(workPath, 'vendor', 'bundle');
+    const relativeVendorDir = (0, path_1.join)(entrypointFsDirname, vendorPath);
+    const hasRootVendorDir = await (0, fs_extra_1.pathExists)(vendorDir);
+    const hasRelativeVendorDir = await (0, fs_extra_1.pathExists)(relativeVendorDir);
     const hasVendorDir = hasRootVendorDir || hasRelativeVendorDir;
     if (hasRelativeVendorDir) {
         if (hasRootVendorDir) {
-            build_utils_1.debug('found two vendor directories, choosing the vendor directory relative to entrypoint');
+            (0, build_utils_1.debug)('found two vendor directories, choosing the vendor directory relative to entrypoint');
         }
         else {
-            build_utils_1.debug('found vendor directory relative to entrypoint');
+            (0, build_utils_1.debug)('found vendor directory relative to entrypoint');
         }
         // vendor dir must be at the root for lambda to find it
-        await fs_extra_1.move(relativeVendorDir, vendorDir);
+        await (0, fs_extra_1.move)(relativeVendorDir, vendorDir);
     }
     else if (hasRootVendorDir) {
-        build_utils_1.debug('found vendor directory in project root');
+        (0, build_utils_1.debug)('found vendor directory in project root');
     }
-    await fs_extra_1.ensureDir(vendorDir);
+    await (0, fs_extra_1.ensureDir)(vendorDir);
     // no vendor directory, check for Gemfile to install
     if (!hasVendorDir) {
         if (gemfilePath) {
-            build_utils_1.debug('did not find a vendor directory but found a Gemfile, bundling gems...');
-            const fileAtRoot = path_1.relative(workPath, gemfilePath) === gemfileName;
+            (0, build_utils_1.debug)('did not find a vendor directory but found a Gemfile, bundling gems...');
+            const fileAtRoot = (0, path_1.relative)(workPath, gemfilePath) === gemfileName;
             // If the `Gemfile` is located in the Root Directory of the project and
             // the new File System API is used (`avoidTopLevelInstall`), the Install Command
             // will have already installed its dependencies, so we don't need to do it again.
             if (meta.avoidTopLevelInstall && fileAtRoot) {
-                build_utils_1.debug('Skipping `bundle install` — already handled by Install Command');
+                (0, build_utils_1.debug)('Skipping `bundle install` — already handled by Install Command');
             }
             else {
                 // try installing. this won't work if native extesions are required.
@@ -8849,27 +9822,27 @@ async function build({ workPath, files, entrypoint, config, meta = {}, }) {
         }
     }
     else {
-        build_utils_1.debug('found vendor directory, skipping "bundle install"...');
+        (0, build_utils_1.debug)('found vendor directory, skipping "bundle install"...');
     }
     // try to remove gem cache to slim bundle size
     try {
-        await fs_extra_1.remove(path_1.join(vendorDir, 'cache'));
+        await (0, fs_extra_1.remove)((0, path_1.join)(vendorDir, 'cache'));
     }
     catch (e) {
         // don't do anything here
     }
-    const originalRbPath = path_1.join(__dirname, '..', 'vc_init.rb');
-    const originalHandlerRbContents = await fs_extra_1.readFile(originalRbPath, 'utf8');
+    const originalRbPath = (0, path_1.join)(__dirname, '..', 'vc_init.rb');
+    const originalHandlerRbContents = await (0, fs_extra_1.readFile)(originalRbPath, 'utf8');
     // will be used on `require_relative '$here'` or for loading rack config.ru file
     // for example, `require_relative 'api/users'`
-    build_utils_1.debug('entrypoint is', entrypoint);
+    (0, build_utils_1.debug)('entrypoint is', entrypoint);
     const userHandlerFilePath = entrypoint.replace(/\.rb$/, '');
     const nowHandlerRbContents = originalHandlerRbContents.replace(/__VC_HANDLER_FILENAME/g, userHandlerFilePath);
     // in order to allow the user to have `server.rb`, we need our `server.rb` to be called
     // somethig else
     const handlerRbFilename = 'vc__handler__ruby';
-    await fs_extra_1.writeFile(path_1.join(workPath, `${handlerRbFilename}.rb`), nowHandlerRbContents);
-    const outputFiles = await build_utils_1.glob('**', workPath);
+    await (0, fs_extra_1.writeFile)((0, path_1.join)(workPath, `${handlerRbFilename}.rb`), nowHandlerRbContents);
+    const outputFiles = await (0, build_utils_1.glob)('**', workPath);
     // static analysis is impossible with ruby.
     // instead, provide `includeFiles` and `excludeFiles` config options to reduce bundle size.
     if (config && (config.includeFiles || config.excludeFiles)) {
@@ -8891,7 +9864,7 @@ async function build({ workPath, files, entrypoint, config, meta = {}, }) {
             delete outputFiles[excludedPaths[i]];
         }
     }
-    const lambda = await build_utils_1.createLambda({
+    const lambda = await (0, build_utils_1.createLambda)({
         files: outputFiles,
         handler: `${handlerRbFilename}.vc__handler`,
         runtime,
@@ -8950,7 +9923,7 @@ function getRubyPath(meta, gemfileContents) {
                 // The array is already in order so return the first
                 // match which will be the newest version.
                 selection = o;
-                return semver_1.intersects(o.range, strVersion);
+                return (0, semver_1.intersects)(o.range, strVersion);
             });
             if (!found) {
                 throw new build_utils_1.NowBuildError({
@@ -8976,11 +9949,11 @@ function getRubyPath(meta, gemfileContents) {
     const result = {
         gemHome,
         runtime,
-        rubyPath: path_1.join(gemHome, 'bin', 'ruby'),
-        gemPath: path_1.join(gemHome, 'bin', 'gem'),
+        rubyPath: (0, path_1.join)(gemHome, 'bin', 'ruby'),
+        gemPath: (0, path_1.join)(gemHome, 'bin', 'gem'),
         vendorPath: `vendor/bundle/ruby/${major}.${minor}.0`,
     };
-    build_utils_1.debug(JSON.stringify(result, null, ' '));
+    (0, build_utils_1.debug)(JSON.stringify(result, null, ' '));
     return result;
 }
 // downloads and installs `bundler` (respecting
@@ -8991,18 +9964,18 @@ async function installBundler(meta, gemfileContents) {
     // If the new File System API is used (`avoidTopLevelInstall`), the Install Command
     // will have already installed the dependencies, so we don't need to do it again.
     if (meta.avoidTopLevelInstall) {
-        build_utils_1.debug(`Skipping bundler installation, already installed by Install Command`);
+        (0, build_utils_1.debug)(`Skipping bundler installation, already installed by Install Command`);
         return {
             gemHome,
             rubyPath,
             gemPath,
             vendorPath,
             runtime,
-            bundlerPath: path_1.join(gemHome, 'bin', 'bundler'),
+            bundlerPath: (0, path_1.join)(gemHome, 'bin', 'bundler'),
         };
     }
-    build_utils_1.debug('installing bundler...');
-    await execa_1.default(gemPath, ['install', 'bundler', '--no-document'], {
+    (0, build_utils_1.debug)('installing bundler...');
+    await (0, execa_1.default)(gemPath, ['install', 'bundler', '--no-document'], {
         stdio: 'pipe',
         env: {
             GEM_HOME: gemHome,
@@ -9014,7 +9987,7 @@ async function installBundler(meta, gemfileContents) {
         gemPath,
         vendorPath,
         runtime,
-        bundlerPath: path_1.join(gemHome, 'bin', 'bundler'),
+        bundlerPath: (0, path_1.join)(gemHome, 'bin', 'bundler'),
     };
 }
 exports.installBundler = installBundler;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@vercel/ruby",
   "author": "Nathan Cahill <nathan@nathancahill.com>",
-  "version": "1.3.74",
-  "license": "MIT",
+  "version": "1.3.76",
+  "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/ruby",
   "files": [
@@ -22,12 +22,11 @@
   "devDependencies": {
     "@types/fs-extra": "8.0.0",
     "@types/semver": "6.0.0",
-    "@vercel/build-utils": "6.7.0",
+    "@vercel/build-utils": "6.7.2",
     "@vercel/ncc": "0.24.0",
     "execa": "2.0.4",
     "fs-extra": "^7.0.1",
-    "semver": "6.1.1",
-    "typescript": "4.3.4"
+    "semver": "6.1.1"
   },
-  "gitHead": "46348201b4eadb03b403f99dc5574c31d2b3926e"
+  "gitHead": "2de365f9cfea3ce283d2bf855507c71209f1e3d8"
 }