@vercel/build-utils 6.7.0 → 6.7.2

package/dist/index.js

@@ -8927,6 +8927,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
+  }
+}
+
+
 /***/ }),
 
 /***/ 8675:
@@ -16883,7 +17856,7 @@ module.exports = new Type('tag:yaml.org,2002:timestamp', {
 
 let _fs
 try {
-  _fs = __webpack_require__(1317)
+  _fs = __webpack_require__(7156)
 } catch (_) {
   _fs = __webpack_require__(5747)
 }
@@ -16994,16 +17967,16 @@ module.exports = { stringify, stripBom }
 
 /***/ }),
 
-/***/ 7767:
+/***/ 7345:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 module.exports = minimatch
 minimatch.Minimatch = Minimatch
 
-var path = { sep: '/' }
-try {
-  path = __webpack_require__(5622)
-} catch (er) {}
+var path = (function () { try { return __webpack_require__(5622) } catch (e) {}}()) || {
+  sep: '/'
+}
+minimatch.sep = path.sep
 
 var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
 var expand = __webpack_require__(490)
@@ -17055,43 +18028,64 @@ function filter (pattern, options) {
 }
 
 function ext (a, b) {
-  a = a || {}
   b = b || {}
   var t = {}
-  Object.keys(b).forEach(function (k) {
-    t[k] = b[k]
-  })
   Object.keys(a).forEach(function (k) {
     t[k] = a[k]
   })
+  Object.keys(b).forEach(function (k) {
+    t[k] = b[k]
+  })
   return t
 }
 
 minimatch.defaults = function (def) {
-  if (!def || !Object.keys(def).length) return minimatch
+  if (!def || typeof def !== 'object' || !Object.keys(def).length) {
+    return minimatch
+  }
 
   var orig = minimatch
 
   var m = function minimatch (p, pattern, options) {
-    return orig.minimatch(p, pattern, ext(def, options))
+    return orig(p, pattern, ext(def, options))
   }
 
   m.Minimatch = function Minimatch (pattern, options) {
     return new orig.Minimatch(pattern, ext(def, options))
   }
+  m.Minimatch.defaults = function defaults (options) {
+    return orig.defaults(ext(def, options)).Minimatch
+  }
+
+  m.filter = function filter (pattern, options) {
+    return orig.filter(pattern, ext(def, options))
+  }
+
+  m.defaults = function defaults (options) {
+    return orig.defaults(ext(def, options))
+  }
+
+  m.makeRe = function makeRe (pattern, options) {
+    return orig.makeRe(pattern, ext(def, options))
+  }
+
+  m.braceExpand = function braceExpand (pattern, options) {
+    return orig.braceExpand(pattern, ext(def, options))
+  }
+
+  m.match = function (list, pattern, options) {
+    return orig.match(list, pattern, ext(def, options))
+  }
 
   return m
 }
 
 Minimatch.defaults = function (def) {
-  if (!def || !Object.keys(def).length) return Minimatch
   return minimatch.defaults(def).Minimatch
 }
 
 function minimatch (p, pattern, options) {
-  if (typeof pattern !== 'string') {
-    throw new TypeError('glob pattern string required')
-  }
+  assertValidPattern(pattern)
 
   if (!options) options = {}
 
@@ -17100,9 +18094,6 @@ function minimatch (p, pattern, options) {
     return false
   }
 
-  // "" only matches ""
-  if (pattern.trim() === '') return p === ''
-
   return new Minimatch(pattern, options).match(p)
 }
 
@@ -17111,15 +18102,14 @@ function Minimatch (pattern, options) {
     return new Minimatch(pattern, options)
   }
 
-  if (typeof pattern !== 'string') {
-    throw new TypeError('glob pattern string required')
-  }
+  assertValidPattern(pattern)
 
   if (!options) options = {}
+
   pattern = pattern.trim()
 
   // windows support: need to use /, not \
-  if (path.sep !== '/') {
+  if (!options.allowWindowsEscape && path.sep !== '/') {
     pattern = pattern.split(path.sep).join('/')
   }
 
@@ -17130,6 +18120,7 @@ function Minimatch (pattern, options) {
   this.negate = false
   this.comment = false
   this.empty = false
+  this.partial = !!options.partial
 
   // make the set of regexps etc.
   this.make()
@@ -17139,9 +18130,6 @@ Minimatch.prototype.debug = function () {}
 
 Minimatch.prototype.make = make
 function make () {
-  // don't do it more than once.
-  if (this._made) return
-
   var pattern = this.pattern
   var options = this.options
 
@@ -17161,7 +18149,7 @@ function make () {
   // step 2: expand braces
   var set = this.globSet = this.braceExpand()
 
-  if (options.debug) this.debug = console.error
+  if (options.debug) this.debug = function debug() { console.error.apply(console, arguments) }
 
   this.debug(this.pattern, set)
 
@@ -17241,12 +18229,11 @@ function braceExpand (pattern, options) {
   pattern = typeof pattern === 'undefined'
     ? this.pattern : pattern
 
-  if (typeof pattern === 'undefined') {
-    throw new TypeError('undefined pattern')
-  }
+  assertValidPattern(pattern)
 
-  if (options.nobrace ||
-    !pattern.match(/\{.*\}/)) {
+  // Thanks to Yeting Li <https://github.com/yetingli> for
+  // improving this regexp to avoid a ReDOS vulnerability.
+  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
     // shortcut. no need to expand.
     return [pattern]
   }
@@ -17254,6 +18241,17 @@ function braceExpand (pattern, options) {
   return expand(pattern)
 }
 
+var MAX_PATTERN_LENGTH = 1024 * 64
+var assertValidPattern = function (pattern) {
+  if (typeof pattern !== 'string') {
+    throw new TypeError('invalid pattern')
+  }
+
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError('pattern is too long')
+  }
+}
+
 // parse a component of the expanded set.
 // At this point, no pattern may contain "/" in it
 // so we're going to return a 2d array, where each entry is the full
@@ -17268,14 +18266,17 @@ function braceExpand (pattern, options) {
 Minimatch.prototype.parse = parse
 var SUBPARSE = {}
 function parse (pattern, isSub) {
-  if (pattern.length > 1024 * 64) {
-    throw new TypeError('pattern is too long')
-  }
+  assertValidPattern(pattern)
 
   var options = this.options
 
   // shortcuts
-  if (!options.noglobstar && pattern === '**') return GLOBSTAR
+  if (pattern === '**') {
+    if (!options.noglobstar)
+      return GLOBSTAR
+    else
+      pattern = '*'
+  }
   if (pattern === '') return ''
 
   var re = ''
@@ -17331,10 +18332,12 @@ function parse (pattern, isSub) {
     }
 
     switch (c) {
-      case '/':
+      /* istanbul ignore next */
+      case '/': {
         // completely not allowed, even escaped.
         // Should already be path-split by now.
         return false
+      }
 
       case '\\':
         clearStateChar()
@@ -17453,25 +18456,23 @@ function parse (pattern, isSub) {
 
         // handle the case where we left a class open.
         // "[z-a]" is valid, equivalent to "\[z-a\]"
-        if (inClass) {
-          // split where the last [ was, make sure we don't have
-          // an invalid re. if so, re-walk the contents of the
-          // would-be class to re-translate any characters that
-          // were passed through as-is
-          // TODO: It would probably be faster to determine this
-          // without a try/catch and a new RegExp, but it's tricky
-          // to do safely.  For now, this is safe and works.
-          var cs = pattern.substring(classStart + 1, i)
-          try {
-            RegExp('[' + cs + ']')
-          } catch (er) {
-            // not a valid class!
-            var sp = this.parse(cs, SUBPARSE)
-            re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
-            hasMagic = hasMagic || sp[1]
-            inClass = false
-            continue
-          }
+        // split where the last [ was, make sure we don't have
+        // an invalid re. if so, re-walk the contents of the
+        // would-be class to re-translate any characters that
+        // were passed through as-is
+        // TODO: It would probably be faster to determine this
+        // without a try/catch and a new RegExp, but it's tricky
+        // to do safely.  For now, this is safe and works.
+        var cs = pattern.substring(classStart + 1, i)
+        try {
+          RegExp('[' + cs + ']')
+        } catch (er) {
+          // not a valid class!
+          var sp = this.parse(cs, SUBPARSE)
+          re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
+          hasMagic = hasMagic || sp[1]
+          inClass = false
+          continue
         }
 
         // finish up the class.
@@ -17555,9 +18556,7 @@ function parse (pattern, isSub) {
   // something that could conceivably capture a dot
   var addPatternStart = false
   switch (re.charAt(0)) {
-    case '.':
-    case '[':
-    case '(': addPatternStart = true
+    case '[': case '.': case '(': addPatternStart = true
   }
 
   // Hack to work around lack of negative lookbehind in JS
@@ -17619,7 +18618,7 @@ function parse (pattern, isSub) {
   var flags = options.nocase ? 'i' : ''
   try {
     var regExp = new RegExp('^' + re + '$', flags)
-  } catch (er) {
+  } catch (er) /* istanbul ignore next - should be impossible */ {
     // If it was an invalid regular expression, then it can't match
     // anything.  This trick looks for a character after the end of
     // the string, which is of course impossible, except in multi-line
@@ -17677,7 +18676,7 @@ function makeRe () {
 
   try {
     this.regexp = new RegExp(re, flags)
-  } catch (ex) {
+  } catch (ex) /* istanbul ignore next - should be impossible */ {
     this.regexp = false
   }
   return this.regexp
@@ -17695,8 +18694,8 @@ minimatch.match = function (list, pattern, options) {
   return list
 }
 
-Minimatch.prototype.match = match
-function match (f, partial) {
+Minimatch.prototype.match = function match (f, partial) {
+  if (typeof partial === 'undefined') partial = this.partial
   this.debug('match', f, this.pattern)
   // short-circuit in the case of busted things.
   // comments, etc.
@@ -17778,6 +18777,7 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
 
     // should be impossible.
     // some invalid regexp stuff in the set.
+    /* istanbul ignore if */
     if (p === false) return false
 
     if (p === GLOBSTAR) {
@@ -17851,6 +18851,7 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
       // no match was found.
       // However, in partial mode, we can't say this is necessarily over.
       // If there's more *pattern* left, then
+      /* istanbul ignore if */
       if (partial) {
         // ran out of file
         this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
@@ -17864,11 +18865,7 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
     // patterns with magic have been turned into regexps.
     var hit
     if (typeof p === 'string') {
-      if (options.nocase) {
-        hit = f.toLowerCase() === p.toLowerCase()
-      } else {
-        hit = f === p
-      }
+      hit = f === p
       this.debug('string match', p, f, hit)
     } else {
       hit = f.match(p)
@@ -17899,16 +18896,16 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
     // this is ok if we're doing the match as part of
     // a glob fs traversal.
     return partial
-  } else if (pi === pl) {
+  } else /* istanbul ignore else */ if (pi === pl) {
     // ran out of pattern, still have file left.
     // this is only acceptable if we're on the very last
     // empty segment of a file with a trailing slash.
     // a/* should match a/b/
-    var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
-    return emptyFileEnd
+    return (fi === fl - 1) && (file[fi] === '')
   }
 
   // should be unreachable.
+  /* istanbul ignore next */
   throw new Error('wtf?')
 }
 
@@ -30169,6 +31166,84 @@ function bufferIncludes(buffer, content) {
 }
 
 
+/***/ }),
+
+/***/ 9799:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.isSpawnError = exports.normalizeError = exports.errorToString = exports.isErrorLike = exports.isErrnoException = exports.isError = exports.isObject = void 0;
+/**
+ * A simple type guard for objects.
+ *
+ * @param obj - A possible object
+ */
+const isObject = (obj) => typeof obj === 'object' && obj !== null;
+exports.isObject = isObject;
+/**
+ * A type guard for `try...catch` errors.
+ *
+ * This function is based on:
+ * https://github.com/stdlib-js/assert-is-error
+ */
+const isError = (error) => {
+    if (!(0, exports.isObject)(error))
+        return false;
+    // Check for `Error` objects instantiated within the current global context.
+    if (error instanceof Error)
+        return true;
+    // Walk the prototype tree until we find a matching object.
+    while (error) {
+        if (Object.prototype.toString.call(error) === '[object Error]')
+            return true;
+        error = Object.getPrototypeOf(error);
+    }
+    return false;
+};
+exports.isError = isError;
+const isErrnoException = (error) => {
+    return (0, exports.isError)(error) && 'code' in error;
+};
+exports.isErrnoException = isErrnoException;
+/**
+ * A type guard for error-like objects.
+ */
+const isErrorLike = (error) => (0, exports.isObject)(error) && 'message' in error;
+exports.isErrorLike = isErrorLike;
+/**
+ * Parses errors to string, useful for getting the error message in a
+ * `try...catch` statement.
+ */
+const errorToString = (error, fallback) => {
+    if ((0, exports.isError)(error) || (0, exports.isErrorLike)(error))
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    return fallback ?? 'An unknown error has ocurred.';
+};
+exports.errorToString = errorToString;
+/**
+ * Normalizes unknown errors to the Error type, useful for working with errors
+ * in a `try...catch` statement.
+ */
+const normalizeError = (error) => {
+    if ((0, exports.isError)(error))
+        return error;
+    const errorMessage = (0, exports.errorToString)(error);
+    // Copy over additional properties if the object is error-like.
+    return (0, exports.isErrorLike)(error)
+        ? Object.assign(new Error(errorMessage), error)
+        : new Error(errorMessage);
+};
+exports.normalizeError = normalizeError;
+function isSpawnError(v) {
+    return (0, exports.isErrnoException)(v) && 'spawnargs' in v;
+}
+exports.isSpawnError = isSpawnError;
+//# sourceMappingURL=index.js.map
+
 /***/ }),
 
 /***/ 651:
@@ -30221,7 +31296,7 @@ exports.cloneEnv = cloneEnv;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const get_platform_env_1 = __webpack_require__(7060);
 function debug(message, ...additional) {
-    if (get_platform_env_1.getPlatformEnv('BUILDER_DEBUG')) {
+    if ((0, get_platform_env_1.getPlatformEnv)('BUILDER_DEBUG')) {
         console.log(message, ...additional);
     }
     else if (process.env.VERCEL_DEBUG_PREFIX) {
@@ -30368,16 +31443,16 @@ const assert_1 = __importDefault(__webpack_require__(2357));
 const into_stream_1 = __importDefault(__webpack_require__(6398));
 class FileBlob {
     constructor({ mode = 0o100644, contentType, data }) {
-        assert_1.default(typeof mode === 'number');
-        assert_1.default(typeof data === 'string' || Buffer.isBuffer(data));
+        (0, assert_1.default)(typeof mode === 'number');
+        (0, assert_1.default)(typeof data === 'string' || Buffer.isBuffer(data));
         this.type = 'FileBlob';
         this.mode = mode;
         this.contentType = contentType;
         this.data = data;
     }
     static async fromStream({ mode = 0o100644, contentType, stream, }) {
-        assert_1.default(typeof mode === 'number');
-        assert_1.default(typeof stream.pipe === 'function'); // is-stream
+        (0, assert_1.default)(typeof mode === 'number');
+        (0, assert_1.default)(typeof stream.pipe === 'function'); // is-stream
         const chunks = [];
         await new Promise((resolve, reject) => {
             stream.on('data', chunk => chunks.push(Buffer.from(chunk)));
@@ -30391,7 +31466,7 @@ class FileBlob {
         return this.toStream();
     }
     toStream() {
-        return into_stream_1.default(this.data);
+        return (0, into_stream_1.default)(this.data);
     }
 }
 exports.default = FileBlob;
@@ -30417,8 +31492,8 @@ const DEFAULT_SEMA = 20;
 const semaToPreventEMFILE = new async_sema_1.default(parseInt(process.env.VERCEL_INTERNAL_FILE_FS_REF_SEMA || String(DEFAULT_SEMA), 10) || DEFAULT_SEMA);
 class FileFsRef {
     constructor({ mode = 0o100644, contentType, fsPath }) {
-        assert_1.default(typeof mode === 'number');
-        assert_1.default(typeof fsPath === 'string');
+        (0, assert_1.default)(typeof mode === 'number');
+        (0, assert_1.default)(typeof fsPath === 'string');
         this.type = 'FileFsRef';
         this.mode = mode;
         this.contentType = contentType;
@@ -30433,9 +31508,9 @@ class FileFsRef {
         return new FileFsRef({ mode: m, contentType, fsPath });
     }
     static async fromStream({ mode = 0o100644, contentType, stream, fsPath, }) {
-        assert_1.default(typeof mode === 'number');
-        assert_1.default(typeof stream.pipe === 'function'); // is-stream
-        assert_1.default(typeof fsPath === 'string');
+        (0, assert_1.default)(typeof mode === 'number');
+        (0, assert_1.default)(typeof stream.pipe === 'function'); // is-stream
+        (0, assert_1.default)(typeof fsPath === 'string');
         await fs_extra_1.default.mkdirp(path_1.default.dirname(fsPath));
         await new Promise((resolve, reject) => {
             const dest = fs_extra_1.default.createWriteStream(fsPath, {
@@ -30459,7 +31534,7 @@ class FileFsRef {
     toStream() {
         let flag = false;
         // eslint-disable-next-line consistent-return
-        return multistream_1.default(cb => {
+        return (0, multistream_1.default)(cb => {
             if (flag)
                 return cb(null, null);
             flag = true;
@@ -30502,8 +31577,8 @@ class BailableError extends Error {
 }
 class FileRef {
     constructor({ mode = 0o100644, digest, contentType, mutable = false, }) {
-        assert_1.default(typeof mode === 'number');
-        assert_1.default(typeof digest === 'string');
+        (0, assert_1.default)(typeof mode === 'number');
+        (0, assert_1.default)(typeof digest === 'string');
         this.type = 'FileRef';
         this.mode = mode;
         this.digest = digest;
@@ -30534,8 +31609,8 @@ class FileRef {
         await semaToDownloadFromS3.acquire();
         // console.time(`downloading ${url}`);
         try {
-            return await async_retry_1.default(async () => {
-                const resp = await node_fetch_1.default(url);
+            return await (0, async_retry_1.default)(async () => {
+                const resp = await (0, node_fetch_1.default)(url);
                 if (!resp.ok) {
                     const error = new BailableError(`download: ${resp.status} ${resp.statusText} for ${url}`);
                     if (resp.status === 403)
@@ -30553,7 +31628,7 @@ class FileRef {
     toStream() {
         let flag = false;
         // eslint-disable-next-line consistent-return
-        return multistream_1.default(cb => {
+        return (0, multistream_1.default)(cb => {
             if (flag)
                 return cb(null, null);
             flag = true;
@@ -30599,13 +31674,13 @@ function isSymbolicLink(mode) {
 }
 exports.isSymbolicLink = isSymbolicLink;
 async function prepareSymlinkTarget(file, fsPath) {
-    const mkdirPromise = fs_extra_1.mkdirp(path_1.default.dirname(fsPath));
+    const mkdirPromise = (0, fs_extra_1.mkdirp)(path_1.default.dirname(fsPath));
     if (file.type === 'FileFsRef') {
-        const [target] = await Promise.all([fs_extra_1.readlink(file.fsPath), mkdirPromise]);
+        const [target] = await Promise.all([(0, fs_extra_1.readlink)(file.fsPath), mkdirPromise]);
         return target;
     }
     if (file.type === 'FileRef' || file.type === 'FileBlob') {
-        const targetPathBufferPromise = stream_to_buffer_1.default(await file.toStreamAsync());
+        const targetPathBufferPromise = (0, stream_to_buffer_1.default)(await file.toStreamAsync());
         const [targetPathBuffer] = await Promise.all([
             targetPathBufferPromise,
             mkdirPromise,
@@ -30617,8 +31692,8 @@ async function prepareSymlinkTarget(file, fsPath) {
 async function downloadFile(file, fsPath) {
     const { mode } = file;
     if (isDirectory(mode)) {
-        await fs_extra_1.mkdirp(fsPath);
-        await fs_extra_1.chmod(fsPath, mode);
+        await (0, fs_extra_1.mkdirp)(fsPath);
+        await (0, fs_extra_1.chmod)(fsPath, mode);
         return file_fs_ref_1.default.fromFsPath({ mode, fsPath });
     }
     // If the source is a symlink, try to create it instead of copying the file.
@@ -30626,7 +31701,7 @@ async function downloadFile(file, fsPath) {
     // enabled in the group policy. We may want to improve the error message.
     if (isSymbolicLink(mode)) {
         const target = await prepareSymlinkTarget(file, fsPath);
-        await fs_extra_1.symlink(target, fsPath);
+        await (0, fs_extra_1.symlink)(target, fsPath);
         return file_fs_ref_1.default.fromFsPath({ mode, fsPath });
     }
     const stream = file.toStream();
@@ -30635,7 +31710,7 @@ async function downloadFile(file, fsPath) {
 exports.downloadFile = downloadFile;
 async function removeFile(basePath, fileMatched) {
     const file = path_1.default.join(basePath, fileMatched);
-    await fs_extra_1.remove(file);
+    await (0, fs_extra_1.remove)(file);
 }
 async function download(files, basePath, meta) {
     const { isDev = false, skipDownload = false, filesChanged = null, filesRemoved = null, } = meta || {};
@@ -30645,7 +31720,7 @@ async function download(files, basePath, meta) {
         // source files are already available.
         return files;
     }
-    debug_1.default('Downloading deployment source files...');
+    (0, debug_1.default)('Downloading deployment source files...');
     const start = Date.now();
     const files2 = {};
     const filenames = Object.keys(files);
@@ -30678,7 +31753,7 @@ async function download(files, basePath, meta) {
         files2[name] = await downloadFile(file, fsPath);
     }));
     const duration = Date.now() - start;
-    debug_1.default(`Downloaded ${filenames.length} source files: ${duration}ms`);
+    (0, debug_1.default)(`Downloaded ${filenames.length} source files: ${duration}ms`);
     return files2;
 }
 exports.default = download;
@@ -30697,8 +31772,8 @@ const os_1 = __webpack_require__(2087);
 const fs_extra_1 = __webpack_require__(6365);
 async function getWritableDirectory() {
     const name = Math.floor(Math.random() * 0x7fffffff).toString(16);
-    const directory = path_1.join(os_1.tmpdir(), name);
-    await fs_extra_1.mkdirp(directory);
+    const directory = (0, path_1.join)((0, os_1.tmpdir)(), name);
+    await (0, fs_extra_1.mkdirp)(directory);
     return directory;
 }
 exports.default = getWritableDirectory;
@@ -30722,7 +31797,7 @@ const util_1 = __webpack_require__(1669);
 const fs_extra_1 = __webpack_require__(6365);
 const normalize_path_1 = __webpack_require__(6263);
 const file_fs_ref_1 = __importDefault(__webpack_require__(6274));
-const vanillaGlob = util_1.promisify(glob_1.default);
+const vanillaGlob = (0, util_1.promisify)(glob_1.default);
 async function glob(pattern, opts, mountpoint) {
     const options = typeof opts === 'string' ? { cwd: opts } : opts;
     if (!options.cwd) {
@@ -30745,15 +31820,15 @@ async function glob(pattern, opts, mountpoint) {
     const dirsWithEntries = new Set();
     for (const relativePath of files) {
         const absPath = path_1.default.join(options.cwd, relativePath);
-        const fsPath = normalize_path_1.normalizePath(absPath);
+        const fsPath = (0, normalize_path_1.normalizePath)(absPath);
         let stat = statCache[fsPath];
-        assert_1.default(stat, `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`);
+        (0, assert_1.default)(stat, `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`);
         const isSymlink = symlinks[fsPath];
         // When `follow` mode is enabled, ensure that the entry is not a symlink
         // that points to outside of `cwd`
         if (options.follow &&
-            (isSymlink || (await fs_extra_1.lstat(fsPath)).isSymbolicLink())) {
-            const target = await fs_extra_1.readlink(absPath);
+            (isSymlink || (await (0, fs_extra_1.lstat)(fsPath)).isSymbolicLink())) {
+            const target = await (0, fs_extra_1.readlink)(absPath);
             const absTarget = path_1.default.resolve(path_1.default.dirname(absPath), target);
             if (path_1.default.relative(options.cwd, absTarget).startsWith(`..${path_1.default.sep}`)) {
                 continue;
@@ -30761,7 +31836,7 @@ async function glob(pattern, opts, mountpoint) {
         }
         if (isSymlink || stat.isFile() || stat.isDirectory()) {
             if (isSymlink) {
-                stat = await fs_extra_1.lstat(absPath);
+                stat = await (0, fs_extra_1.lstat)(absPath);
             }
             // Some bookkeeping to track which directories already have entries within
             const dirname = path_1.default.dirname(relativePath);
@@ -30786,7 +31861,7 @@ async function glob(pattern, opts, mountpoint) {
             if (mountpoint) {
                 finalPath = path_1.default.join(mountpoint, finalPath);
             }
-            const fsPath = normalize_path_1.normalizePath(path_1.default.join(options.cwd, relativePath));
+            const fsPath = (0, normalize_path_1.normalizePath)(path_1.default.join(options.cwd, relativePath));
             const stat = statCache[fsPath];
             results[finalPath] = new file_fs_ref_1.default({ mode: stat.mode, fsPath });
         }
@@ -30854,12 +31929,12 @@ exports.getDiscontinuedNodeVersions = getDiscontinuedNodeVersions;
 async function getSupportedNodeVersion(engineRange, isAuto = false) {
     let selection = getLatestNodeVersion();
     if (engineRange) {
-        const found = semver_1.validRange(engineRange) &&
+        const found = (0, semver_1.validRange)(engineRange) &&
             getOptions().some(o => {
                 // the array is already in order so return the first
                 // match which will be the newest version of node
                 selection = o;
-                return semver_1.intersects(o.range, engineRange);
+                return (0, semver_1.intersects)(o.range, engineRange);
             });
         if (!found) {
             throw new errors_1.NowBuildError({
@@ -30877,7 +31952,7 @@ async function getSupportedNodeVersion(engineRange, isAuto = false) {
             message: `${intro} ${getHint(isAuto)}`,
         });
     }
-    debug_1.default(`Selected Node.js ${selection.range}`);
+    (0, debug_1.default)(`Selected Node.js ${selection.range}`);
     if (selection.discontinueDate) {
         const d = selection.discontinueDate.toISOString().split('T')[0];
         console.warn(`Error: Node.js version ${selection.range} has reached End-of-Life. Deployments created on or after ${d} will fail to build. ${getHint(isAuto)}`);
@@ -30925,14 +32000,18 @@ exports.readConfigFile = void 0;
 const js_yaml_1 = __importDefault(__webpack_require__(1452));
 const toml_1 = __importDefault(__webpack_require__(207));
 const fs_extra_1 = __webpack_require__(6365);
+const error_utils_1 = __webpack_require__(9799);
 async function readFileOrNull(file) {
     try {
-        const data = await fs_extra_1.readFile(file);
+        const data = await (0, fs_extra_1.readFile)(file);
         return data;
     }
-    catch (err) {
-        if (err.code !== 'ENOENT') {
-            throw err;
+    catch (error) {
+        if (!(0, error_utils_1.isErrnoException)(error)) {
+            throw error;
+        }
+        if (error.code !== 'ENOENT') {
+            throw error;
         }
     }
     return null;
@@ -31019,7 +32098,7 @@ function spawnAsync(command, args, opts = {}) {
     return new Promise((resolve, reject) => {
         const stderrLogs = [];
         opts = { stdio: 'inherit', ...opts };
-        const child = cross_spawn_1.default(command, args, opts);
+        const child = (0, cross_spawn_1.default)(command, args, opts);
         if (opts.stdio === 'pipe' && child.stderr) {
             child.stderr.on('data', data => stderrLogs.push(data));
         }
@@ -31044,9 +32123,9 @@ exports.spawnAsync = spawnAsync;
 function spawnCommand(command, options = {}) {
     const opts = { ...options, prettyCommand: command };
     if (process.platform === 'win32') {
-        return cross_spawn_1.default('cmd.exe', ['/C', command], opts);
+        return (0, cross_spawn_1.default)('cmd.exe', ['/C', command], opts);
     }
-    return cross_spawn_1.default('sh', ['-c', command], opts);
+    return (0, cross_spawn_1.default)('sh', ['-c', command], opts);
 }
 exports.spawnCommand = spawnCommand;
 async function execCommand(command, options = {}) {
@@ -31075,7 +32154,7 @@ async function chmodPlusX(fsPath) {
     await fs_extra_1.default.chmod(fsPath, base8);
 }
 async function runShellScript(fsPath, args = [], spawnOpts) {
-    assert_1.default(path_1.default.isAbsolute(fsPath));
+    (0, assert_1.default)(path_1.default.isAbsolute(fsPath));
     const destPath = path_1.default.dirname(fsPath);
     await chmodPlusX(fsPath);
     const command = `./${path_1.default.basename(fsPath)}`;
@@ -31089,7 +32168,7 @@ async function runShellScript(fsPath, args = [], spawnOpts) {
 exports.runShellScript = runShellScript;
 function getSpawnOptions(meta, nodeVersion) {
     const opts = {
-        env: clone_env_1.cloneEnv(process.env),
+        env: (0, clone_env_1.cloneEnv)(process.env),
     };
     if (!meta.isDev) {
         let found = false;
@@ -31111,7 +32190,7 @@ function getSpawnOptions(meta, nodeVersion) {
 }
 exports.getSpawnOptions = getSpawnOptions;
 async function getNodeVersion(destPath, nodeVersionFallback = process.env.VERCEL_PROJECT_SETTINGS_NODE_VERSION, config = {}, meta = {}) {
-    const latest = node_version_1.getLatestNodeVersion();
+    const latest = (0, node_version_1.getLatestNodeVersion)();
     if (meta.isDev) {
         // Use the system-installed version of `node` in PATH for `vercel dev`
         return { ...latest, runtime: 'nodejs' };
@@ -31121,23 +32200,23 @@ async function getNodeVersion(destPath, nodeVersionFallback = process.env.VERCEL
     let isAuto = true;
     if (packageJson?.engines?.node) {
         const { node } = packageJson.engines;
-        if (nodeVersion && semver_1.validRange(node) && !semver_1.intersects(nodeVersion, node)) {
+        if (nodeVersion && (0, semver_1.validRange)(node) && !(0, semver_1.intersects)(nodeVersion, node)) {
             console.warn(`Warning: Due to "engines": { "node": "${node}" } in your \`package.json\` file, the Node.js Version defined in your Project Settings ("${nodeVersion}") will not apply. Learn More: http://vercel.link/node-version`);
         }
-        else if (semver_1.coerce(node)?.raw === node) {
+        else if ((0, semver_1.coerce)(node)?.raw === node) {
             console.warn(`Warning: Detected "engines": { "node": "${node}" } in your \`package.json\` with major.minor.patch, but only major Node.js Version can be selected. Learn More: http://vercel.link/node-version`);
         }
-        else if (semver_1.validRange(node) && semver_1.intersects(`${latest.major + 1}.x`, node)) {
+        else if ((0, semver_1.validRange)(node) && (0, semver_1.intersects)(`${latest.major + 1}.x`, node)) {
             console.warn(`Warning: Detected "engines": { "node": "${node}" } in your \`package.json\` that will automatically upgrade when a new major Node.js Version is released. Learn More: http://vercel.link/node-version`);
         }
         nodeVersion = node;
         isAuto = false;
     }
-    return node_version_1.getSupportedNodeVersion(nodeVersion, isAuto);
+    return (0, node_version_1.getSupportedNodeVersion)(nodeVersion, isAuto);
 }
 exports.getNodeVersion = getNodeVersion;
 async function scanParentDirs(destPath, readPackageJson = false) {
-    assert_1.default(path_1.default.isAbsolute(destPath));
+    (0, assert_1.default)(path_1.default.isAbsolute(destPath));
     const pkgJsonPath = await walkParentDirs({
         base: '/',
         start: destPath,
@@ -31157,10 +32236,10 @@ async function scanParentDirs(destPath, readPackageJson = false) {
     const [hasYarnLock, packageLockJson, pnpmLockYaml] = await Promise.all([
         Boolean(yarnLockPath),
         npmLockPath
-            ? read_config_file_1.readConfigFile(npmLockPath)
+            ? (0, read_config_file_1.readConfigFile)(npmLockPath)
             : null,
         pnpmLockPath
-            ? read_config_file_1.readConfigFile(pnpmLockPath)
+            ? (0, read_config_file_1.readConfigFile)(pnpmLockPath)
             : null,
     ]);
     // Priority order is Yarn > pnpm > npm
@@ -31189,8 +32268,8 @@ async function scanParentDirs(destPath, readPackageJson = false) {
 }
 exports.scanParentDirs = scanParentDirs;
 async function walkParentDirs({ base, start, filename, }) {
-    assert_1.default(path_1.default.isAbsolute(base), 'Expected "base" to be absolute path');
-    assert_1.default(path_1.default.isAbsolute(start), 'Expected "start" to be absolute path');
+    (0, assert_1.default)(path_1.default.isAbsolute(base), 'Expected "base" to be absolute path');
+    (0, assert_1.default)(path_1.default.isAbsolute(start), 'Expected "start" to be absolute path');
     let parent = '';
     for (let current = start; base.length <= current.length; current = parent) {
         const fullPath = path_1.default.join(current, filename);
@@ -31229,10 +32308,10 @@ function isSet(v) {
 }
 async function runNpmInstall(destPath, args = [], spawnOpts, meta, nodeVersion) {
     if (meta?.isDev) {
-        debug_1.default('Skipping dependency installation because dev mode is enabled');
+        (0, debug_1.default)('Skipping dependency installation because dev mode is enabled');
         return false;
     }
-    assert_1.default(path_1.default.isAbsolute(destPath));
+    (0, assert_1.default)(path_1.default.isAbsolute(destPath));
     try {
         await runNpmInstallSema.acquire();
         const { cliType, packageJsonPath, lockfileVersion } = await scanParentDirs(destPath);
@@ -31253,9 +32332,9 @@ async function runNpmInstall(destPath, args = [], spawnOpts, meta, nodeVersion)
         }
         const installTime = Date.now();
         console.log('Installing dependencies...');
-        debug_1.default(`Installing to ${destPath}`);
+        (0, debug_1.default)(`Installing to ${destPath}`);
         const opts = { cwd: destPath, ...spawnOpts };
-        const env = clone_env_1.cloneEnv(opts.env || process.env);
+        const env = (0, clone_env_1.cloneEnv)(opts.env || process.env);
         delete env.NODE_ENV;
         opts.env = getEnvForPackageManager({
             cliType,
@@ -31316,7 +32395,7 @@ async function runNpmInstall(destPath, args = [], spawnOpts, meta, nodeVersion)
                 throw err;
             }
         }
-        debug_1.default(`Install complete [${Date.now() - installTime}ms]`);
+        (0, debug_1.default)(`Install complete [${Date.now() - installTime}ms]`);
         return true;
     }
     finally {
@@ -31378,7 +32457,7 @@ async function runCustomInstallCommand({ destPath, installCommand, nodeVersion,
         nodeVersion,
         env: spawnOpts?.env || {},
     });
-    debug_1.default(`Running with $PATH:`, env?.PATH || '');
+    (0, debug_1.default)(`Running with $PATH:`, env?.PATH || '');
     await execCommand(installCommand, {
         ...spawnOpts,
         env,
@@ -31387,12 +32466,12 @@ async function runCustomInstallCommand({ destPath, installCommand, nodeVersion,
 }
 exports.runCustomInstallCommand = runCustomInstallCommand;
 async function runPackageJsonScript(destPath, scriptNames, spawnOpts) {
-    assert_1.default(path_1.default.isAbsolute(destPath));
+    (0, assert_1.default)(path_1.default.isAbsolute(destPath));
     const { packageJson, cliType, lockfileVersion } = await scanParentDirs(destPath, true);
     const scriptName = getScriptName(packageJson, typeof scriptNames === 'string' ? [scriptNames] : scriptNames);
     if (!scriptName)
         return false;
-    debug_1.default('Running user script...');
+    (0, debug_1.default)('Running user script...');
     const runScriptTime = Date.now();
     const opts = {
         cwd: destPath,
@@ -31401,7 +32480,7 @@ async function runPackageJsonScript(destPath, scriptNames, spawnOpts) {
             cliType,
             lockfileVersion,
             nodeVersion: undefined,
-            env: clone_env_1.cloneEnv(process.env, spawnOpts?.env),
+            env: (0, clone_env_1.cloneEnv)(process.env, spawnOpts?.env),
         }),
     };
     if (cliType === 'npm') {
@@ -31415,26 +32494,26 @@ async function runPackageJsonScript(destPath, scriptNames, spawnOpts) {
     }
     console.log(`Running "${opts.prettyCommand}"`);
     await spawnAsync(cliType, ['run', scriptName], opts);
-    debug_1.default(`Script complete [${Date.now() - runScriptTime}ms]`);
+    (0, debug_1.default)(`Script complete [${Date.now() - runScriptTime}ms]`);
     return true;
 }
 exports.runPackageJsonScript = runPackageJsonScript;
 async function runBundleInstall(destPath, args = [], spawnOpts, meta) {
     if (meta && meta.isDev) {
-        debug_1.default('Skipping dependency installation because dev mode is enabled');
+        (0, debug_1.default)('Skipping dependency installation because dev mode is enabled');
         return;
     }
-    assert_1.default(path_1.default.isAbsolute(destPath));
+    (0, assert_1.default)(path_1.default.isAbsolute(destPath));
     const opts = { ...spawnOpts, cwd: destPath, prettyCommand: 'bundle install' };
     await spawnAsync('bundle', args.concat(['install']), opts);
 }
 exports.runBundleInstall = runBundleInstall;
 async function runPipInstall(destPath, args = [], spawnOpts, meta) {
     if (meta && meta.isDev) {
-        debug_1.default('Skipping dependency installation because dev mode is enabled');
+        (0, debug_1.default)('Skipping dependency installation because dev mode is enabled');
         return;
     }
-    assert_1.default(path_1.default.isAbsolute(destPath));
+    (0, assert_1.default)(path_1.default.isAbsolute(destPath));
     const opts = { ...spawnOpts, cwd: destPath, prettyCommand: 'pip3 install' };
     await spawnAsync('pip3', ['install', '--disable-pip-version-check', ...args], opts);
 }
@@ -31454,7 +32533,7 @@ exports.getScriptName = getScriptName;
  * @deprecate installDependencies() is deprecated.
  * Please use runNpmInstall() instead.
  */
-exports.installDependencies = util_1.deprecate(runNpmInstall, 'installDependencies() is deprecated. Please use runNpmInstall() instead.');
+exports.installDependencies = (0, util_1.deprecate)(runNpmInstall, 'installDependencies() is deprecated. Please use runNpmInstall() instead.');
 
 
 /***/ }),
@@ -31473,7 +32552,7 @@ function streamToBuffer(stream) {
     return new Promise((resolve, reject) => {
         const buffers = [];
         stream.on('data', buffers.push.bind(buffers));
-        end_of_stream_1.default(stream, err => {
+        (0, end_of_stream_1.default)(stream, err => {
             if (err) {
                 reject(err);
                 return;
@@ -31549,7 +32628,7 @@ async function default_1(downloadPath, rootDirectory) {
     if (ignoreContents.length === 0) {
         return () => false;
     }
-    const ignoreFilter = ignore_1.default().add(clearRelative(ignoreContents[0]));
+    const ignoreFilter = (0, ignore_1.default)().add(clearRelative(ignoreContents[0]));
     return function (p) {
         // we should not ignore now.json and vercel.json if it asked to.
         // we depend on these files for building the app with sourceless
@@ -31733,7 +32812,11 @@ async function linkOrCopy(srcFile, destFile) {
 
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -31845,7 +32928,7 @@ exports.getLambdaOptionsFromFunction = exports.createZip = exports.createLambda
 const assert_1 = __importDefault(__webpack_require__(2357));
 const async_sema_1 = __importDefault(__webpack_require__(2219));
 const yazl_1 = __webpack_require__(3044);
-const minimatch_1 = __importDefault(__webpack_require__(7767));
+const minimatch_1 = __importDefault(__webpack_require__(7345));
 const fs_extra_1 = __webpack_require__(6365);
 const download_1 = __webpack_require__(3166);
 const stream_to_buffer_1 = __importDefault(__webpack_require__(9688));
@@ -31853,39 +32936,39 @@ class Lambda {
     constructor(opts) {
         const { handler, runtime, maxDuration, memory, environment = {}, allowQuery, regions, supportsMultiPayloads, supportsWrapper, supportsResponseStreaming, experimentalResponseStreaming, operationType, framework, } = opts;
         if ('files' in opts) {
-            assert_1.default(typeof opts.files === 'object', '"files" must be an object');
+            (0, assert_1.default)(typeof opts.files === 'object', '"files" must be an object');
         }
         if ('zipBuffer' in opts) {
-            assert_1.default(Buffer.isBuffer(opts.zipBuffer), '"zipBuffer" must be a Buffer');
+            (0, assert_1.default)(Buffer.isBuffer(opts.zipBuffer), '"zipBuffer" must be a Buffer');
         }
-        assert_1.default(typeof handler === 'string', '"handler" is not a string');
-        assert_1.default(typeof runtime === 'string', '"runtime" is not a string');
-        assert_1.default(typeof environment === 'object', '"environment" is not an object');
+        (0, assert_1.default)(typeof handler === 'string', '"handler" is not a string');
+        (0, assert_1.default)(typeof runtime === 'string', '"runtime" is not a string');
+        (0, assert_1.default)(typeof environment === 'object', '"environment" is not an object');
         if (memory !== undefined) {
-            assert_1.default(typeof memory === 'number', '"memory" is not a number');
+            (0, assert_1.default)(typeof memory === 'number', '"memory" is not a number');
         }
         if (maxDuration !== undefined) {
-            assert_1.default(typeof maxDuration === 'number', '"maxDuration" is not a number');
+            (0, assert_1.default)(typeof maxDuration === 'number', '"maxDuration" is not a number');
         }
         if (allowQuery !== undefined) {
-            assert_1.default(Array.isArray(allowQuery), '"allowQuery" is not an Array');
-            assert_1.default(allowQuery.every(q => typeof q === 'string'), '"allowQuery" is not a string Array');
+            (0, assert_1.default)(Array.isArray(allowQuery), '"allowQuery" is not an Array');
+            (0, assert_1.default)(allowQuery.every(q => typeof q === 'string'), '"allowQuery" is not a string Array');
         }
         if (supportsMultiPayloads !== undefined) {
-            assert_1.default(typeof supportsMultiPayloads === 'boolean', '"supportsMultiPayloads" is not a boolean');
+            (0, assert_1.default)(typeof supportsMultiPayloads === 'boolean', '"supportsMultiPayloads" is not a boolean');
         }
         if (supportsWrapper !== undefined) {
-            assert_1.default(typeof supportsWrapper === 'boolean', '"supportsWrapper" is not a boolean');
+            (0, assert_1.default)(typeof supportsWrapper === 'boolean', '"supportsWrapper" is not a boolean');
         }
         if (regions !== undefined) {
-            assert_1.default(Array.isArray(regions), '"regions" is not an Array');
-            assert_1.default(regions.every(r => typeof r === 'string'), '"regions" is not a string Array');
+            (0, assert_1.default)(Array.isArray(regions), '"regions" is not an Array');
+            (0, assert_1.default)(regions.every(r => typeof r === 'string'), '"regions" is not a string Array');
         }
         if (framework !== undefined) {
-            assert_1.default(typeof framework === 'object', '"framework" is not an object');
-            assert_1.default(typeof framework.slug === 'string', '"framework.slug" is not a string');
+            (0, assert_1.default)(typeof framework === 'object', '"framework" is not an object');
+            (0, assert_1.default)(typeof framework.slug === 'string', '"framework.slug" is not a string');
             if (framework.version !== undefined) {
-                assert_1.default(typeof framework.version === 'string', '"framework.version" is not a string');
+                (0, assert_1.default)(typeof framework.version === 'string', '"framework.version" is not a string');
             }
         }
         this.type = 'Lambda';
@@ -31949,8 +33032,8 @@ async function createZip(files) {
     const symlinkTargets = new Map();
     for (const name of names) {
         const file = files[name];
-        if (file.mode && download_1.isSymbolicLink(file.mode) && file.type === 'FileFsRef') {
-            const symlinkTarget = await fs_extra_1.readlink(file.fsPath);
+        if (file.mode && (0, download_1.isSymbolicLink)(file.mode) && file.type === 'FileFsRef') {
+            const symlinkTarget = await (0, fs_extra_1.readlink)(file.fsPath);
             symlinkTargets.set(name, symlinkTarget);
         }
     }
@@ -31963,7 +33046,7 @@ async function createZip(files) {
             if (typeof symlinkTarget === 'string') {
                 zipFile.addBuffer(Buffer.from(symlinkTarget, 'utf8'), name, opts);
             }
-            else if (file.mode && download_1.isDirectory(file.mode)) {
+            else if (file.mode && (0, download_1.isDirectory)(file.mode)) {
                 zipFile.addEmptyDirectory(name, opts);
             }
             else {
@@ -31973,7 +33056,7 @@ async function createZip(files) {
             }
         }
         zipFile.end();
-        stream_to_buffer_1.default(zipFile.outputStream).then(resolve).catch(reject);
+        (0, stream_to_buffer_1.default)(zipFile.outputStream).then(resolve).catch(reject);
     });
     return zipBuffer;
 }
@@ -31981,7 +33064,7 @@ exports.createZip = createZip;
 async function getLambdaOptionsFromFunction({ sourceFile, config, }) {
     if (config?.functions) {
         for (const [pattern, fn] of Object.entries(config.functions)) {
-            if (sourceFile === pattern || minimatch_1.default(sourceFile, pattern)) {
+            if (sourceFile === pattern || (0, minimatch_1.default)(sourceFile, pattern)) {
                 return {
                     memory: fn.memory,
                     maxDuration: fn.maxDuration,
@@ -32177,7 +33260,7 @@ const shouldServe = ({ entrypoint, files, requestPath, }) => {
     if (entrypoint === requestPath && hasProp(files, entrypoint)) {
         return true;
     }
-    const { dir, name } = path_1.parse(entrypoint);
+    const { dir, name } = (0, path_1.parse)(entrypoint);
     if (name === 'index' && dir === requestPath && hasProp(files, entrypoint)) {
         return true;
     }