@vercel/build-utils 2.12.3-canary.9 → 2.13.0

package/dist/index.js

@@ -7657,6 +7657,476 @@ IconvLiteDecoderStream.prototype.collect = function(cb) {
 
 
 
+/***/ }),
+
+/***/ 3556:
+/***/ ((module) => {
+
+// A simple implementation of make-array
+function make_array (subject) {
+  return Array.isArray(subject)
+    ? subject
+    : [subject]
+}
+
+const REGEX_BLANK_LINE = /^\s+$/
+const REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\!/
+const REGEX_LEADING_EXCAPED_HASH = /^\\#/
+const SLASH = '/'
+const KEY_IGNORE = typeof Symbol !== 'undefined'
+  ? Symbol.for('node-ignore')
+  /* istanbul ignore next */
+  : 'node-ignore'
+
+const define = (object, key, value) =>
+  Object.defineProperty(object, key, {value})
+
+const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g
+
+// Sanitize the range of a regular expression
+// The cases are complicated, see test cases for details
+const sanitizeRange = range => range.replace(
+  REGEX_REGEXP_RANGE,
+  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)
+    ? match
+    // Invalid range (out of order) which is ok for gitignore rules but
+    //   fatal for JavaScript regular expression, so eliminate it.
+    : ''
+)
+
+// > If the pattern ends with a slash,
+// > it is removed for the purpose of the following description,
+// > but it would only find a match with a directory.
+// > In other words, foo/ will match a directory foo and paths underneath it,
+// > but will not match a regular file or a symbolic link foo
+// >  (this is consistent with the way how pathspec works in general in Git).
+// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
+// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
+//      you could use option `mark: true` with `glob`
+
+// '`foo/`' should not continue with the '`..`'
+const DEFAULT_REPLACER_PREFIX = [
+
+  // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+  [
+    // (a\ ) -> (a )
+    // (a  ) -> (a)
+    // (a \ ) -> (a  )
+    /\\?\s+$/,
+    match => match.indexOf('\\') === 0
+      ? ' '
+      : ''
+  ],
+
+  // replace (\ ) with ' '
+  [
+    /\\\s/g,
+    () => ' '
+  ],
+
+  // Escape metacharacters
+  // which is written down by users but means special for regular expressions.
+
+  // > There are 12 characters with special meanings:
+  // > - the backslash \,
+  // > - the caret ^,
+  // > - the dollar sign $,
+  // > - the period or dot .,
+  // > - the vertical bar or pipe symbol |,
+  // > - the question mark ?,
+  // > - the asterisk or star *,
+  // > - the plus sign +,
+  // > - the opening parenthesis (,
+  // > - the closing parenthesis ),
+  // > - and the opening square bracket [,
+  // > - the opening curly brace {,
+  // > These special characters are often called "metacharacters".
+  [
+    /[\\^$.|*+(){]/g,
+    match => `\\${match}`
+  ],
+
+  [
+    // > [abc] matches any character inside the brackets
+    // >    (in this case a, b, or c);
+    /\[([^\]/]*)($|\])/g,
+    (match, p1, p2) => p2 === ']'
+      ? `[${sanitizeRange(p1)}]`
+      : `\\${match}`
+  ],
+
+  [
+    // > a question mark (?) matches a single character
+    /(?!\\)\?/g,
+    () => '[^/]'
+  ],
+
+  // leading slash
+  [
+
+    // > A leading slash matches the beginning of the pathname.
+    // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+    // A leading slash matches the beginning of the pathname
+    /^\//,
+    () => '^'
+  ],
+
+  // replace special metacharacter slash after the leading slash
+  [
+    /\//g,
+    () => '\\/'
+  ],
+
+  [
+    // > A leading "**" followed by a slash means match in all directories.
+    // > For example, "**/foo" matches file or directory "foo" anywhere,
+    // > the same as pattern "foo".
+    // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+    // >   under directory "foo".
+    // Notice that the '*'s have been replaced as '\\*'
+    /^\^*\\\*\\\*\\\//,
+
+    // '**/foo' <-> 'foo'
+    () => '^(?:.*\\/)?'
+  ]
+]
+
+const DEFAULT_REPLACER_SUFFIX = [
+  // starting
+  [
+    // there will be no leading '/'
+    //   (which has been replaced by section "leading slash")
+    // If starts with '**', adding a '^' to the regular expression also works
+    /^(?=[^^])/,
+    function startingReplacer () {
+      return !/\/(?!$)/.test(this)
+        // > If the pattern does not contain a slash /,
+        // >   Git treats it as a shell glob pattern
+        // Actually, if there is only a trailing slash,
+        //   git also treats it as a shell glob pattern
+        ? '(?:^|\\/)'
+
+        // > Otherwise, Git treats the pattern as a shell glob suitable for
+        // >   consumption by fnmatch(3)
+        : '^'
+    }
+  ],
+
+  // two globstars
+  [
+    // Use lookahead assertions so that we could match more than one `'/**'`
+    /\\\/\\\*\\\*(?=\\\/|$)/g,
+
+    // Zero, one or several directories
+    // should not use '*', or it will be replaced by the next replacer
+
+    // Check if it is not the last `'/**'`
+    (match, index, str) => index + 6 < str.length
+
+      // case: /**/
+      // > A slash followed by two consecutive asterisks then a slash matches
+      // >   zero or more directories.
+      // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
+      // '/**/'
+      ? '(?:\\/[^\\/]+)*'
+
+      // case: /**
+      // > A trailing `"/**"` matches everything inside.
+
+      // #21: everything inside but it should not include the current folder
+      : '\\/.+'
+  ],
+
+  // intermediate wildcards
+  [
+    // Never replace escaped '*'
+    // ignore rule '\*' will match the path '*'
+
+    // 'abc.*/' -> go
+    // 'abc.*'  -> skip this rule
+    /(^|[^\\]+)\\\*(?=.+)/g,
+
+    // '*.js' matches '.js'
+    // '*.js' doesn't match 'abc'
+    (match, p1) => `${p1}[^\\/]*`
+  ],
+
+  // trailing wildcard
+  [
+    /(\^|\\\/)?\\\*$/,
+    (match, p1) => {
+      const prefix = p1
+        // '\^':
+        // '/*' does not match ''
+        // '/*' does not match everything
+
+        // '\\\/':
+        // 'abc/*' does not match 'abc/'
+        ? `${p1}[^/]+`
+
+        // 'a*' matches 'a'
+        // 'a*' matches 'aa'
+        : '[^/]*'
+
+      return `${prefix}(?=$|\\/$)`
+    }
+  ],
+
+  [
+    // unescape
+    /\\\\\\/g,
+    () => '\\'
+  ]
+]
+
+const POSITIVE_REPLACERS = [
+  ...DEFAULT_REPLACER_PREFIX,
+
+  // 'f'
+  // matches
+  // - /f(end)
+  // - /f/
+  // - (start)f(end)
+  // - (start)f/
+  // doesn't match
+  // - oof
+  // - foo
+  // pseudo:
+  // -> (^|/)f(/|$)
+
+  // ending
+  [
+    // 'js' will not match 'js.'
+    // 'ab' will not match 'abc'
+    /(?:[^*/])$/,
+
+    // 'js*' will not match 'a.js'
+    // 'js/' will not match 'a.js'
+    // 'js' will match 'a.js' and 'a.js/'
+    match => `${match}(?=$|\\/)`
+  ],
+
+  ...DEFAULT_REPLACER_SUFFIX
+]
+
+const NEGATIVE_REPLACERS = [
+  ...DEFAULT_REPLACER_PREFIX,
+
+  // #24, #38
+  // The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore)
+  // A negative pattern without a trailing wildcard should not
+  // re-include the things inside that directory.
+
+  // eg:
+  // ['node_modules/*', '!node_modules']
+  // should ignore `node_modules/a.js`
+  [
+    /(?:[^*])$/,
+    match => `${match}(?=$|\\/$)`
+  ],
+
+  ...DEFAULT_REPLACER_SUFFIX
+]
+
+// A simple cache, because an ignore rule only has only one certain meaning
+const cache = Object.create(null)
+
+// @param {pattern}
+const make_regex = (pattern, negative, ignorecase) => {
+  const r = cache[pattern]
+  if (r) {
+    return r
+  }
+
+  const replacers = negative
+    ? NEGATIVE_REPLACERS
+    : POSITIVE_REPLACERS
+
+  const source = replacers.reduce(
+    (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+    pattern
+  )
+
+  return cache[pattern] = ignorecase
+    ? new RegExp(source, 'i')
+    : new RegExp(source)
+}
+
+// > A blank line matches no files, so it can serve as a separator for readability.
+const checkPattern = pattern => pattern
+  && typeof pattern === 'string'
+  && !REGEX_BLANK_LINE.test(pattern)
+
+  // > A line starting with # serves as a comment.
+  && pattern.indexOf('#') !== 0
+
+const createRule = (pattern, ignorecase) => {
+  const origin = pattern
+  let negative = false
+
+  // > An optional prefix "!" which negates the pattern;
+  if (pattern.indexOf('!') === 0) {
+    negative = true
+    pattern = pattern.substr(1)
+  }
+
+  pattern = pattern
+  // > Put a backslash ("\") in front of the first "!" for patterns that
+  // >   begin with a literal "!", for example, `"\!important!.txt"`.
+  .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!')
+  // > Put a backslash ("\") in front of the first hash for patterns that
+  // >   begin with a hash.
+  .replace(REGEX_LEADING_EXCAPED_HASH, '#')
+
+  const regex = make_regex(pattern, negative, ignorecase)
+
+  return {
+    origin,
+    pattern,
+    negative,
+    regex
+  }
+}
+
+class IgnoreBase {
+  constructor ({
+    ignorecase = true
+  } = {}) {
+    this._rules = []
+    this._ignorecase = ignorecase
+    define(this, KEY_IGNORE, true)
+    this._initCache()
+  }
+
+  _initCache () {
+    this._cache = Object.create(null)
+  }
+
+  // @param {Array.<string>|string|Ignore} pattern
+  add (pattern) {
+    this._added = false
+
+    if (typeof pattern === 'string') {
+      pattern = pattern.split(/\r?\n/g)
+    }
+
+    make_array(pattern).forEach(this._addPattern, this)
+
+    // Some rules have just added to the ignore,
+    // making the behavior changed.
+    if (this._added) {
+      this._initCache()
+    }
+
+    return this
+  }
+
+  // legacy
+  addPattern (pattern) {
+    return this.add(pattern)
+  }
+
+  _addPattern (pattern) {
+    // #32
+    if (pattern && pattern[KEY_IGNORE]) {
+      this._rules = this._rules.concat(pattern._rules)
+      this._added = true
+      return
+    }
+
+    if (checkPattern(pattern)) {
+      const rule = createRule(pattern, this._ignorecase)
+      this._added = true
+      this._rules.push(rule)
+    }
+  }
+
+  filter (paths) {
+    return make_array(paths).filter(path => this._filter(path))
+  }
+
+  createFilter () {
+    return path => this._filter(path)
+  }
+
+  ignores (path) {
+    return !this._filter(path)
+  }
+
+  // @returns `Boolean` true if the `path` is NOT ignored
+  _filter (path, slices) {
+    if (!path) {
+      return false
+    }
+
+    if (path in this._cache) {
+      return this._cache[path]
+    }
+
+    if (!slices) {
+      // path/to/a.js
+      // ['path', 'to', 'a.js']
+      slices = path.split(SLASH)
+    }
+
+    slices.pop()
+
+    return this._cache[path] = slices.length
+      // > It is not possible to re-include a file if a parent directory of
+      // >   that file is excluded.
+      // If the path contains a parent directory, check the parent first
+      ? this._filter(slices.join(SLASH) + SLASH, slices)
+        && this._test(path)
+
+      // Or only test the path
+      : this._test(path)
+  }
+
+  // @returns {Boolean} true if a file is NOT ignored
+  _test (path) {
+    // Explicitly define variable type by setting matched to `0`
+    let matched = 0
+
+    this._rules.forEach(rule => {
+      // if matched = true, then we only test negative rules
+      // if matched = false, then we test non-negative rules
+      if (!(matched ^ rule.negative)) {
+        matched = rule.negative ^ rule.regex.test(path)
+      }
+    })
+
+    return !matched
+  }
+}
+
+// Windows
+// --------------------------------------------------------------
+/* istanbul ignore if  */
+if (
+  // Detect `process` so that it can run in browsers.
+  typeof process !== 'undefined'
+  && (
+    process.env && process.env.IGNORE_TEST_WIN32
+    || process.platform === 'win32'
+  )
+) {
+  const filter = IgnoreBase.prototype._filter
+
+  /* eslint no-control-regex: "off" */
+  const make_posix = str => /^\\\\\?\\/.test(str)
+  || /[^\x00-\x80]+/.test(str)
+    ? str
+    : str.replace(/\\/g, '/')
+
+  IgnoreBase.prototype._filter = function filterWin32 (path, slices) {
+    path = make_posix(path)
+    return filter.call(this, path, slices)
+  }
+}
+
+module.exports = options => new IgnoreBase(options)
+
+
 /***/ }),
 
 /***/ 9442:
@@ -8056,147 +8526,6 @@ function sync (path, options) {
 }
 
 
-/***/ }),
-
-/***/ 1215:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var _fs
-try {
-  _fs = __webpack_require__(552)
-} catch (_) {
-  _fs = __webpack_require__(5747)
-}
-
-function readFile (file, options, callback) {
-  if (callback == null) {
-    callback = options
-    options = {}
-  }
-
-  if (typeof options === 'string') {
-    options = {encoding: options}
-  }
-
-  options = options || {}
-  var fs = options.fs || _fs
-
-  var shouldThrow = true
-  if ('throws' in options) {
-    shouldThrow = options.throws
-  }
-
-  fs.readFile(file, options, function (err, data) {
-    if (err) return callback(err)
-
-    data = stripBom(data)
-
-    var obj
-    try {
-      obj = JSON.parse(data, options ? options.reviver : null)
-    } catch (err2) {
-      if (shouldThrow) {
-        err2.message = file + ': ' + err2.message
-        return callback(err2)
-      } else {
-        return callback(null, null)
-      }
-    }
-
-    callback(null, obj)
-  })
-}
-
-function readFileSync (file, options) {
-  options = options || {}
-  if (typeof options === 'string') {
-    options = {encoding: options}
-  }
-
-  var fs = options.fs || _fs
-
-  var shouldThrow = true
-  if ('throws' in options) {
-    shouldThrow = options.throws
-  }
-
-  try {
-    var content = fs.readFileSync(file, options)
-    content = stripBom(content)
-    return JSON.parse(content, options.reviver)
-  } catch (err) {
-    if (shouldThrow) {
-      err.message = file + ': ' + err.message
-      throw err
-    } else {
-      return null
-    }
-  }
-}
-
-function stringify (obj, options) {
-  var spaces
-  var EOL = '\n'
-  if (typeof options === 'object' && options !== null) {
-    if (options.spaces) {
-      spaces = options.spaces
-    }
-    if (options.EOL) {
-      EOL = options.EOL
-    }
-  }
-
-  var str = JSON.stringify(obj, options ? options.replacer : null, spaces)
-
-  return str.replace(/\n/g, EOL) + EOL
-}
-
-function writeFile (file, obj, options, callback) {
-  if (callback == null) {
-    callback = options
-    options = {}
-  }
-  options = options || {}
-  var fs = options.fs || _fs
-
-  var str = ''
-  try {
-    str = stringify(obj, options)
-  } catch (err) {
-    // Need to return whether a callback was passed or not
-    if (callback) callback(err, null)
-    return
-  }
-
-  fs.writeFile(file, str, options, callback)
-}
-
-function writeFileSync (file, obj, options) {
-  options = options || {}
-  var fs = options.fs || _fs
-
-  var str = stringify(obj, options)
-  // not sure if fs.writeFileSync returns anything, but just in case
-  return fs.writeFileSync(file, str, options)
-}
-
-function stripBom (content) {
-  // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
-  if (Buffer.isBuffer(content)) content = content.toString('utf8')
-  content = content.replace(/^\uFEFF/, '')
-  return content
-}
-
-var jsonfile = {
-  readFile: readFile,
-  readFileSync: readFileSync,
-  writeFile: writeFile,
-  writeFileSync: writeFileSync
-}
-
-module.exports = jsonfile
-
-
 /***/ }),
 
 /***/ 9566:
@@ -14012,39 +14341,6 @@ SafeBuffer.allocUnsafeSlow = function (size) {
 }
 
 
-/***/ }),
-
-/***/ 2703:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-
-exports.E = function (fn) {
-  return Object.defineProperty(function () {
-    if (typeof arguments[arguments.length - 1] === 'function') fn.apply(this, arguments)
-    else {
-      return new Promise((resolve, reject) => {
-        arguments[arguments.length] = (err, res) => {
-          if (err) return reject(err)
-          resolve(res)
-        }
-        arguments.length++
-        fn.apply(this, arguments)
-      })
-    }
-  }, 'name', { value: fn.name })
-}
-
-exports.p = function (fn) {
-  return Object.defineProperty(function () {
-    const cb = arguments[arguments.length - 1]
-    if (typeof cb !== 'function') return fn.apply(this, arguments)
-    else fn.apply(this, arguments).then(r => cb(null, r), cb)
-  }, 'name', { value: fn.name })
-}
-
-
 /***/ }),
 
 /***/ 9209:
@@ -16877,14 +17173,13 @@ module.exports = eos;
 
 const fs = __webpack_require__(552)
 const path = __webpack_require__(5622)
-const mkdirpSync = __webpack_require__(9181).mkdirsSync
-const utimesSync = __webpack_require__(8605).utimesMillisSync
-
-const notExist = Symbol('notExist')
+const mkdirsSync = __webpack_require__(9181).mkdirsSync
+const utimesMillisSync = __webpack_require__(8605).utimesMillisSync
+const stat = __webpack_require__(9783)
 
 function copySync (src, dest, opts) {
   if (typeof opts === 'function') {
-    opts = {filter: opts}
+    opts = { filter: opts }
   }
 
   opts = opts || {}
@@ -16897,13 +17192,16 @@ function copySync (src, dest, opts) {
     see https://github.com/jprichardson/node-fs-extra/issues/269`)
   }
 
-  const destStat = checkPaths(src, dest)
+  const { srcStat, destStat } = stat.checkPathsSync(src, dest, 'copy', opts)
+  stat.checkParentPathsSync(src, srcStat, dest, 'copy')
+  return handleFilterAndCopy(destStat, src, dest, opts)
+}
 
+function handleFilterAndCopy (destStat, src, dest, opts) {
   if (opts.filter && !opts.filter(src, dest)) return
-
   const destParent = path.dirname(dest)
-  if (!fs.existsSync(destParent)) mkdirpSync(destParent)
-  return startCopy(destStat, src, dest, opts)
+  if (!fs.existsSync(destParent)) mkdirsSync(destParent)
+  return getStats(destStat, src, dest, opts)
 }
 
 function startCopy (destStat, src, dest, opts) {
@@ -16920,10 +17218,13 @@ function getStats (destStat, src, dest, opts) {
            srcStat.isCharacterDevice() ||
            srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts)
   else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)
+  else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)
+  else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)
+  throw new Error(`Unknown file: ${src}`)
 }
 
 function onFile (srcStat, destStat, src, dest, opts) {
-  if (destStat === notExist) return copyFile(srcStat, src, dest, opts)
+  if (!destStat) return copyFile(srcStat, src, dest, opts)
   return mayCopyFile(srcStat, src, dest, opts)
 }
 
@@ -16937,49 +17238,48 @@ function mayCopyFile (srcStat, src, dest, opts) {
 }
 
 function copyFile (srcStat, src, dest, opts) {
-  if (typeof fs.copyFileSync === 'function') {
-    fs.copyFileSync(src, dest)
-    fs.chmodSync(dest, srcStat.mode)
-    if (opts.preserveTimestamps) {
-      return utimesSync(dest, srcStat.atime, srcStat.mtime)
-    }
-    return
-  }
-  return copyFileFallback(srcStat, src, dest, opts)
+  fs.copyFileSync(src, dest)
+  if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest)
+  return setDestMode(dest, srcStat.mode)
 }
 
-function copyFileFallback (srcStat, src, dest, opts) {
-  const BUF_LENGTH = 64 * 1024
-  const _buff = __webpack_require__(6343)(BUF_LENGTH)
+function handleTimestamps (srcMode, src, dest) {
+  // Make sure the file is writable before setting the timestamp
+  // otherwise open fails with EPERM when invoked with 'r+'
+  // (through utimes call)
+  if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode)
+  return setDestTimestamps(src, dest)
+}
 
-  const fdr = fs.openSync(src, 'r')
-  const fdw = fs.openSync(dest, 'w', srcStat.mode)
-  let pos = 0
+function fileIsNotWritable (srcMode) {
+  return (srcMode & 0o200) === 0
+}
 
-  while (pos < srcStat.size) {
-    const bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos)
-    fs.writeSync(fdw, _buff, 0, bytesRead)
-    pos += bytesRead
-  }
+function makeFileWritable (dest, srcMode) {
+  return setDestMode(dest, srcMode | 0o200)
+}
 
-  if (opts.preserveTimestamps) fs.futimesSync(fdw, srcStat.atime, srcStat.mtime)
+function setDestMode (dest, srcMode) {
+  return fs.chmodSync(dest, srcMode)
+}
 
-  fs.closeSync(fdr)
-  fs.closeSync(fdw)
+function setDestTimestamps (src, dest) {
+  // The initial srcStat.atime cannot be trusted
+  // because it is modified by the read(2) system call
+  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
+  const updatedSrcStat = fs.statSync(src)
+  return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
 }
 
 function onDir (srcStat, destStat, src, dest, opts) {
-  if (destStat === notExist) return mkDirAndCopy(srcStat, src, dest, opts)
-  if (destStat && !destStat.isDirectory()) {
-    throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
-  }
+  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts)
   return copyDir(src, dest, opts)
 }
 
-function mkDirAndCopy (srcStat, src, dest, opts) {
+function mkDirAndCopy (srcMode, src, dest, opts) {
   fs.mkdirSync(dest)
   copyDir(src, dest, opts)
-  return fs.chmodSync(dest, srcStat.mode)
+  return setDestMode(dest, srcMode)
 }
 
 function copyDir (src, dest, opts) {
@@ -16989,18 +17289,17 @@ function copyDir (src, dest, opts) {
 function copyDirItem (item, src, dest, opts) {
   const srcItem = path.join(src, item)
   const destItem = path.join(dest, item)
-  const destStat = checkPaths(srcItem, destItem)
+  const { destStat } = stat.checkPathsSync(srcItem, destItem, 'copy', opts)
   return startCopy(destStat, srcItem, destItem, opts)
 }
 
 function onLink (destStat, src, dest, opts) {
   let resolvedSrc = fs.readlinkSync(src)
-
   if (opts.dereference) {
     resolvedSrc = path.resolve(process.cwd(), resolvedSrc)
   }
 
-  if (destStat === notExist) {
+  if (!destStat) {
     return fs.symlinkSync(resolvedSrc, dest)
   } else {
     let resolvedDest
@@ -17016,14 +17315,14 @@ function onLink (destStat, src, dest, opts) {
     if (opts.dereference) {
       resolvedDest = path.resolve(process.cwd(), resolvedDest)
     }
-    if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+    if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
       throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
     }
 
     // prevent copy if src is a subdir of dest since unlinking
     // dest in this case would result in removing src contents
     // and therefore a broken symlink would be created.
-    if (fs.statSync(dest).isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
+    if (fs.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
       throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
     }
     return copyLink(resolvedSrc, dest)
@@ -17035,37 +17334,7 @@ function copyLink (resolvedSrc, dest) {
   return fs.symlinkSync(resolvedSrc, dest)
 }
 
-// return true if dest is a subdir of src, otherwise false.
-function isSrcSubdir (src, dest) {
-  const srcArray = path.resolve(src).split(path.sep)
-  const destArray = path.resolve(dest).split(path.sep)
-  return srcArray.reduce((acc, current, i) => acc && destArray[i] === current, true)
-}
-
-function checkStats (src, dest) {
-  const srcStat = fs.statSync(src)
-  let destStat
-  try {
-    destStat = fs.statSync(dest)
-  } catch (err) {
-    if (err.code === 'ENOENT') return {srcStat, destStat: notExist}
-    throw err
-  }
-  return {srcStat, destStat}
-}
-
-function checkPaths (src, dest) {
-  const {srcStat, destStat} = checkStats(src, dest)
-  if (destStat.ino && destStat.ino === srcStat.ino) {
-    throw new Error('Source and destination must not be the same.')
-  }
-  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-    throw new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`)
-  }
-  return destStat
-}
-
-module.exports = copySync
+module.exports = copySync
 
 
 /***/ }),
@@ -17091,18 +17360,17 @@ module.exports = {
 
 const fs = __webpack_require__(552)
 const path = __webpack_require__(5622)
-const mkdirp = __webpack_require__(9181).mkdirs
+const mkdirs = __webpack_require__(9181).mkdirs
 const pathExists = __webpack_require__(5516).pathExists
-const utimes = __webpack_require__(8605).utimesMillis
-
-const notExist = Symbol('notExist')
+const utimesMillis = __webpack_require__(8605).utimesMillis
+const stat = __webpack_require__(9783)
 
 function copy (src, dest, opts, cb) {
   if (typeof opts === 'function' && !cb) {
     cb = opts
     opts = {}
   } else if (typeof opts === 'function') {
-    opts = {filter: opts}
+    opts = { filter: opts }
   }
 
   cb = cb || function () {}
@@ -17117,10 +17385,14 @@ function copy (src, dest, opts, cb) {
     see https://github.com/jprichardson/node-fs-extra/issues/269`)
   }
 
-  checkPaths(src, dest, (err, destStat) => {
+  stat.checkPaths(src, dest, 'copy', opts, (err, stats) => {
     if (err) return cb(err)
-    if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb)
-    return checkParentDir(destStat, src, dest, opts, cb)
+    const { srcStat, destStat } = stats
+    stat.checkParentPaths(src, srcStat, dest, 'copy', err => {
+      if (err) return cb(err)
+      if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb)
+      return checkParentDir(destStat, src, dest, opts, cb)
+    })
   })
 }
 
@@ -17128,20 +17400,17 @@ function checkParentDir (destStat, src, dest, opts, cb) {
   const destParent = path.dirname(dest)
   pathExists(destParent, (err, dirExists) => {
     if (err) return cb(err)
-    if (dirExists) return startCopy(destStat, src, dest, opts, cb)
-    mkdirp(destParent, err => {
+    if (dirExists) return getStats(destStat, src, dest, opts, cb)
+    mkdirs(destParent, err => {
       if (err) return cb(err)
-      return startCopy(destStat, src, dest, opts, cb)
+      return getStats(destStat, src, dest, opts, cb)
     })
   })
 }
 
 function handleFilter (onInclude, destStat, src, dest, opts, cb) {
   Promise.resolve(opts.filter(src, dest)).then(include => {
-    if (include) {
-      if (destStat) return onInclude(destStat, src, dest, opts, cb)
-      return onInclude(src, dest, opts, cb)
-    }
+    if (include) return onInclude(destStat, src, dest, opts, cb)
     return cb()
   }, error => cb(error))
 }
@@ -17161,11 +17430,14 @@ function getStats (destStat, src, dest, opts, cb) {
              srcStat.isCharacterDevice() ||
              srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb)
     else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb)
+    else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`))
+    else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`))
+    return cb(new Error(`Unknown file: ${src}`))
   })
 }
 
 function onFile (srcStat, destStat, src, dest, opts, cb) {
-  if (destStat === notExist) return copyFile(srcStat, src, dest, opts, cb)
+  if (!destStat) return copyFile(srcStat, src, dest, opts, cb)
   return mayCopyFile(srcStat, src, dest, opts, cb)
 }
 
@@ -17181,49 +17453,66 @@ function mayCopyFile (srcStat, src, dest, opts, cb) {
 }
 
 function copyFile (srcStat, src, dest, opts, cb) {
-  if (typeof fs.copyFile === 'function') {
-    return fs.copyFile(src, dest, err => {
+  fs.copyFile(src, dest, err => {
+    if (err) return cb(err)
+    if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb)
+    return setDestMode(dest, srcStat.mode, cb)
+  })
+}
+
+function handleTimestampsAndMode (srcMode, src, dest, cb) {
+  // Make sure the file is writable before setting the timestamp
+  // otherwise open fails with EPERM when invoked with 'r+'
+  // (through utimes call)
+  if (fileIsNotWritable(srcMode)) {
+    return makeFileWritable(dest, srcMode, err => {
       if (err) return cb(err)
-      return setDestModeAndTimestamps(srcStat, dest, opts, cb)
+      return setDestTimestampsAndMode(srcMode, src, dest, cb)
     })
   }
-  return copyFileFallback(srcStat, src, dest, opts, cb)
+  return setDestTimestampsAndMode(srcMode, src, dest, cb)
 }
 
-function copyFileFallback (srcStat, src, dest, opts, cb) {
-  const rs = fs.createReadStream(src)
-  rs.on('error', err => cb(err)).once('open', () => {
-    const ws = fs.createWriteStream(dest, { mode: srcStat.mode })
-    ws.on('error', err => cb(err))
-      .on('open', () => rs.pipe(ws))
-      .once('close', () => setDestModeAndTimestamps(srcStat, dest, opts, cb))
+function fileIsNotWritable (srcMode) {
+  return (srcMode & 0o200) === 0
+}
+
+function makeFileWritable (dest, srcMode, cb) {
+  return setDestMode(dest, srcMode | 0o200, cb)
+}
+
+function setDestTimestampsAndMode (srcMode, src, dest, cb) {
+  setDestTimestamps(src, dest, err => {
+    if (err) return cb(err)
+    return setDestMode(dest, srcMode, cb)
   })
 }
 
-function setDestModeAndTimestamps (srcStat, dest, opts, cb) {
-  fs.chmod(dest, srcStat.mode, err => {
+function setDestMode (dest, srcMode, cb) {
+  return fs.chmod(dest, srcMode, cb)
+}
+
+function setDestTimestamps (src, dest, cb) {
+  // The initial srcStat.atime cannot be trusted
+  // because it is modified by the read(2) system call
+  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
+  fs.stat(src, (err, updatedSrcStat) => {
     if (err) return cb(err)
-    if (opts.preserveTimestamps) {
-      return utimes(dest, srcStat.atime, srcStat.mtime, cb)
-    }
-    return cb()
+    return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb)
   })
 }
 
 function onDir (srcStat, destStat, src, dest, opts, cb) {
-  if (destStat === notExist) return mkDirAndCopy(srcStat, src, dest, opts, cb)
-  if (destStat && !destStat.isDirectory()) {
-    return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))
-  }
+  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb)
   return copyDir(src, dest, opts, cb)
 }
 
-function mkDirAndCopy (srcStat, src, dest, opts, cb) {
+function mkDirAndCopy (srcMode, src, dest, opts, cb) {
   fs.mkdir(dest, err => {
     if (err) return cb(err)
     copyDir(src, dest, opts, err => {
       if (err) return cb(err)
-      return fs.chmod(dest, srcStat.mode, cb)
+      return setDestMode(dest, srcMode, cb)
     })
   })
 }
@@ -17244,8 +17533,9 @@ function copyDirItems (items, src, dest, opts, cb) {
 function copyDirItem (items, item, src, dest, opts, cb) {
   const srcItem = path.join(src, item)
   const destItem = path.join(dest, item)
-  checkPaths(srcItem, destItem, (err, destStat) => {
+  stat.checkPaths(srcItem, destItem, 'copy', opts, (err, stats) => {
     if (err) return cb(err)
+    const { destStat } = stats
     startCopy(destStat, srcItem, destItem, opts, err => {
       if (err) return cb(err)
       return copyDirItems(items, src, dest, opts, cb)
@@ -17256,12 +17546,11 @@ function copyDirItem (items, item, src, dest, opts, cb) {
 function onLink (destStat, src, dest, opts, cb) {
   fs.readlink(src, (err, resolvedSrc) => {
     if (err) return cb(err)
-
     if (opts.dereference) {
       resolvedSrc = path.resolve(process.cwd(), resolvedSrc)
     }
 
-    if (destStat === notExist) {
+    if (!destStat) {
       return fs.symlink(resolvedSrc, dest, cb)
     } else {
       fs.readlink(dest, (err, resolvedDest) => {
@@ -17275,14 +17564,14 @@ function onLink (destStat, src, dest, opts, cb) {
         if (opts.dereference) {
           resolvedDest = path.resolve(process.cwd(), resolvedDest)
         }
-        if (isSrcSubdir(resolvedSrc, resolvedDest)) {
+        if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
           return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`))
         }
 
         // do not copy if src is a subdir of dest since unlinking
         // dest in this case would result in removing src contents
         // and therefore a broken symlink would be created.
-        if (destStat.isDirectory() && isSrcSubdir(resolvedDest, resolvedSrc)) {
+        if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
           return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))
         }
         return copyLink(resolvedSrc, dest, cb)
@@ -17298,40 +17587,6 @@ function copyLink (resolvedSrc, dest, cb) {
   })
 }
 
-// return true if dest is a subdir of src, otherwise false.
-function isSrcSubdir (src, dest) {
-  const srcArray = path.resolve(src).split(path.sep)
-  const destArray = path.resolve(dest).split(path.sep)
-  return srcArray.reduce((acc, current, i) => acc && destArray[i] === current, true)
-}
-
-function checkStats (src, dest, cb) {
-  fs.stat(src, (err, srcStat) => {
-    if (err) return cb(err)
-    fs.stat(dest, (err, destStat) => {
-      if (err) {
-        if (err.code === 'ENOENT') return cb(null, {srcStat, destStat: notExist})
-        return cb(err)
-      }
-      return cb(null, {srcStat, destStat})
-    })
-  })
-}
-
-function checkPaths (src, dest, cb) {
-  checkStats(src, dest, (err, stats) => {
-    if (err) return cb(err)
-    const {srcStat, destStat} = stats
-    if (destStat.ino && destStat.ino === srcStat.ino) {
-      return cb(new Error('Source and destination must not be the same.'))
-    }
-    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-      return cb(new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`))
-    }
-    return cb(null, destStat)
-  })
-}
-
 module.exports = copy
 
 
@@ -17343,7 +17598,7 @@ module.exports = copy
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
+const u = __webpack_require__(7500).fromCallback
 module.exports = {
   copy: u(__webpack_require__(4487))
 }
@@ -17357,37 +17612,28 @@ module.exports = {
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
-const fs = __webpack_require__(5747)
+const u = __webpack_require__(7500).fromPromise
+const fs = __webpack_require__(893)
 const path = __webpack_require__(5622)
 const mkdir = __webpack_require__(9181)
 const remove = __webpack_require__(4879)
 
-const emptyDir = u(function emptyDir (dir, callback) {
-  callback = callback || function () {}
-  fs.readdir(dir, (err, items) => {
-    if (err) return mkdir.mkdirs(dir, callback)
-
-    items = items.map(item => path.join(dir, item))
-
-    deleteItem()
+const emptyDir = u(async function emptyDir (dir) {
+  let items
+  try {
+    items = await fs.readdir(dir)
+  } catch {
+    return mkdir.mkdirs(dir)
+  }
 
-    function deleteItem () {
-      const item = items.pop()
-      if (!item) return callback()
-      remove.remove(item, err => {
-        if (err) return callback(err)
-        deleteItem()
-      })
-    }
-  })
+  return Promise.all(items.map(item => remove.remove(path.join(dir, item))))
 })
 
 function emptyDirSync (dir) {
   let items
   try {
     items = fs.readdirSync(dir)
-  } catch (err) {
+  } catch {
     return mkdir.mkdirsSync(dir)
   }
 
@@ -17413,11 +17659,10 @@ module.exports = {
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
+const u = __webpack_require__(7500).fromCallback
 const path = __webpack_require__(5622)
 const fs = __webpack_require__(552)
 const mkdir = __webpack_require__(9181)
-const pathExists = __webpack_require__(5516).pathExists
 
 function createFile (file, callback) {
   function makeFile () {
@@ -17430,13 +17675,26 @@ function createFile (file, callback) {
   fs.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
     if (!err && stats.isFile()) return callback()
     const dir = path.dirname(file)
-    pathExists(dir, (err, dirExists) => {
-      if (err) return callback(err)
-      if (dirExists) return makeFile()
-      mkdir.mkdirs(dir, err => {
-        if (err) return callback(err)
-        makeFile()
-      })
+    fs.stat(dir, (err, stats) => {
+      if (err) {
+        // if the directory doesn't exist, make it
+        if (err.code === 'ENOENT') {
+          return mkdir.mkdirs(dir, err => {
+            if (err) return callback(err)
+            makeFile()
+          })
+        }
+        return callback(err)
+      }
+
+      if (stats.isDirectory()) makeFile()
+      else {
+        // parent is not a directory
+        // This is just to cause an internal ENOTDIR error to be thrown
+        fs.readdir(dir, err => {
+          if (err) return callback(err)
+        })
+      }
     })
   })
 }
@@ -17445,12 +17703,20 @@ function createFileSync (file) {
   let stats
   try {
     stats = fs.statSync(file)
-  } catch (e) {}
+  } catch {}
   if (stats && stats.isFile()) return
 
   const dir = path.dirname(file)
-  if (!fs.existsSync(dir)) {
-    mkdir.mkdirsSync(dir)
+  try {
+    if (!fs.statSync(dir).isDirectory()) {
+      // parent is not a directory
+      // This is just to cause an internal ENOTDIR error to be thrown
+      fs.readdirSync(dir)
+    }
+  } catch (err) {
+    // If the stat call above failed because the directory doesn't exist, create it
+    if (err && err.code === 'ENOENT') mkdir.mkdirsSync(dir)
+    else throw err
   }
 
   fs.writeFileSync(file, '')
@@ -17501,11 +17767,12 @@ module.exports = {
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
+const u = __webpack_require__(7500).fromCallback
 const path = __webpack_require__(5622)
 const fs = __webpack_require__(552)
 const mkdir = __webpack_require__(9181)
 const pathExists = __webpack_require__(5516).pathExists
+const { areIdentical } = __webpack_require__(9783)
 
 function createLink (srcpath, dstpath, callback) {
   function makeLink (srcpath, dstpath) {
@@ -17515,14 +17782,13 @@ function createLink (srcpath, dstpath, callback) {
     })
   }
 
-  pathExists(dstpath, (err, destinationExists) => {
-    if (err) return callback(err)
-    if (destinationExists) return callback(null)
-    fs.lstat(srcpath, (err) => {
+  fs.lstat(dstpath, (_, dstStat) => {
+    fs.lstat(srcpath, (err, srcStat) => {
       if (err) {
         err.message = err.message.replace('lstat', 'ensureLink')
         return callback(err)
       }
+      if (dstStat && areIdentical(srcStat, dstStat)) return callback(null)
 
       const dir = path.dirname(dstpath)
       pathExists(dir, (err, dirExists) => {
@@ -17538,11 +17804,14 @@ function createLink (srcpath, dstpath, callback) {
 }
 
 function createLinkSync (srcpath, dstpath) {
-  const destinationExists = fs.existsSync(dstpath)
-  if (destinationExists) return undefined
+  let dstStat
+  try {
+    dstStat = fs.lstatSync(dstpath)
+  } catch {}
 
   try {
-    fs.lstatSync(srcpath)
+    const srcStat = fs.lstatSync(srcpath)
+    if (dstStat && areIdentical(srcStat, dstStat)) return
   } catch (err) {
     err.message = err.message.replace('lstat', 'ensureLink')
     throw err
@@ -17604,8 +17873,8 @@ function symlinkPaths (srcpath, dstpath, callback) {
         return callback(err)
       }
       return callback(null, {
-        'toCwd': srcpath,
-        'toDst': srcpath
+        toCwd: srcpath,
+        toDst: srcpath
       })
     })
   } else {
@@ -17615,8 +17884,8 @@ function symlinkPaths (srcpath, dstpath, callback) {
       if (err) return callback(err)
       if (exists) {
         return callback(null, {
-          'toCwd': relativeToDst,
-          'toDst': srcpath
+          toCwd: relativeToDst,
+          toDst: srcpath
         })
       } else {
         return fs.lstat(srcpath, (err) => {
@@ -17625,8 +17894,8 @@ function symlinkPaths (srcpath, dstpath, callback) {
             return callback(err)
           }
           return callback(null, {
-            'toCwd': srcpath,
-            'toDst': path.relative(dstdir, srcpath)
+            toCwd: srcpath,
+            toDst: path.relative(dstdir, srcpath)
           })
         })
       }
@@ -17640,8 +17909,8 @@ function symlinkPathsSync (srcpath, dstpath) {
     exists = fs.existsSync(srcpath)
     if (!exists) throw new Error('absolute srcpath does not exist')
     return {
-      'toCwd': srcpath,
-      'toDst': srcpath
+      toCwd: srcpath,
+      toDst: srcpath
     }
   } else {
     const dstdir = path.dirname(dstpath)
@@ -17649,15 +17918,15 @@ function symlinkPathsSync (srcpath, dstpath) {
     exists = fs.existsSync(relativeToDst)
     if (exists) {
       return {
-        'toCwd': relativeToDst,
-        'toDst': srcpath
+        toCwd: relativeToDst,
+        toDst: srcpath
       }
     } else {
       exists = fs.existsSync(srcpath)
       if (!exists) throw new Error('relative srcpath does not exist')
       return {
-        'toCwd': srcpath,
-        'toDst': path.relative(dstdir, srcpath)
+        toCwd: srcpath,
+        toDst: path.relative(dstdir, srcpath)
       }
     }
   }
@@ -17696,7 +17965,7 @@ function symlinkTypeSync (srcpath, type) {
   if (type) return type
   try {
     stats = fs.lstatSync(srcpath)
-  } catch (e) {
+  } catch {
     return 'file'
   }
   return (stats && stats.isDirectory()) ? 'dir' : 'file'
@@ -17716,9 +17985,9 @@ module.exports = {
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
+const u = __webpack_require__(7500).fromCallback
 const path = __webpack_require__(5622)
-const fs = __webpack_require__(552)
+const fs = __webpack_require__(893)
 const _mkdirs = __webpack_require__(9181)
 const mkdirs = _mkdirs.mkdirs
 const mkdirsSync = _mkdirs.mkdirsSync
@@ -17733,26 +18002,38 @@ const symlinkTypeSync = _symlinkType.symlinkTypeSync
 
 const pathExists = __webpack_require__(5516).pathExists
 
+const { areIdentical } = __webpack_require__(9783)
+
 function createSymlink (srcpath, dstpath, type, callback) {
   callback = (typeof type === 'function') ? type : callback
   type = (typeof type === 'function') ? false : type
 
-  pathExists(dstpath, (err, destinationExists) => {
+  fs.lstat(dstpath, (err, stats) => {
+    if (!err && stats.isSymbolicLink()) {
+      Promise.all([
+        fs.stat(srcpath),
+        fs.stat(dstpath)
+      ]).then(([srcStat, dstStat]) => {
+        if (areIdentical(srcStat, dstStat)) return callback(null)
+        _createSymlink(srcpath, dstpath, type, callback)
+      })
+    } else _createSymlink(srcpath, dstpath, type, callback)
+  })
+}
+
+function _createSymlink (srcpath, dstpath, type, callback) {
+  symlinkPaths(srcpath, dstpath, (err, relative) => {
     if (err) return callback(err)
-    if (destinationExists) return callback(null)
-    symlinkPaths(srcpath, dstpath, (err, relative) => {
+    srcpath = relative.toDst
+    symlinkType(relative.toCwd, type, (err, type) => {
       if (err) return callback(err)
-      srcpath = relative.toDst
-      symlinkType(relative.toCwd, type, (err, type) => {
+      const dir = path.dirname(dstpath)
+      pathExists(dir, (err, dirExists) => {
         if (err) return callback(err)
-        const dir = path.dirname(dstpath)
-        pathExists(dir, (err, dirExists) => {
+        if (dirExists) return fs.symlink(srcpath, dstpath, type, callback)
+        mkdirs(dir, err => {
           if (err) return callback(err)
-          if (dirExists) return fs.symlink(srcpath, dstpath, type, callback)
-          mkdirs(dir, err => {
-            if (err) return callback(err)
-            fs.symlink(srcpath, dstpath, type, callback)
-          })
+          fs.symlink(srcpath, dstpath, type, callback)
         })
       })
     })
@@ -17760,8 +18041,15 @@ function createSymlink (srcpath, dstpath, type, callback) {
 }
 
 function createSymlinkSync (srcpath, dstpath, type) {
-  const destinationExists = fs.existsSync(dstpath)
-  if (destinationExists) return undefined
+  let stats
+  try {
+    stats = fs.lstatSync(dstpath)
+  } catch {}
+  if (stats && stats.isSymbolicLink()) {
+    const srcStat = fs.statSync(srcpath)
+    const dstStat = fs.statSync(dstpath)
+    if (areIdentical(srcStat, dstStat)) return
+  }
 
   const relative = symlinkPathsSync(srcpath, dstpath)
   srcpath = relative.toDst
@@ -17788,7 +18076,7 @@ module.exports = {
 
 // This is adapted from https://github.com/normalize/mz
 // Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
-const u = __webpack_require__(2703)/* .fromCallback */ .E
+const u = __webpack_require__(7500).fromCallback
 const fs = __webpack_require__(552)
 
 const api = [
@@ -17805,18 +18093,20 @@ const api = [
   'fsync',
   'ftruncate',
   'futimes',
-  'lchown',
   'lchmod',
+  'lchown',
   'link',
   'lstat',
   'mkdir',
   'mkdtemp',
   'open',
-  'readFile',
+  'opendir',
   'readdir',
+  'readFile',
   'readlink',
   'realpath',
   'rename',
+  'rm',
   'rmdir',
   'stat',
   'symlink',
@@ -17826,26 +18116,20 @@ const api = [
   'writeFile'
 ].filter(key => {
   // Some commands are not available on some systems. Ex:
-  // fs.copyFile was added in Node.js v8.5.0
-  // fs.mkdtemp was added in Node.js v5.10.0
+  // fs.opendir was added in Node.js v12.12.0
+  // fs.rm was added in Node.js v14.14.0
   // fs.lchown is not available on at least some Linux
   return typeof fs[key] === 'function'
 })
 
-// Export all keys:
-Object.keys(fs).forEach(key => {
-  if (key === 'promises') {
-    // fs.promises is a getter property that triggers ExperimentalWarning
-    // Don't re-export it here, the getter is defined in "lib/index.js"
-    return
-  }
-  exports[key] = fs[key]
-})
+// Export cloned fs:
+Object.assign(exports, fs)
 
 // Universalify async methods:
 api.forEach(method => {
   exports[method] = u(fs[method])
 })
+exports.realpath.native = u(fs.realpath.native)
 
 // We differ from mz/fs in that we still ship the old, broken, fs.exists()
 // since we are a drop-in replacement for the native module
@@ -17858,7 +18142,7 @@ exports.exists = function (filename, callback) {
   })
 }
 
-// fs.read() & fs.write need special treatment due to multiple callback args
+// fs.read(), fs.write(), & fs.writev() need special treatment due to multiple callback args
 
 exports.read = function (fd, buffer, offset, length, position, callback) {
   if (typeof callback === 'function') {
@@ -17890,6 +18174,25 @@ exports.write = function (fd, buffer, ...args) {
   })
 }
 
+// fs.writev only available in Node v12.9.0+
+if (typeof fs.writev === 'function') {
+  // Function signature is
+  // s.writev(fd, buffers[, position], callback)
+  // We need to handle the optional arg, so we use ...args
+  exports.writev = function (fd, buffers, ...args) {
+    if (typeof args[args.length - 1] === 'function') {
+      return fs.writev(fd, buffers, ...args)
+    }
+
+    return new Promise((resolve, reject) => {
+      fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
+        if (err) return reject(err)
+        resolve({ bytesWritten, buffers })
+      })
+    })
+  }
+}
+
 
 /***/ }),
 
@@ -17899,31 +18202,21 @@ exports.write = function (fd, buffer, ...args) {
 "use strict";
 
 
-module.exports = Object.assign(
-  {},
+module.exports = {
   // Export promiseified graceful-fs:
-  __webpack_require__(893),
+  ...__webpack_require__(893),
   // Export extra methods:
-  __webpack_require__(9567),
-  __webpack_require__(8852),
-  __webpack_require__(2677),
-  __webpack_require__(6004),
-  __webpack_require__(3960),
-  __webpack_require__(9181),
-  __webpack_require__(4168),
-  __webpack_require__(7819),
-  __webpack_require__(3849),
-  __webpack_require__(5516),
-  __webpack_require__(4879)
-)
-
-// Export fs.promises as a getter property so that we don't trigger
-// ExperimentalWarning before fs.promises is actually accessed.
-const fs = __webpack_require__(5747)
-if (Object.getOwnPropertyDescriptor(fs, 'promises')) {
-  Object.defineProperty(module.exports, "promises", ({
-    get () { return fs.promises }
-  }))
+  ...__webpack_require__(9567),
+  ...__webpack_require__(8852),
+  ...__webpack_require__(2677),
+  ...__webpack_require__(6004),
+  ...__webpack_require__(3960),
+  ...__webpack_require__(9181),
+  ...__webpack_require__(4168),
+  ...__webpack_require__(7819),
+  ...__webpack_require__(3849),
+  ...__webpack_require__(5516),
+  ...__webpack_require__(4879)
 }
 
 
@@ -17935,7 +18228,7 @@ if (Object.getOwnPropertyDescriptor(fs, 'promises')) {
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
+const u = __webpack_require__(7500).fromPromise
 const jsonFile = __webpack_require__(4003)
 
 jsonFile.outputJson = u(__webpack_require__(7583))
@@ -17959,14 +18252,13 @@ module.exports = jsonFile
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
-const jsonFile = __webpack_require__(1215)
+const jsonFile = __webpack_require__(4862)
 
 module.exports = {
   // jsonfile exports
-  readJson: u(jsonFile.readFile),
+  readJson: jsonFile.readFile,
   readJsonSync: jsonFile.readFileSync,
-  writeJson: u(jsonFile.writeFile),
+  writeJson: jsonFile.writeFile,
   writeJsonSync: jsonFile.writeFileSync
 }
 
@@ -17979,19 +18271,13 @@ module.exports = {
 "use strict";
 
 
-const fs = __webpack_require__(552)
-const path = __webpack_require__(5622)
-const mkdir = __webpack_require__(9181)
-const jsonFile = __webpack_require__(4003)
+const { stringify } = __webpack_require__(7653)
+const { outputFileSync } = __webpack_require__(3849)
 
 function outputJsonSync (file, data, options) {
-  const dir = path.dirname(file)
-
-  if (!fs.existsSync(dir)) {
-    mkdir.mkdirsSync(dir)
-  }
+  const str = stringify(data, options)
 
-  jsonFile.writeJsonSync(file, data, options)
+  outputFileSync(file, str, options)
 }
 
 module.exports = outputJsonSync
@@ -18005,28 +18291,13 @@ module.exports = outputJsonSync
 "use strict";
 
 
-const path = __webpack_require__(5622)
-const mkdir = __webpack_require__(9181)
-const pathExists = __webpack_require__(5516).pathExists
-const jsonFile = __webpack_require__(4003)
-
-function outputJson (file, data, options, callback) {
-  if (typeof options === 'function') {
-    callback = options
-    options = {}
-  }
-
-  const dir = path.dirname(file)
+const { stringify } = __webpack_require__(7653)
+const { outputFile } = __webpack_require__(3849)
 
-  pathExists(dir, (err, itDoes) => {
-    if (err) return callback(err)
-    if (itDoes) return jsonFile.writeJson(file, data, options, callback)
+async function outputJson (file, data, options = {}) {
+  const str = stringify(data, options)
 
-    mkdir.mkdirs(dir, err => {
-      if (err) return callback(err)
-      jsonFile.writeJson(file, data, options, callback)
-    })
-  })
+  await outputFile(file, str, options)
 }
 
 module.exports = outputJson
@@ -18039,190 +18310,101 @@ module.exports = outputJson
 
 "use strict";
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
-const mkdirs = u(__webpack_require__(7718))
-const mkdirsSync = __webpack_require__(1275)
+const u = __webpack_require__(7500).fromPromise
+const { makeDir: _makeDir, makeDirSync } = __webpack_require__(511)
+const makeDir = u(_makeDir)
 
 module.exports = {
-  mkdirs,
-  mkdirsSync,
+  mkdirs: makeDir,
+  mkdirsSync: makeDirSync,
   // alias
-  mkdirp: mkdirs,
-  mkdirpSync: mkdirsSync,
-  ensureDir: mkdirs,
-  ensureDirSync: mkdirsSync
+  mkdirp: makeDir,
+  mkdirpSync: makeDirSync,
+  ensureDir: makeDir,
+  ensureDirSync: makeDirSync
 }
 
 
 /***/ }),
 
-/***/ 1275:
+/***/ 511:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
+const fs = __webpack_require__(893)
+const { checkPath } = __webpack_require__(1176)
 
-const fs = __webpack_require__(552)
-const path = __webpack_require__(5622)
-const invalidWin32Path = __webpack_require__(3727).invalidWin32Path
-
-const o777 = parseInt('0777', 8)
-
-function mkdirsSync (p, opts, made) {
-  if (!opts || typeof opts !== 'object') {
-    opts = { mode: opts }
-  }
-
-  let mode = opts.mode
-  const xfs = opts.fs || fs
-
-  if (process.platform === 'win32' && invalidWin32Path(p)) {
-    const errInval = new Error(p + ' contains invalid WIN32 path characters.')
-    errInval.code = 'EINVAL'
-    throw errInval
-  }
+const getMode = options => {
+  const defaults = { mode: 0o777 }
+  if (typeof options === 'number') return options
+  return ({ ...defaults, ...options }).mode
+}
 
-  if (mode === undefined) {
-    mode = o777 & (~process.umask())
-  }
-  if (!made) made = null
+module.exports.makeDir = async (dir, options) => {
+  checkPath(dir)
 
-  p = path.resolve(p)
+  return fs.mkdir(dir, {
+    mode: getMode(options),
+    recursive: true
+  })
+}
 
-  try {
-    xfs.mkdirSync(p, mode)
-    made = made || p
-  } catch (err0) {
-    if (err0.code === 'ENOENT') {
-      if (path.dirname(p) === p) throw err0
-      made = mkdirsSync(path.dirname(p), opts, made)
-      mkdirsSync(p, opts, made)
-    } else {
-      // In the case of any other error, just see if there's a dir there
-      // already. If so, then hooray!  If not, then something is borked.
-      let stat
-      try {
-        stat = xfs.statSync(p)
-      } catch (err1) {
-        throw err0
-      }
-      if (!stat.isDirectory()) throw err0
-    }
-  }
+module.exports.makeDirSync = (dir, options) => {
+  checkPath(dir)
 
-  return made
+  return fs.mkdirSync(dir, {
+    mode: getMode(options),
+    recursive: true
+  })
 }
 
-module.exports = mkdirsSync
-
 
 /***/ }),
 
-/***/ 7718:
+/***/ 1176:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
+// Adapted from https://github.com/sindresorhus/make-dir
+// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-
-const fs = __webpack_require__(552)
 const path = __webpack_require__(5622)
-const invalidWin32Path = __webpack_require__(3727).invalidWin32Path
 
-const o777 = parseInt('0777', 8)
+// https://github.com/nodejs/node/issues/8987
+// https://github.com/libuv/libuv/pull/1088
+module.exports.checkPath = function checkPath (pth) {
+  if (process.platform === 'win32') {
+    const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''))
 
-function mkdirs (p, opts, callback, made) {
-  if (typeof opts === 'function') {
-    callback = opts
-    opts = {}
-  } else if (!opts || typeof opts !== 'object') {
-    opts = { mode: opts }
-  }
-
-  if (process.platform === 'win32' && invalidWin32Path(p)) {
-    const errInval = new Error(p + ' contains invalid WIN32 path characters.')
-    errInval.code = 'EINVAL'
-    return callback(errInval)
-  }
-
-  let mode = opts.mode
-  const xfs = opts.fs || fs
-
-  if (mode === undefined) {
-    mode = o777 & (~process.umask())
-  }
-  if (!made) made = null
-
-  callback = callback || function () {}
-  p = path.resolve(p)
-
-  xfs.mkdir(p, mode, er => {
-    if (!er) {
-      made = made || p
-      return callback(null, made)
+    if (pathHasInvalidWinCharacters) {
+      const error = new Error(`Path contains invalid characters: ${pth}`)
+      error.code = 'EINVAL'
+      throw error
     }
-    switch (er.code) {
-      case 'ENOENT':
-        if (path.dirname(p) === p) return callback(er)
-        mkdirs(path.dirname(p), opts, (er, made) => {
-          if (er) callback(er, made)
-          else mkdirs(p, opts, callback, made)
-        })
-        break
-
-      // In the case of any other error, just see if there's a dir
-      // there already.  If so, then hooray!  If not, then something
-      // is borked.
-      default:
-        xfs.stat(p, (er2, stat) => {
-          // if the stat fails, then that's super weird.
-          // let the original error be the failure reason.
-          if (er2 || !stat.isDirectory()) callback(er, made)
-          else callback(null, made)
-        })
-        break
-    }
-  })
+  }
 }
 
-module.exports = mkdirs
-
 
 /***/ }),
 
-/***/ 3727:
+/***/ 4168:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
 
-const path = __webpack_require__(5622)
-
-// get drive on windows
-function getRootPath (p) {
-  p = path.normalize(path.resolve(p)).split(path.sep)
-  if (p.length > 0) return p[0]
-  return null
-}
-
-// http://stackoverflow.com/a/62888/10333 contains more accurate
-// TODO: expand to include the rest
-const INVALID_PATH_CHARS = /[<>:"|?*]/
-
-function invalidWin32Path (p) {
-  const rp = getRootPath(p)
-  p = p.replace(rp, '')
-  return INVALID_PATH_CHARS.test(p)
-}
-
 module.exports = {
-  getRootPath,
-  invalidWin32Path
+  moveSync: __webpack_require__(6776)
 }
 
 
 /***/ }),
 
-/***/ 4168:
+/***/ 6776:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
@@ -18232,134 +18414,85 @@ const fs = __webpack_require__(552)
 const path = __webpack_require__(5622)
 const copySync = __webpack_require__(9567).copySync
 const removeSync = __webpack_require__(4879).removeSync
-const mkdirpSync = __webpack_require__(9181).mkdirsSync
-const buffer = __webpack_require__(6343)
-
-function moveSync (src, dest, options) {
-  options = options || {}
-  const overwrite = options.overwrite || options.clobber || false
-
-  src = path.resolve(src)
-  dest = path.resolve(dest)
+const mkdirpSync = __webpack_require__(9181).mkdirpSync
+const stat = __webpack_require__(9783)
 
-  if (src === dest) return fs.accessSync(src)
-
-  if (isSrcSubdir(src, dest)) throw new Error(`Cannot move '${src}' into itself '${dest}'.`)
+function moveSync (src, dest, opts) {
+  opts = opts || {}
+  const overwrite = opts.overwrite || opts.clobber || false
 
-  mkdirpSync(path.dirname(dest))
-  tryRenameSync()
+  const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, 'move', opts)
+  stat.checkParentPathsSync(src, srcStat, dest, 'move')
+  if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest))
+  return doRename(src, dest, overwrite, isChangingCase)
+}
 
-  function tryRenameSync () {
-    if (overwrite) {
-      try {
-        return fs.renameSync(src, dest)
-      } catch (err) {
-        if (err.code === 'ENOTEMPTY' || err.code === 'EEXIST' || err.code === 'EPERM') {
-          removeSync(dest)
-          options.overwrite = false // just overwriteed it, no need to do it again
-          return moveSync(src, dest, options)
-        }
+function isParentRoot (dest) {
+  const parent = path.dirname(dest)
+  const parsedPath = path.parse(parent)
+  return parsedPath.root === parent
+}
 
-        if (err.code !== 'EXDEV') throw err
-        return moveSyncAcrossDevice(src, dest, overwrite)
-      }
-    } else {
-      try {
-        fs.linkSync(src, dest)
-        return fs.unlinkSync(src)
-      } catch (err) {
-        if (err.code === 'EXDEV' || err.code === 'EISDIR' || err.code === 'EPERM' || err.code === 'ENOTSUP') {
-          return moveSyncAcrossDevice(src, dest, overwrite)
-        }
-        throw err
-      }
-    }
+function doRename (src, dest, overwrite, isChangingCase) {
+  if (isChangingCase) return rename(src, dest, overwrite)
+  if (overwrite) {
+    removeSync(dest)
+    return rename(src, dest, overwrite)
   }
+  if (fs.existsSync(dest)) throw new Error('dest already exists.')
+  return rename(src, dest, overwrite)
 }
 
-function moveSyncAcrossDevice (src, dest, overwrite) {
-  const stat = fs.statSync(src)
-
-  if (stat.isDirectory()) {
-    return moveDirSyncAcrossDevice(src, dest, overwrite)
-  } else {
-    return moveFileSyncAcrossDevice(src, dest, overwrite)
+function rename (src, dest, overwrite) {
+  try {
+    fs.renameSync(src, dest)
+  } catch (err) {
+    if (err.code !== 'EXDEV') throw err
+    return moveAcrossDevice(src, dest, overwrite)
   }
 }
 
-function moveFileSyncAcrossDevice (src, dest, overwrite) {
-  const BUF_LENGTH = 64 * 1024
-  const _buff = buffer(BUF_LENGTH)
-
-  const flags = overwrite ? 'w' : 'wx'
-
-  const fdr = fs.openSync(src, 'r')
-  const stat = fs.fstatSync(fdr)
-  const fdw = fs.openSync(dest, flags, stat.mode)
-  let pos = 0
-
-  while (pos < stat.size) {
-    const bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos)
-    fs.writeSync(fdw, _buff, 0, bytesRead)
-    pos += bytesRead
+function moveAcrossDevice (src, dest, overwrite) {
+  const opts = {
+    overwrite,
+    errorOnExist: true
   }
-
-  fs.closeSync(fdr)
-  fs.closeSync(fdw)
-  return fs.unlinkSync(src)
+  copySync(src, dest, opts)
+  return removeSync(src)
 }
 
-function moveDirSyncAcrossDevice (src, dest, overwrite) {
-  const options = {
-    overwrite: false
-  }
+module.exports = moveSync
 
-  if (overwrite) {
-    removeSync(dest)
-    tryCopySync()
-  } else {
-    tryCopySync()
-  }
 
-  function tryCopySync () {
-    copySync(src, dest, options)
-    return removeSync(src)
-  }
-}
+/***/ }),
 
-// return true if dest is a subdir of src, otherwise false.
-// extract dest base dir and check if that is the same as src basename
-function isSrcSubdir (src, dest) {
-  try {
-    return fs.statSync(src).isDirectory() &&
-           src !== dest &&
-           dest.indexOf(src) > -1 &&
-           dest.split(path.dirname(src) + path.sep)[1].split(path.sep)[0] === path.basename(src)
-  } catch (e) {
-    return false
-  }
-}
+/***/ 7819:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
 
+
+const u = __webpack_require__(7500).fromCallback
 module.exports = {
-  moveSync
+  move: u(__webpack_require__(4064))
 }
 
 
 /***/ }),
 
-/***/ 7819:
+/***/ 4064:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
 const fs = __webpack_require__(552)
 const path = __webpack_require__(5622)
 const copy = __webpack_require__(8852).copy
 const remove = __webpack_require__(4879).remove
 const mkdirp = __webpack_require__(9181).mkdirp
 const pathExists = __webpack_require__(5516).pathExists
+const stat = __webpack_require__(9783)
 
 function move (src, dest, opts, cb) {
   if (typeof opts === 'function') {
@@ -18369,25 +18502,28 @@ function move (src, dest, opts, cb) {
 
   const overwrite = opts.overwrite || opts.clobber || false
 
-  src = path.resolve(src)
-  dest = path.resolve(dest)
-
-  if (src === dest) return fs.access(src, cb)
-
-  fs.stat(src, (err, st) => {
+  stat.checkPaths(src, dest, 'move', opts, (err, stats) => {
     if (err) return cb(err)
-
-    if (st.isDirectory() && isSrcSubdir(src, dest)) {
-      return cb(new Error(`Cannot move '${src}' to a subdirectory of itself, '${dest}'.`))
-    }
-    mkdirp(path.dirname(dest), err => {
+    const { srcStat, isChangingCase = false } = stats
+    stat.checkParentPaths(src, srcStat, dest, 'move', err => {
       if (err) return cb(err)
-      return doRename(src, dest, overwrite, cb)
+      if (isParentRoot(dest)) return doRename(src, dest, overwrite, isChangingCase, cb)
+      mkdirp(path.dirname(dest), err => {
+        if (err) return cb(err)
+        return doRename(src, dest, overwrite, isChangingCase, cb)
+      })
     })
   })
 }
 
-function doRename (src, dest, overwrite, cb) {
+function isParentRoot (dest) {
+  const parent = path.dirname(dest)
+  const parsedPath = path.parse(parent)
+  return parsedPath.root === parent
+}
+
+function doRename (src, dest, overwrite, isChangingCase, cb) {
+  if (isChangingCase) return rename(src, dest, overwrite, cb)
   if (overwrite) {
     return remove(dest, err => {
       if (err) return cb(err)
@@ -18414,25 +18550,13 @@ function moveAcrossDevice (src, dest, overwrite, cb) {
     overwrite,
     errorOnExist: true
   }
-
   copy(src, dest, opts, err => {
     if (err) return cb(err)
     return remove(src, cb)
   })
 }
 
-function isSrcSubdir (src, dest) {
-  const srcArray = src.split(path.sep)
-  const destArray = dest.split(path.sep)
-
-  return srcArray.reduce((acc, current, i) => {
-    return acc && destArray[i] === current
-  }, true)
-}
-
-module.exports = {
-  move: u(move)
-}
+module.exports = move
 
 
 /***/ }),
@@ -18443,7 +18567,7 @@ module.exports = {
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
+const u = __webpack_require__(7500).fromCallback
 const fs = __webpack_require__(552)
 const path = __webpack_require__(5622)
 const mkdir = __webpack_require__(9181)
@@ -18490,7 +18614,7 @@ module.exports = {
 
 "use strict";
 
-const u = __webpack_require__(2703)/* .fromPromise */ .p
+const u = __webpack_require__(7500).fromPromise
 const fs = __webpack_require__(893)
 
 function pathExists (path) {
@@ -18511,12 +18635,25 @@ module.exports = {
 "use strict";
 
 
-const u = __webpack_require__(2703)/* .fromCallback */ .E
+const fs = __webpack_require__(552)
+const u = __webpack_require__(7500).fromCallback
 const rimraf = __webpack_require__(7137)
 
+function remove (path, callback) {
+  // Node 14.14.0+
+  if (fs.rm) return fs.rm(path, { recursive: true, force: true }, callback)
+  rimraf(path, callback)
+}
+
+function removeSync (path) {
+  // Node 14.14.0+
+  if (fs.rmSync) return fs.rmSync(path, { recursive: true, force: true })
+  rimraf.sync(path)
+}
+
 module.exports = {
-  remove: u(rimraf),
-  removeSync: rimraf.sync
+  remove: u(remove),
+  removeSync
 }
 
 
@@ -18641,9 +18778,6 @@ function fixWinEPERM (p, options, er, cb) {
   assert(p)
   assert(options)
   assert(typeof cb === 'function')
-  if (er) {
-    assert(er instanceof Error)
-  }
 
   options.chmod(p, 0o666, er2 => {
     if (er2) {
@@ -18667,9 +18801,6 @@ function fixWinEPERMSync (p, options, er) {
 
   assert(p)
   assert(options)
-  if (er) {
-    assert(er instanceof Error)
-  }
 
   try {
     options.chmodSync(p, 0o666)
@@ -18701,9 +18832,6 @@ function fixWinEPERMSync (p, options, er) {
 function rmdir (p, options, originalEr, cb) {
   assert(p)
   assert(options)
-  if (originalEr) {
-    assert(originalEr instanceof Error)
-  }
   assert(typeof cb === 'function')
 
   // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
@@ -18796,9 +18924,6 @@ function rimrafSync (p, options) {
 function rmdirSync (p, options, originalEr) {
   assert(p)
   assert(options)
-  if (originalEr) {
-    assert(originalEr instanceof Error)
-  }
 
   try {
     options.rmdirSync(p)
@@ -18818,24 +18943,24 @@ function rmkidsSync (p, options) {
   assert(options)
   options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))
 
-  // We only end up here once we got ENOTEMPTY at least once, and
-  // at this point, we are guaranteed to have removed all the kids.
-  // So, we know that it won't be ENOENT or ENOTDIR or anything else.
-  // try really hard to delete stuff on windows, because it has a
-  // PROFOUNDLY annoying habit of not closing handles promptly when
-  // files are deleted, resulting in spurious ENOTEMPTY errors.
-  const retries = isWindows ? 100 : 1
-  let i = 0
-  do {
-    let threw = true
-    try {
-      const ret = options.rmdirSync(p, options)
-      threw = false
-      return ret
-    } finally {
-      if (++i < retries && threw) continue // eslint-disable-line
-    }
-  } while (true)
+  if (isWindows) {
+    // We only end up here once we got ENOTEMPTY at least once, and
+    // at this point, we are guaranteed to have removed all the kids.
+    // So, we know that it won't be ENOENT or ENOTDIR or anything else.
+    // try really hard to delete stuff on windows, because it has a
+    // PROFOUNDLY annoying habit of not closing handles promptly when
+    // files are deleted, resulting in spurious ENOTEMPTY errors.
+    const startTime = Date.now()
+    do {
+      try {
+        const ret = options.rmdirSync(p, options)
+        return ret
+      } catch {}
+    } while (Date.now() - startTime < 500) // give up after 500ms
+  } else {
+    const ret = options.rmdirSync(p, options)
+    return ret
+  }
 }
 
 module.exports = rimraf
@@ -18844,83 +18969,175 @@ rimraf.sync = rimrafSync
 
 /***/ }),
 
-/***/ 6343:
-/***/ ((module) => {
+/***/ 9783:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
-/* eslint-disable node/no-deprecated-api */
-module.exports = function (size) {
-  if (typeof Buffer.allocUnsafe === 'function') {
-    try {
-      return Buffer.allocUnsafe(size)
-    } catch (e) {
-      return new Buffer(size)
-    }
+
+const fs = __webpack_require__(893)
+const path = __webpack_require__(5622)
+const util = __webpack_require__(1669)
+
+function getStats (src, dest, opts) {
+  const statFunc = opts.dereference
+    ? (file) => fs.stat(file, { bigint: true })
+    : (file) => fs.lstat(file, { bigint: true })
+  return Promise.all([
+    statFunc(src),
+    statFunc(dest).catch(err => {
+      if (err.code === 'ENOENT') return null
+      throw err
+    })
+  ]).then(([srcStat, destStat]) => ({ srcStat, destStat }))
+}
+
+function getStatsSync (src, dest, opts) {
+  let destStat
+  const statFunc = opts.dereference
+    ? (file) => fs.statSync(file, { bigint: true })
+    : (file) => fs.lstatSync(file, { bigint: true })
+  const srcStat = statFunc(src)
+  try {
+    destStat = statFunc(dest)
+  } catch (err) {
+    if (err.code === 'ENOENT') return { srcStat, destStat: null }
+    throw err
   }
-  return new Buffer(size)
+  return { srcStat, destStat }
 }
 
+function checkPaths (src, dest, funcName, opts, cb) {
+  util.callbackify(getStats)(src, dest, opts, (err, stats) => {
+    if (err) return cb(err)
+    const { srcStat, destStat } = stats
 
-/***/ }),
+    if (destStat) {
+      if (areIdentical(srcStat, destStat)) {
+        const srcBaseName = path.basename(src)
+        const destBaseName = path.basename(dest)
+        if (funcName === 'move' &&
+          srcBaseName !== destBaseName &&
+          srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+          return cb(null, { srcStat, destStat, isChangingCase: true })
+        }
+        return cb(new Error('Source and destination must not be the same.'))
+      }
+      if (srcStat.isDirectory() && !destStat.isDirectory()) {
+        return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))
+      }
+      if (!srcStat.isDirectory() && destStat.isDirectory()) {
+        return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`))
+      }
+    }
 
-/***/ 8605:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+      return cb(new Error(errMsg(src, dest, funcName)))
+    }
+    return cb(null, { srcStat, destStat })
+  })
+}
 
-"use strict";
+function checkPathsSync (src, dest, funcName, opts) {
+  const { srcStat, destStat } = getStatsSync(src, dest, opts)
 
+  if (destStat) {
+    if (areIdentical(srcStat, destStat)) {
+      const srcBaseName = path.basename(src)
+      const destBaseName = path.basename(dest)
+      if (funcName === 'move' &&
+        srcBaseName !== destBaseName &&
+        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+        return { srcStat, destStat, isChangingCase: true }
+      }
+      throw new Error('Source and destination must not be the same.')
+    }
+    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
+    }
+    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
+    }
+  }
 
-const fs = __webpack_require__(552)
-const os = __webpack_require__(2087)
-const path = __webpack_require__(5622)
+  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+    throw new Error(errMsg(src, dest, funcName))
+  }
+  return { srcStat, destStat }
+}
 
-// HFS, ext{2,3}, FAT do not, Node.js v0.10 does not
-function hasMillisResSync () {
-  let tmpfile = path.join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2))
-  tmpfile = path.join(os.tmpdir(), tmpfile)
+// recursively check if dest parent is a subdirectory of src.
+// It works for all file types including symlinks since it
+// checks the src and dest inodes. It starts from the deepest
+// parent and stops once it reaches the src parent or the root path.
+function checkParentPaths (src, srcStat, dest, funcName, cb) {
+  const srcParent = path.resolve(path.dirname(src))
+  const destParent = path.resolve(path.dirname(dest))
+  if (destParent === srcParent || destParent === path.parse(destParent).root) return cb()
+  fs.stat(destParent, { bigint: true }, (err, destStat) => {
+    if (err) {
+      if (err.code === 'ENOENT') return cb()
+      return cb(err)
+    }
+    if (areIdentical(srcStat, destStat)) {
+      return cb(new Error(errMsg(src, dest, funcName)))
+    }
+    return checkParentPaths(src, srcStat, destParent, funcName, cb)
+  })
+}
 
-  // 550 millis past UNIX epoch
-  const d = new Date(1435410243862)
-  fs.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141')
-  const fd = fs.openSync(tmpfile, 'r+')
-  fs.futimesSync(fd, d, d)
-  fs.closeSync(fd)
-  return fs.statSync(tmpfile).mtime > 1435410243000
+function checkParentPathsSync (src, srcStat, dest, funcName) {
+  const srcParent = path.resolve(path.dirname(src))
+  const destParent = path.resolve(path.dirname(dest))
+  if (destParent === srcParent || destParent === path.parse(destParent).root) return
+  let destStat
+  try {
+    destStat = fs.statSync(destParent, { bigint: true })
+  } catch (err) {
+    if (err.code === 'ENOENT') return
+    throw err
+  }
+  if (areIdentical(srcStat, destStat)) {
+    throw new Error(errMsg(src, dest, funcName))
+  }
+  return checkParentPathsSync(src, srcStat, destParent, funcName)
 }
 
-function hasMillisRes (callback) {
-  let tmpfile = path.join('millis-test' + Date.now().toString() + Math.random().toString().slice(2))
-  tmpfile = path.join(os.tmpdir(), tmpfile)
+function areIdentical (srcStat, destStat) {
+  return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev
+}
 
-  // 550 millis past UNIX epoch
-  const d = new Date(1435410243862)
-  fs.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
-    if (err) return callback(err)
-    fs.open(tmpfile, 'r+', (err, fd) => {
-      if (err) return callback(err)
-      fs.futimes(fd, d, d, err => {
-        if (err) return callback(err)
-        fs.close(fd, err => {
-          if (err) return callback(err)
-          fs.stat(tmpfile, (err, stats) => {
-            if (err) return callback(err)
-            callback(null, stats.mtime > 1435410243000)
-          })
-        })
-      })
-    })
-  })
+// return true if dest is a subdir of src, otherwise false.
+// It only checks the path strings.
+function isSrcSubdir (src, dest) {
+  const srcArr = path.resolve(src).split(path.sep).filter(i => i)
+  const destArr = path.resolve(dest).split(path.sep).filter(i => i)
+  return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true)
 }
 
-function timeRemoveMillis (timestamp) {
-  if (typeof timestamp === 'number') {
-    return Math.floor(timestamp / 1000) * 1000
-  } else if (timestamp instanceof Date) {
-    return new Date(Math.floor(timestamp.getTime() / 1000) * 1000)
-  } else {
-    throw new Error('fs-extra: timeRemoveMillis() unknown parameter type')
-  }
-}
+function errMsg (src, dest, funcName) {
+  return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`
+}
+
+module.exports = {
+  checkPaths,
+  checkPathsSync,
+  checkParentPaths,
+  checkParentPathsSync,
+  isSrcSubdir,
+  areIdentical
+}
+
+
+/***/ }),
+
+/***/ 8605:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+const fs = __webpack_require__(552)
 
 function utimesMillis (path, atime, mtime, callback) {
   // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
@@ -18941,9 +19158,6 @@ function utimesMillisSync (path, atime, mtime) {
 }
 
 module.exports = {
-  hasMillisRes,
-  hasMillisResSync,
-  timeRemoveMillis,
   utimesMillis,
   utimesMillisSync
 }
@@ -24610,6 +24824,122 @@ module.exports = new Type('tag:yaml.org,2002:timestamp', {
 });
 
 
+/***/ }),
+
+/***/ 4862:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+let _fs
+try {
+  _fs = __webpack_require__(552)
+} catch (_) {
+  _fs = __webpack_require__(5747)
+}
+const universalify = __webpack_require__(7500)
+const { stringify, stripBom } = __webpack_require__(7653)
+
+async function _readFile (file, options = {}) {
+  if (typeof options === 'string') {
+    options = { encoding: options }
+  }
+
+  const fs = options.fs || _fs
+
+  const shouldThrow = 'throws' in options ? options.throws : true
+
+  let data = await universalify.fromCallback(fs.readFile)(file, options)
+
+  data = stripBom(data)
+
+  let obj
+  try {
+    obj = JSON.parse(data, options ? options.reviver : null)
+  } catch (err) {
+    if (shouldThrow) {
+      err.message = `${file}: ${err.message}`
+      throw err
+    } else {
+      return null
+    }
+  }
+
+  return obj
+}
+
+const readFile = universalify.fromPromise(_readFile)
+
+function readFileSync (file, options = {}) {
+  if (typeof options === 'string') {
+    options = { encoding: options }
+  }
+
+  const fs = options.fs || _fs
+
+  const shouldThrow = 'throws' in options ? options.throws : true
+
+  try {
+    let content = fs.readFileSync(file, options)
+    content = stripBom(content)
+    return JSON.parse(content, options.reviver)
+  } catch (err) {
+    if (shouldThrow) {
+      err.message = `${file}: ${err.message}`
+      throw err
+    } else {
+      return null
+    }
+  }
+}
+
+async function _writeFile (file, obj, options = {}) {
+  const fs = options.fs || _fs
+
+  const str = stringify(obj, options)
+
+  await universalify.fromCallback(fs.writeFile)(file, str, options)
+}
+
+const writeFile = universalify.fromPromise(_writeFile)
+
+function writeFileSync (file, obj, options = {}) {
+  const fs = options.fs || _fs
+
+  const str = stringify(obj, options)
+  // not sure if fs.writeFileSync returns anything, but just in case
+  return fs.writeFileSync(file, str, options)
+}
+
+const jsonfile = {
+  readFile,
+  readFileSync,
+  writeFile,
+  writeFileSync
+}
+
+module.exports = jsonfile
+
+
+/***/ }),
+
+/***/ 7653:
+/***/ ((module) => {
+
+function stringify (obj, { EOL = '\n', finalEOL = true, replacer = null, spaces } = {}) {
+  const EOF = finalEOL ? EOL : ''
+  const str = JSON.stringify(obj, replacer, spaces)
+
+  return str.replace(/\n/g, EOL) + EOF
+}
+
+function stripBom (content) {
+  // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
+  if (Buffer.isBuffer(content)) content = content.toString('utf8')
+  return content.replace(/^\uFEFF/, '')
+}
+
+module.exports = { stringify, stripBom }
+
+
 /***/ }),
 
 /***/ 4725:
@@ -26182,6 +26512,38 @@ function coerce (version, options) {
 }
 
 
+/***/ }),
+
+/***/ 7500:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+
+exports.fromCallback = function (fn) {
+  return Object.defineProperty(function (...args) {
+    if (typeof args[args.length - 1] === 'function') fn.apply(this, args)
+    else {
+      return new Promise((resolve, reject) => {
+        fn.call(
+          this,
+          ...args,
+          (err, res) => (err != null) ? reject(err) : resolve(res)
+        )
+      })
+    }
+  }, 'name', { value: fn.name })
+}
+
+exports.fromPromise = function (fn) {
+  return Object.defineProperty(function (...args) {
+    const cb = args[args.length - 1]
+    if (typeof cb !== 'function') return fn.apply(this, args)
+    else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb)
+  }, 'name', { value: fn.name })
+}
+
+
 /***/ }),
 
 /***/ 8438:
@@ -26238,6 +26600,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `blitz build`',
+                value: 'blitz build',
             },
             devCommand: {
                 value: 'blitz start',
@@ -26246,8 +26609,7 @@ exports.frameworks = [
                 placeholder: 'Next.js default',
             },
         },
-        devCommand: 'blitz start',
-        buildCommand: 'blitz build',
+        getFsOutputDir: async () => '.next',
         getOutputDirName: async () => 'public',
     },
     {
@@ -26275,6 +26637,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `next build`',
+                value: 'next build',
             },
             devCommand: {
                 value: 'next dev --port $PORT',
@@ -26290,8 +26653,7 @@ exports.frameworks = [
                 dependencies: ['next-plugin-sentry', 'next-sentry-source-maps'],
             },
         ],
-        devCommand: 'next dev --port $PORT',
-        buildCommand: 'next build',
+        getFsOutputDir: async () => '.next',
         getOutputDirName: async () => 'public',
         cachePattern: '.next/cache/**',
     },
@@ -26303,7 +26665,7 @@ exports.frameworks = [
         tagline: 'Gatsby helps developers build blazing fast websites and apps with React.',
         description: 'A Gatsby app, using the default starter theme and a Serverless Function API.',
         website: 'https://gatsbyjs.org',
-        sort: 2,
+        sort: 5,
         envPrefix: 'GATSBY_',
         detectors: {
             every: [
@@ -26319,6 +26681,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `gatsby build`',
+                value: 'gatsby build',
             },
             devCommand: {
                 value: 'gatsby develop --port $PORT',
@@ -26329,8 +26692,6 @@ exports.frameworks = [
             },
         },
         dependency: 'gatsby',
-        devCommand: 'gatsby develop --port $PORT',
-        buildCommand: 'gatsby build',
         getOutputDirName: async () => 'public',
         defaultRoutes: async (dirPrefix) => {
             // This file could be generated by gatsby-plugin-now or gatsby-plugin-zeit-now
@@ -26378,6 +26739,75 @@ exports.frameworks = [
         },
         cachePattern: '{.cache,public}/**',
     },
+    {
+        name: 'Remix',
+        slug: 'remix',
+        demo: 'https://remix.examples.vercel.com',
+        logo: 'https://raw.githubusercontent.com/vercel/vercel/main/packages/frameworks/logos/remix-no-shadow.svg',
+        tagline: 'Build Better Websites',
+        description: 'A new Remix app — the result of running `npx create-remix`.',
+        website: 'https://remix.run',
+        sort: 6,
+        detectors: {
+            every: [
+                {
+                    path: 'package.json',
+                    matchContent: '"(dev)?(d|D)ependencies":\\s*{[^}]*"remix":\\s*".+?"[^}]*}',
+                },
+            ],
+        },
+        settings: {
+            installCommand: {
+                placeholder: '`yarn install` or `npm install`',
+            },
+            buildCommand: {
+                value: 'remix build',
+                placeholder: '`npm run build` or `remix build`',
+            },
+            devCommand: {
+                value: 'remix dev',
+                placeholder: 'remix dev',
+            },
+            outputDirectory: {
+                value: 'public',
+            },
+        },
+        dependency: 'remix',
+        getOutputDirName: async () => 'public',
+        defaultRoutes: [
+            {
+                src: '^/build/(.*)$',
+                headers: { 'cache-control': 'public, max-age=31536000, immutable' },
+                continue: true,
+            },
+            {
+                handle: 'filesystem',
+            },
+            {
+                src: '/(.*)',
+                dest: '/api',
+            },
+        ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                destination: '/api',
+            },
+        ],
+        defaultHeaders: [
+            {
+                source: '/build/(.*)',
+                regex: '/build/(.*)',
+                headers: [
+                    {
+                        key: 'cache-control',
+                        value: 'public, max-age=31536000, immutable',
+                    },
+                ],
+            },
+        ],
+    },
     {
         name: 'Hexo',
         slug: 'hexo',
@@ -26386,7 +26816,6 @@ exports.frameworks = [
         tagline: 'Hexo is a fast, simple & powerful blog framework powered by Node.js.',
         description: 'A Hexo site, created with the Hexo CLI.',
         website: 'https://hexo.io',
-        sort: 3,
         detectors: {
             every: [
                 {
@@ -26401,6 +26830,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `hexo generate`',
+                value: 'hexo generate',
             },
             devCommand: {
                 value: 'hexo server --port $PORT',
@@ -26411,8 +26841,6 @@ exports.frameworks = [
             },
         },
         dependency: 'hexo',
-        devCommand: 'hexo server --port $PORT',
-        buildCommand: 'hexo generate',
         getOutputDirName: async () => 'public',
     },
     {
@@ -26423,7 +26851,6 @@ exports.frameworks = [
         tagline: '11ty is a simpler static site generator written in JavaScript, created to be an alternative to Jekyll.',
         description: 'An Eleventy site, created with npm init.',
         website: 'https://www.11ty.dev',
-        sort: 4,
         detectors: {
             every: [
                 {
@@ -26438,6 +26865,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `npx @11ty/eleventy`',
+                value: 'npx @11ty/eleventy',
             },
             devCommand: {
                 value: 'npx @11ty/eleventy --serve --watch --port $PORT',
@@ -26448,8 +26876,6 @@ exports.frameworks = [
             },
         },
         dependency: '@11ty/eleventy',
-        devCommand: 'npx @11ty/eleventy --serve --watch --port $PORT',
-        buildCommand: 'npx @11ty/eleventy',
         getOutputDirName: async () => '_site',
         cachePattern: '.cache/**',
     },
@@ -26475,6 +26901,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `docusaurus build`',
+                value: 'docusaurus build',
             },
             devCommand: {
                 value: 'docusaurus start --port $PORT',
@@ -26485,8 +26912,6 @@ exports.frameworks = [
             },
         },
         dependency: '@docusaurus/core',
-        devCommand: 'docusaurus start --port $PORT',
-        buildCommand: 'docusaurus build',
         getOutputDirName: async (dirPrefix) => {
             const base = 'build';
             try {
@@ -26502,6 +26927,51 @@ exports.frameworks = [
             }
             return base;
         },
+        defaultHeaders: [
+            {
+                source: '^/[^./]+\\.[0-9a-f]{8}\\.(css|js)$',
+                regex: '^/[^./]+\\.[0-9a-f]{8}\\.(css|js)$',
+                headers: [
+                    { key: 'cache-control', value: 'max-age=31536000, immutable' },
+                ],
+            },
+            {
+                source: '^/assets/images/[^/]+-[0-9a-f]{32}\\.(ico|svg|jpg|jpeg|png|gif|webp)$',
+                regex: '^/assets/images/[^/]+-[0-9a-f]{32}\\.(ico|svg|jpg|jpeg|png|gif|webp)$',
+                headers: [
+                    { key: 'cache-control', value: 'max-age=31536000, immutable' },
+                ],
+            },
+            {
+                source: '^/assets/medias/[^/]+-[0-9a-f]{32}\\.(ogv|wav|mp3|m4a|aac|oga|flac)$',
+                regex: '^/assets/medias/[^/]+-[0-9a-f]{32}\\.(ogv|wav|mp3|m4a|aac|oga|flac)$',
+                headers: [
+                    { key: 'cache-control', value: 'max-age=31536000, immutable' },
+                ],
+            },
+            {
+                source: '^/assets/files/[^/]+-[0-9a-f]{32}\\.(pdf|doc|docx|xls|xlsx|zip|rar)$',
+                regex: '^/assets/files/[^/]+-[0-9a-f]{32}\\.(pdf|doc|docx|xls|xlsx|zip|rar)$',
+                headers: [
+                    { key: 'cache-control', value: 'max-age=31536000, immutable' },
+                ],
+            },
+            {
+                source: '^/ideal-img/[^/]+\\.[0-9a-f]{7}\\.\\d+\\.(png|jpe?g|gif)$',
+                regex: '^/ideal-img/[^/]+\\.[0-9a-f]{7}\\.\\d+\\.(png|jpe?g|gif)$',
+                headers: [
+                    { key: 'cache-control', value: 'max-age=31536000, immutable' },
+                ],
+            },
+        ],
+        defaultRedirects: [
+            {
+                source: '.*',
+                regex: '.*',
+                statusCode: 404,
+                destination: '404.html',
+            },
+        ],
         defaultRoutes: [
             {
                 src: '^/[^./]+\\.[0-9a-f]{8}\\.(css|js)$',
@@ -26560,6 +27030,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `docusaurus-build`',
+                value: 'docusaurus-build',
             },
             devCommand: {
                 value: 'docusaurus-start --port $PORT',
@@ -26570,8 +27041,6 @@ exports.frameworks = [
             },
         },
         dependency: 'docusaurus',
-        devCommand: 'docusaurus-start --port $PORT',
-        buildCommand: 'docusaurus-build',
         getOutputDirName: async (dirPrefix) => {
             const base = 'build';
             try {
@@ -26610,6 +27079,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `preact build`',
+                value: 'preact build',
             },
             devCommand: {
                 value: 'preact watch --port $PORT',
@@ -26620,8 +27090,6 @@ exports.frameworks = [
             },
         },
         dependency: 'preact-cli',
-        devCommand: 'preact watch --port $PORT',
-        buildCommand: 'preact build',
         getOutputDirName: async () => 'build',
         defaultRoutes: [
             {
@@ -26632,6 +27100,51 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                destination: '/index.html',
+            },
+        ],
+    },
+    {
+        name: 'SolidStart',
+        slug: 'solidstart',
+        demo: 'https://solidstart.examples.vercel.com',
+        logo: 'https://raw.githubusercontent.com/vercel/vercel/main/packages/frameworks/logos/solid.svg',
+        tagline: 'Simple and performant reactivity for building user interfaces.',
+        description: 'A Solid app, created with SolidStart.',
+        website: 'https://solidjs.com',
+        envPrefix: 'VITE_',
+        detectors: {
+            every: [
+                {
+                    path: 'package.json',
+                    matchContent: '"(dev)?(d|D)ependencies":\\s*{[^}]*"solid-js":\\s*".+?"[^}]*}',
+                },
+                {
+                    path: 'package.json',
+                    matchContent: '"(dev)?(d|D)ependencies":\\s*{[^}]*"solid-start":\\s*".+?"[^}]*}',
+                },
+            ],
+        },
+        settings: {
+            installCommand: {
+                placeholder: '`yarn install` or `npm install`',
+            },
+            buildCommand: {
+                placeholder: '`npm run build` or `solid-start build`',
+                value: 'solid-start build',
+            },
+            devCommand: {
+                value: 'solid-start dev',
+            },
+            outputDirectory: {
+                value: '.output',
+            },
+        },
+        getOutputDirName: async () => '.output',
     },
     {
         name: 'Dojo',
@@ -26658,6 +27171,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `dojo build`',
+                value: 'dojo build',
             },
             devCommand: {
                 value: 'dojo build -m dev -w -s -p $PORT',
@@ -26668,8 +27182,6 @@ exports.frameworks = [
             },
         },
         dependency: '@dojo/cli',
-        devCommand: 'dojo build -m dev -w -s -p $PORT',
-        buildCommand: 'dojo build',
         getOutputDirName: async () => path_1.join('output', 'dist'),
         defaultRoutes: [
             {
@@ -26685,6 +27197,21 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaulHeaders: [
+            {
+                source: '/service-worker.js',
+                regex: '/service-worker.js',
+                headers: { 'cache-control': 's-maxage=0' },
+                continue: true,
+            },
+        ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                destination: '/index.html',
+            },
+        ],
     },
     {
         name: 'Ember.js',
@@ -26708,6 +27235,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `ember build`',
+                value: 'ember build',
             },
             devCommand: {
                 value: 'ember serve --port $PORT',
@@ -26718,8 +27246,6 @@ exports.frameworks = [
             },
         },
         dependency: 'ember-cli',
-        devCommand: 'ember serve --port $PORT',
-        buildCommand: 'ember build',
         getOutputDirName: async () => 'dist',
         defaultRoutes: [
             {
@@ -26730,6 +27256,13 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                destination: '/index.html',
+            },
+        ],
     },
     {
         name: 'Vue.js',
@@ -26754,6 +27287,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `vue-cli-service build`',
+                value: 'vue-cli-service build',
             },
             devCommand: {
                 value: 'vue-cli-service serve --port $PORT',
@@ -26764,8 +27298,6 @@ exports.frameworks = [
             },
         },
         dependency: '@vue/cli-service',
-        devCommand: 'vue-cli-service serve --port $PORT',
-        buildCommand: 'vue-cli-service build',
         getOutputDirName: async () => 'dist',
         defaultRoutes: [
             {
@@ -26786,6 +27318,27 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultHeaders: [
+            {
+                source: '^/[^/]*\\.(js|txt|ico|json)',
+                regex: '^/[^/]*\\.(js|txt|ico|json)',
+                headers: [{ key: 'cache-control', value: 'max-age=300' }],
+            },
+            {
+                source: '^/(img|js|css|fonts|media)/[^/]+\\.[0-9a-f]{8}\\.*',
+                regex: '^/(img|js|css|fonts|media)/[^/]+\\.[0-9a-f]{8}\\.*',
+                headers: [
+                    { key: 'cache-control', value: 'max-age=31536000, immutable' },
+                ],
+            },
+        ],
+        defaultRewrites: [
+            {
+                source: '^.*',
+                regex: '^.*',
+                destination: '/index.html',
+            },
+        ],
     },
     {
         name: 'Scully',
@@ -26809,6 +27362,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `ng build && scully`',
+                value: 'ng build && scully',
             },
             devCommand: {
                 value: 'ng serve --port $PORT',
@@ -26819,8 +27373,6 @@ exports.frameworks = [
             },
         },
         dependency: '@scullyio/init',
-        devCommand: 'ng serve --port $PORT',
-        buildCommand: 'ng build && scully',
         getOutputDirName: async () => 'dist/static',
     },
     {
@@ -26845,17 +27397,16 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `ng build`',
+                value: 'ng build',
             },
             devCommand: {
-                value: 'ng serve',
+                value: 'ng serve --port $PORT',
             },
             outputDirectory: {
                 value: 'www',
             },
         },
         dependency: '@ionic/angular',
-        devCommand: 'ng serve',
-        buildCommand: 'ng build',
         getOutputDirName: async () => 'www',
         defaultRoutes: [
             {
@@ -26866,6 +27417,13 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                destination: '/index.html',
+            },
+        ],
     },
     {
         name: 'Angular',
@@ -26889,6 +27447,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `ng build`',
+                value: 'ng build',
             },
             devCommand: {
                 value: 'ng serve --port $PORT',
@@ -26899,8 +27458,6 @@ exports.frameworks = [
             },
         },
         dependency: '@angular/cli',
-        devCommand: 'ng serve --port $PORT',
-        buildCommand: 'ng build',
         getOutputDirName: async (dirPrefix) => {
             const base = 'dist';
             try {
@@ -26925,6 +27482,13 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                destination: '/index.html',
+            },
+        ],
     },
     {
         name: 'Polymer',
@@ -26948,6 +27512,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `polymer build`',
+                value: 'polymer build',
             },
             devCommand: {
                 value: 'polymer serve --port $PORT',
@@ -26958,8 +27523,6 @@ exports.frameworks = [
             },
         },
         dependency: 'polymer-cli',
-        devCommand: 'polymer serve --port $PORT',
-        buildCommand: 'polymer build',
         getOutputDirName: async (dirPrefix) => {
             const base = 'build';
             try {
@@ -26982,6 +27545,13 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                destination: '/index.html',
+            },
+        ],
     },
     {
         name: 'Svelte',
@@ -26991,6 +27561,7 @@ exports.frameworks = [
         tagline: 'Svelte lets you write high performance reactive apps with significantly less boilerplate.',
         description: 'A basic Svelte app using the default template.',
         website: 'https://svelte.dev',
+        sort: 3,
         detectors: {
             every: [
                 {
@@ -27009,6 +27580,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `rollup -c`',
+                value: 'rollup -c',
             },
             devCommand: {
                 value: 'rollup -c -w',
@@ -27018,8 +27590,6 @@ exports.frameworks = [
             },
         },
         dependency: 'sirv-cli',
-        devCommand: 'rollup -c -w',
-        buildCommand: 'rollup -c',
         getOutputDirName: async () => 'public',
         defaultRoutes: [
             {
@@ -27030,6 +27600,13 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                destination: '/index.html',
+            },
+        ],
     },
     {
         name: 'SvelteKit',
@@ -27039,6 +27616,7 @@ exports.frameworks = [
         tagline: 'SvelteKit is a framework for building web applications of all sizes.',
         description: 'A SvelteKit app optimized to work for serverless.',
         website: 'https://kit.svelte.dev',
+        envPrefix: 'VITE_',
         detectors: {
             every: [
                 {
@@ -27053,17 +27631,16 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `svelte-kit build`',
+                value: 'svelte-kit build',
             },
             devCommand: {
                 value: 'svelte-kit dev --port $PORT',
                 placeholder: 'svelte-kit dev',
             },
             outputDirectory: {
-                placeholder: 'public',
+                value: 'public',
             },
         },
-        devCommand: 'svelte-kit dev --port $PORT',
-        buildCommand: 'svelte-kit build',
         getOutputDirName: async () => 'public',
     },
     {
@@ -27088,6 +27665,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `react-scripts build`',
+                value: 'react-scripts build',
             },
             devCommand: {
                 value: 'react-scripts start',
@@ -27097,8 +27675,6 @@ exports.frameworks = [
             },
         },
         dependency: '@ionic/react',
-        devCommand: 'react-scripts start',
-        buildCommand: 'react-scripts build',
         getOutputDirName: async () => 'build',
         defaultRoutes: [
             {
@@ -27125,6 +27701,45 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultHeaders: [
+            {
+                source: '/static/(.*)',
+                regex: '/static/(.*)',
+                headers: [
+                    { key: 'cache-control', value: 's-maxage=31536000, immutable' },
+                ],
+            },
+            {
+                source: '/service-worker.js',
+                regex: '/service-worker.js',
+                headers: [{ key: 'cache-control', value: 's-maxage=0' }],
+            },
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                headers: [{ key: 'cache-control', value: 's-maxage=0' }],
+            },
+        ],
+        defaultRedirects: [
+            {
+                source: '/static/(.*)',
+                destination: '/404.html',
+                statusCode: 404,
+                regex: '/static/(.*)',
+            },
+        ],
+        defaultRewrites: [
+            {
+                source: '/sockjs-node/(.*)',
+                destination: '/sockjs-node/$1',
+                regex: '/sockjs-node/(.*)',
+            },
+            {
+                source: '/(.*)',
+                destination: '/index.html',
+                regex: '/(.*)',
+            },
+        ],
     },
     {
         name: 'Create React App',
@@ -27134,6 +27749,7 @@ exports.frameworks = [
         tagline: 'Create React App allows you to get going with React in no time.',
         description: 'A React app, bootstrapped with create-react-app, and a Serverless Function API.',
         website: 'https://create-react-app.dev',
+        sort: 4,
         envPrefix: 'REACT_APP_',
         detectors: {
             some: [
@@ -27153,6 +27769,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `react-scripts build`',
+                value: 'react-scripts build',
             },
             devCommand: {
                 value: 'react-scripts start',
@@ -27162,8 +27779,6 @@ exports.frameworks = [
             },
         },
         dependency: 'react-scripts',
-        devCommand: 'react-scripts start',
-        buildCommand: 'react-scripts build',
         getOutputDirName: async () => 'build',
         defaultRoutes: [
             {
@@ -27190,6 +27805,45 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultHeaders: [
+            {
+                source: '/static/(.*)',
+                regex: '/static/(.*)',
+                headers: [
+                    { key: 'cache-control', value: 's-maxage=31536000, immutable' },
+                ],
+            },
+            {
+                source: '/service-worker.js',
+                regex: '/service-worker.js',
+                headers: [{ key: 'cache-control', value: 's-maxage=0' }],
+            },
+            {
+                source: '/(.*)',
+                regex: '/(.*)',
+                headers: [{ key: 'cache-control', value: 's-maxage=0' }],
+            },
+        ],
+        defaultRedirects: [
+            {
+                source: '/static/(.*)',
+                destination: '/404.html',
+                statusCode: 404,
+                regex: '/static/(.*)',
+            },
+        ],
+        defaultRewrites: [
+            {
+                source: '/sockjs-node/(.*)',
+                destination: '/sockjs-node/$1',
+                regex: '/sockjs-node/(.*)',
+            },
+            {
+                source: '/(.*)',
+                destination: '/index.html',
+                regex: '/(.*)',
+            },
+        ],
     },
     {
         name: 'Gridsome',
@@ -27213,6 +27867,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `gridsome build`',
+                value: 'gridsome build',
             },
             devCommand: {
                 value: 'gridsome develop -p $PORT',
@@ -27223,8 +27878,6 @@ exports.frameworks = [
             },
         },
         dependency: 'gridsome',
-        devCommand: 'gridsome develop -p $PORT',
-        buildCommand: 'gridsome build',
         getOutputDirName: async () => 'dist',
     },
     {
@@ -27249,6 +27902,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `umi build`',
+                value: 'umi build',
             },
             devCommand: {
                 value: 'umi dev --port $PORT',
@@ -27259,8 +27913,6 @@ exports.frameworks = [
             },
         },
         dependency: 'umi',
-        devCommand: 'umi dev --port $PORT',
-        buildCommand: 'umi build',
         getOutputDirName: async () => 'dist',
         defaultRoutes: [
             {
@@ -27271,6 +27923,13 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                destination: '/index.html',
+                regex: '/(.*)',
+            },
+        ],
     },
     {
         name: 'Sapper',
@@ -27294,6 +27953,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `sapper export`',
+                value: 'sapper export',
             },
             devCommand: {
                 value: 'sapper dev --port $PORT',
@@ -27304,8 +27964,6 @@ exports.frameworks = [
             },
         },
         dependency: 'sapper',
-        devCommand: 'sapper dev --port $PORT',
-        buildCommand: 'sapper export',
         getOutputDirName: async () => '__sapper__/export',
     },
     {
@@ -27330,6 +27988,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `saber build`',
+                value: 'saber build',
             },
             devCommand: {
                 value: 'saber --port $PORT',
@@ -27340,8 +27999,6 @@ exports.frameworks = [
             },
         },
         dependency: 'saber',
-        devCommand: 'saber --port $PORT',
-        buildCommand: 'saber build',
         getOutputDirName: async () => 'public',
         defaultRoutes: [
             {
@@ -27357,6 +28014,23 @@ exports.frameworks = [
                 dest: '404.html',
             },
         ],
+        defaultHeaders: [
+            {
+                source: '/_saber/.*',
+                regex: '/_saber/.*',
+                headers: [
+                    { key: 'cache-control', value: 'max-age=31536000, immutable' },
+                ],
+            },
+        ],
+        defaultRedirects: [
+            {
+                source: '.*',
+                statusCode: 404,
+                destination: '404.html',
+                regex: '.*',
+            },
+        ],
     },
     {
         name: 'Stencil',
@@ -27380,6 +28054,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `stencil build`',
+                value: 'stencil build',
             },
             devCommand: {
                 value: 'stencil build --dev --watch --serve --port $PORT',
@@ -27390,8 +28065,6 @@ exports.frameworks = [
             },
         },
         dependency: '@stencil/core',
-        devCommand: 'stencil build --dev --watch --serve --port $PORT',
-        buildCommand: 'stencil build',
         getOutputDirName: async () => 'www',
         defaultRoutes: [
             {
@@ -27417,6 +28090,32 @@ exports.frameworks = [
                 dest: '/index.html',
             },
         ],
+        defaultHeaders: [
+            {
+                source: '/assets/(.*)',
+                regex: '/assets/(.*)',
+                headers: [{ key: 'cache-control', value: 'max-age=2592000' }],
+            },
+            {
+                source: '/build/p-.*',
+                regex: '/build/p-.*',
+                headers: [
+                    { key: 'cache-control', value: 'max-age=31536000, immutable' },
+                ],
+            },
+            {
+                source: '/sw.js',
+                regex: '/sw.js',
+                headers: [{ key: 'cache-control', value: 'no-cache' }],
+            },
+        ],
+        defaultRewrites: [
+            {
+                source: '/(.*)',
+                destination: '/index.html',
+                regex: '/(.*)',
+            },
+        ],
     },
     {
         name: 'Nuxt.js',
@@ -27426,6 +28125,7 @@ exports.frameworks = [
         tagline: 'Nuxt.js is the web comprehensive framework that lets you dream big with Vue.js.',
         description: 'A Nuxt.js app, bootstrapped with create-nuxt-app.',
         website: 'https://nuxtjs.org',
+        sort: 2,
         envPrefix: 'NUXT_ENV_',
         detectors: {
             every: [
@@ -27441,6 +28141,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `nuxt generate`',
+                value: 'nuxt generate',
             },
             devCommand: {
                 value: 'nuxt',
@@ -27450,8 +28151,6 @@ exports.frameworks = [
             },
         },
         dependency: 'nuxt',
-        devCommand: 'nuxt',
-        buildCommand: 'nuxt generate',
         getOutputDirName: async () => 'dist',
         cachePattern: '.nuxt/**',
         defaultRoutes: [
@@ -27508,8 +28207,6 @@ exports.frameworks = [
                 placeholder: 'RedwoodJS default',
             },
         },
-        devCommand: 'yarn rw dev --fwd="--port=$PORT --open=false',
-        buildCommand: 'yarn rw deploy vercel',
         getOutputDirName: async () => 'public',
     },
     {
@@ -27520,7 +28217,6 @@ exports.frameworks = [
         tagline: 'Hugo is the world’s fastest framework for building websites, written in Go.',
         description: 'A Hugo site, created with the Hugo CLI.',
         website: 'https://gohugo.io',
-        sort: 5,
         detectors: {
             some: [
                 {
@@ -27543,6 +28239,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `hugo -D --gc`',
+                value: 'hugo -D --gc',
             },
             devCommand: {
                 value: 'hugo server -D -w -p $PORT',
@@ -27552,8 +28249,6 @@ exports.frameworks = [
                 placeholder: '`public` or `publishDir` from the `config` file',
             },
         },
-        devCommand: 'hugo server -D -w -p $PORT',
-        buildCommand: 'hugo -D --gc',
         getOutputDirName: async (dirPrefix) => {
             const config = await read_config_file_1.readConfigFile(['config.json', 'config.yaml', 'config.toml'].map(fileName => {
                 return path_1.join(dirPrefix, fileName);
@@ -27583,6 +28278,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `jekyll build`',
+                value: 'jekyll build',
             },
             devCommand: {
                 value: 'bundle exec jekyll serve --watch --port $PORT',
@@ -27592,8 +28288,6 @@ exports.frameworks = [
                 placeholder: '`_site` or `destination` from `_config.yml`',
             },
         },
-        devCommand: 'bundle exec jekyll serve --watch --port $PORT',
-        buildCommand: 'jekyll build',
         getOutputDirName: async (dirPrefix) => {
             const config = await read_config_file_1.readConfigFile(path_1.join(dirPrefix, '_config.yml'));
             return (config && config.destination) || '_site';
@@ -27621,6 +28315,7 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `brunch build --production`',
+                value: 'brunch build --production',
             },
             devCommand: {
                 value: 'brunch watch --server --port $PORT',
@@ -27630,8 +28325,6 @@ exports.frameworks = [
                 value: 'public',
             },
         },
-        devCommand: 'brunch watch --server --port $PORT',
-        buildCommand: 'brunch build --production',
         getOutputDirName: async () => 'public',
     },
     {
@@ -27654,18 +28347,17 @@ exports.frameworks = [
                 value: 'bundle install',
             },
             buildCommand: {
-                value: '`npm run build` or `bundle exec middleman build`',
+                placeholder: '`npm run build` or `bundle exec middleman build`',
+                value: 'bundle exec middleman build',
             },
             devCommand: {
-                value: 'bundle exec middleman server -p $PORT',
                 placeholder: 'bundle exec middleman server',
+                value: 'bundle exec middleman server -p $PORT',
             },
             outputDirectory: {
                 value: 'build',
             },
         },
-        devCommand: 'bundle exec middleman server -p $PORT',
-        buildCommand: 'bundle exec middleman build',
         getOutputDirName: async () => 'build',
         cachePattern: '{vendor/bin,vendor/cache,vendor/bundle}/**',
     },
@@ -27693,15 +28385,13 @@ exports.frameworks = [
                 value: 'zola build',
             },
             devCommand: {
-                value: 'zola serve --port $PORT',
                 placeholder: 'zola serve',
+                value: 'zola serve --port $PORT',
             },
             outputDirectory: {
                 value: 'public',
             },
         },
-        devCommand: 'zola serve --port $PORT',
-        buildCommand: 'zola build',
         getOutputDirName: async () => 'public',
         defaultVersion: '0.13.0',
     },
@@ -27728,40 +28418,110 @@ exports.frameworks = [
             },
             buildCommand: {
                 placeholder: '`npm run build` or `vite build`',
+                value: 'vite build',
             },
             devCommand: {
                 placeholder: 'vite',
+                value: 'vite',
             },
             outputDirectory: {
                 value: 'dist',
             },
         },
         dependency: 'vite',
-        devCommand: 'vite',
-        buildCommand: 'vite build',
         getOutputDirName: async () => 'dist',
     },
+    {
+        name: 'Parcel',
+        slug: 'parcel',
+        demo: 'https://parcel.examples.vercel.com',
+        logo: 'https://raw.githubusercontent.com/vercel/vercel/main/packages/frameworks/logos/parcel.png',
+        tagline: 'Parcel is a zero configuration build tool for the web that scales to projects of any size and complexity.',
+        description: 'A vanilla web app built with Parcel.',
+        website: 'https://parceljs.org',
+        detectors: {
+            every: [
+                {
+                    path: 'package.json',
+                    matchContent: '"(dev)?(d|D)ependencies":\\s*{[^}]*"parcel":\\s*".+?"[^}]*}',
+                },
+            ],
+        },
+        settings: {
+            installCommand: {
+                placeholder: '`yarn install` or `npm install`',
+            },
+            buildCommand: {
+                placeholder: '`npm run build` or `parcel build`',
+                value: 'parcel build',
+            },
+            devCommand: {
+                placeholder: 'parcel',
+                value: 'parcel',
+            },
+            outputDirectory: {
+                value: 'dist',
+            },
+        },
+        dependency: 'parcel',
+        getOutputDirName: async () => 'dist',
+        defaultRoutes: [
+            {
+                src: '^/[^./]+\\.[0-9a-f]{8}\\.(css|js|png|jpg|webp|avif|svg)$',
+                headers: { 'cache-control': 's-maxage=31536000, immutable' },
+                continue: true,
+            },
+            {
+                handle: 'filesystem',
+            },
+        ],
+        defaultHeaders: [
+            {
+                source: '^/[^./]+\\.[0-9a-f]{8}\\.(css|js|png|jpg|webp|avif|svg)$',
+                regex: '^/[^./]+\\.[0-9a-f]{8}\\.(css|js|png|jpg|webp|avif|svg)$',
+                headers: [
+                    { key: 'cache-control', value: 's-maxage=31536000, immutable' },
+                ],
+            },
+        ],
+    },
     {
         name: 'Other',
         slug: null,
         logo: 'https://raw.githubusercontent.com/vercel/vercel/main/packages/frameworks/logos/other.svg',
-        description: 'No framework or a unoptimized framework.',
+        description: 'No framework or an unoptimized framework.',
         settings: {
             installCommand: {
                 placeholder: '`yarn install` or `npm install`',
             },
             buildCommand: {
                 placeholder: '`npm run vercel-build` or `npm run build`',
+                value: null,
             },
             devCommand: {
                 placeholder: 'None',
+                value: null,
             },
             outputDirectory: {
                 placeholder: '`public` if it exists, or `.`',
             },
         },
-        devCommand: null,
-        buildCommand: null,
+        getFsOutputDir: async (dirPrefix) => {
+            // Public if it exists or `.`
+            let base = 'public';
+            try {
+                const location = path_1.join(dirPrefix, base);
+                const content = await readdir(location, { withFileTypes: true });
+                // If there is only one file in it that is a dir we'll use it as dist dir
+                if (content.length === 1 && content[0].isDirectory()) {
+                    return path_1.join(base, content[0].name);
+                }
+            }
+            catch (_error) {
+                base = '.';
+            }
+            return base;
+        },
         getOutputDirName: async () => 'public',
     },
 ];
@@ -31953,6 +32713,312 @@ module.exports = new Type('tag:yaml.org,2002:timestamp', {
 });
 
 
+/***/ }),
+
+/***/ 7276:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports._experimental_updateRoutesManifest = exports._experimental_updateFunctionsManifest = exports._experimental_convertRuntimeToPlugin = void 0;
+const fs_extra_1 = __importDefault(__webpack_require__(5392));
+const path_1 = __webpack_require__(5622);
+const glob_1 = __importDefault(__webpack_require__(4240));
+const normalize_path_1 = __webpack_require__(6261);
+const lambda_1 = __webpack_require__(6721);
+const _1 = __webpack_require__(2855);
+// `.output` was already created by the Build Command, so we have
+// to ensure its contents don't get bundled into the Lambda. Similarily,
+// we don't want to bundle anything from `.vercel` either. Lastly,
+// Builders/Runtimes didn't have `vercel.json` or `now.json`.
+const ignoredPaths = ['.output', '.vercel', 'vercel.json', 'now.json'];
+const shouldIgnorePath = (file, ignoreFilter, ignoreFile) => {
+    const isNative = ignoredPaths.some(item => {
+        return file.startsWith(item);
+    });
+    if (!ignoreFile) {
+        return isNative;
+    }
+    return isNative || ignoreFilter(file);
+};
+const getSourceFiles = async (workPath, ignoreFilter) => {
+    const list = await glob_1.default('**', {
+        cwd: workPath,
+    });
+    // We're not passing this as an `ignore` filter to the `glob` function above,
+    // so that we can re-use exactly the same `getIgnoreFilter` method that the
+    // Build Step uses (literally the same code). Note that this exclusion only applies
+    // when deploying. Locally, another exclusion is needed, which is handled
+    // further below in the `convertRuntimeToPlugin` function.
+    for (const file in list) {
+        if (shouldIgnorePath(file, ignoreFilter, true)) {
+            delete list[file];
+        }
+    }
+    return list;
+};
+/**
+ * Convert legacy Runtime to a Plugin.
+ * @param buildRuntime - a legacy build() function from a Runtime
+ * @param packageName - the name of the package, for example `vercel-plugin-python`
+ * @param ext - the file extension, for example `.py`
+ */
+function _experimental_convertRuntimeToPlugin(buildRuntime, packageName, ext) {
+    // This `build()` signature should match `plugin.build()` signature in `vercel build`.
+    return async function build({ workPath }) {
+        // We also don't want to provide any files to Runtimes that were ignored
+        // through `.vercelignore` or `.nowignore`, because the Build Step does the same.
+        const ignoreFilter = await _1.getIgnoreFilter(workPath);
+        // Retrieve the files that are currently available on the File System,
+        // before the Legacy Runtime has even started to build.
+        const sourceFilesPreBuild = await getSourceFiles(workPath, ignoreFilter);
+        // Instead of doing another `glob` to get all the matching source files,
+        // we'll filter the list of existing files down to only the ones
+        // that are matching the entrypoint pattern, so we're first creating
+        // a clean new list to begin.
+        const entrypoints = Object.assign({}, sourceFilesPreBuild);
+        const entrypointMatch = new RegExp(`^api/.*${ext}$`);
+        // Up next, we'll strip out the files from the list of entrypoints
+        // that aren't actually considered entrypoints.
+        for (const file in entrypoints) {
+            if (!entrypointMatch.test(file)) {
+                delete entrypoints[file];
+            }
+        }
+        const pages = {};
+        const pluginName = packageName.replace('vercel-plugin-', '');
+        const outputPath = path_1.join(workPath, '.output');
+        const traceDir = path_1.join(outputPath, `inputs`, 
+        // Legacy Runtimes can only provide API Routes, so that's
+        // why we can use this prefix for all of them. Here, we have to
+        // make sure to not use a cryptic hash name, because people
+        // need to be able to easily inspect the output.
+        `api-routes-${pluginName}`);
+        await fs_extra_1.default.ensureDir(traceDir);
+        const entryRoot = path_1.join(outputPath, 'server', 'pages');
+        for (const entrypoint of Object.keys(entrypoints)) {
+            const { output } = await buildRuntime({
+                files: sourceFilesPreBuild,
+                entrypoint,
+                workPath,
+                config: {
+                    zeroConfig: true,
+                },
+                meta: {
+                    avoidTopLevelInstall: true,
+                    skipDownload: true,
+                },
+            });
+            // @ts-ignore This symbol is a private API
+            const lambdaFiles = output[lambda_1.FILES_SYMBOL];
+            // When deploying, the `files` that are passed to the Legacy Runtimes already
+            // have certain files that are ignored stripped, but locally, that list of
+            // files isn't used by the Legacy Runtimes, so we need to apply the filters
+            // to the outputs that they are returning instead.
+            for (const file in lambdaFiles) {
+                if (shouldIgnorePath(file, ignoreFilter, false)) {
+                    delete lambdaFiles[file];
+                }
+            }
+            let handlerFileBase = output.handler;
+            let handlerFile = lambdaFiles[handlerFileBase];
+            let handlerHasImport = false;
+            const { handler } = output;
+            const handlerMethod = handler.split('.').pop();
+            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
+            // For compiled languages, the launcher file for the Lambda generated
+            // by the Legacy Runtime matches the `handler` defined for it, but for
+            // interpreted languages, the `handler` consists of the launcher file name
+            // without an extension, plus the name of the method inside of that file
+            // that should be invoked, so we have to construct the file path explicitly.
+            if (!handlerFile) {
+                handlerFileBase = handlerFileName + ext;
+                handlerFile = lambdaFiles[handlerFileBase];
+                handlerHasImport = true;
+            }
+            if (!handlerFile || !handlerFile.fsPath) {
+                throw new Error(`Could not find a handler file. Please ensure that \`files\` for the returned \`Lambda\` contains an \`FileFsRef\` named "${handlerFileBase}" with a valid \`fsPath\`.`);
+            }
+            const handlerExtName = path_1.extname(handlerFile.fsPath);
+            const entryBase = path_1.basename(entrypoint).replace(ext, handlerExtName);
+            const entryPath = path_1.join(path_1.dirname(entrypoint), entryBase);
+            const entry = path_1.join(entryRoot, entryPath);
+            // Create the parent directory of the API Route that will be created
+            // for the current entrypoint inside of `.output/server/pages/api`.
+            await fs_extra_1.default.ensureDir(path_1.dirname(entry));
+            // For compiled languages, the launcher file will be binary and therefore
+            // won't try to import a user-provided request handler (instead, it will
+            // contain it). But for interpreted languages, the launcher might try to
+            // load a user-provided request handler from the source file instead of bundling
+            // it, so we have to adjust the import statement inside the launcher to point
+            // to the respective source file. Previously, Legacy Runtimes simply expected
+            // the user-provided request-handler to be copied right next to the launcher,
+            // but with the new File System API, files won't be moved around unnecessarily.
+            if (handlerHasImport) {
+                const { fsPath } = handlerFile;
+                const encoding = 'utf-8';
+                // This is the true directory of the user-provided request handler in the
+                // source files, so that's what we will use as an import path in the launcher.
+                const locationPrefix = path_1.relative(entry, outputPath);
+                let handlerContent = await fs_extra_1.default.readFile(fsPath, encoding);
+                const importPaths = [
+                    // This is the full entrypoint path, like `./api/test.py`. In our tests
+                    // Python didn't support importing from a parent directory without using different
+                    // code in the launcher that registers it as a location for modules and then changing
+                    // the importing syntax, but continuing to import it like before seems to work. If
+                    // other languages need this, we should consider excluding Python explicitly.
+                    // `./${entrypoint}`,
+                    // This is the entrypoint path without extension, like `api/test`
+                    entrypoint.slice(0, -ext.length),
+                ];
+                // Generate a list of regular expressions that we can use for
+                // finding matches, but only allow matches if the import path is
+                // wrapped inside single (') or double quotes (").
+                const patterns = importPaths.map(path => {
+                    // eslint-disable-next-line no-useless-escape
+                    return new RegExp(`('|")(${path.replace(/\./g, '\\.')})('|")`, 'g');
+                });
+                let replacedMatch = null;
+                for (const pattern of patterns) {
+                    const newContent = handlerContent.replace(pattern, (_, p1, p2, p3) => {
+                        return `${p1}${path_1.join(locationPrefix, p2)}${p3}`;
+                    });
+                    if (newContent !== handlerContent) {
+                        _1.debug(`Replaced "${pattern}" inside "${entry}" to ensure correct import of user-provided request handler`);
+                        handlerContent = newContent;
+                        replacedMatch = true;
+                    }
+                }
+                if (!replacedMatch) {
+                    new Error(`No replacable matches for "${importPaths[0]}" or "${importPaths[1]}" found in "${fsPath}"`);
+                }
+                await fs_extra_1.default.writeFile(entry, handlerContent, encoding);
+            }
+            else {
+                await fs_extra_1.default.copy(handlerFile.fsPath, entry);
+            }
+            // Legacy Runtimes based on interpreted languages will create a new launcher file
+            // for every entrypoint, but they will create each one inside `workPath`, which means that
+            // the launcher for one entrypoint will overwrite the launcher provided for the previous
+            // entrypoint. That's why, above, we copy the file contents into the new destination (and
+            // optionally transform them along the way), instead of linking. We then also want to remove
+            // the copy origin right here, so that the `workPath` doesn't contain a useless launcher file
+            // once the build has finished running.
+            await fs_extra_1.default.remove(handlerFile.fsPath);
+            _1.debug(`Removed temporary file "${handlerFile.fsPath}"`);
+            const nft = `${entry}.nft.json`;
+            const json = JSON.stringify({
+                version: 2,
+                files: Object.keys(lambdaFiles)
+                    .map(file => {
+                    const { fsPath } = lambdaFiles[file];
+                    if (!fsPath) {
+                        throw new Error(`File "${file}" is missing valid \`fsPath\` property`);
+                    }
+                    // The handler was already moved into position above.
+                    if (file === handlerFileBase) {
+                        return;
+                    }
+                    return normalize_path_1.normalizePath(path_1.relative(path_1.dirname(nft), fsPath));
+                })
+                    .filter(Boolean),
+            });
+            await fs_extra_1.default.writeFile(nft, json);
+            // Add an entry that will later on be added to the `functions-manifest.json`
+            // file that is placed inside of the `.output` directory.
+            pages[normalize_path_1.normalizePath(entryPath)] = {
+                // Because the underlying file used as a handler was placed
+                // inside `.output/server/pages/api`, it no longer has the name it originally
+                // had and is now named after the API Route that it's responsible for,
+                // so we have to adjust the name of the Lambda handler accordingly.
+                handler: handler.replace(handlerFileName, path_1.parse(entry).name),
+                runtime: output.runtime,
+                memory: output.memory,
+                maxDuration: output.maxDuration,
+                environment: output.environment,
+                allowQuery: output.allowQuery,
+            };
+        }
+        // Add any Serverless Functions that were exposed by the Legacy Runtime
+        // to the `functions-manifest.json` file provided in `.output`.
+        await _experimental_updateFunctionsManifest({ workPath, pages });
+    };
+}
+exports._experimental_convertRuntimeToPlugin = _experimental_convertRuntimeToPlugin;
+async function readJson(filePath) {
+    try {
+        const str = await fs_extra_1.default.readFile(filePath, 'utf8');
+        return JSON.parse(str);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return {};
+        }
+        throw err;
+    }
+}
+/**
+ * If `.output/functions-manifest.json` exists, append to the pages
+ * property. Otherwise write a new file.
+ */
+async function _experimental_updateFunctionsManifest({ workPath, pages, }) {
+    const functionsManifestPath = path_1.join(workPath, '.output', 'functions-manifest.json');
+    const functionsManifest = await readJson(functionsManifestPath);
+    if (!functionsManifest.version)
+        functionsManifest.version = 2;
+    if (!functionsManifest.pages)
+        functionsManifest.pages = {};
+    for (const [pageKey, pageConfig] of Object.entries(pages)) {
+        functionsManifest.pages[pageKey] = { ...pageConfig };
+    }
+    await fs_extra_1.default.writeFile(functionsManifestPath, JSON.stringify(functionsManifest));
+}
+exports._experimental_updateFunctionsManifest = _experimental_updateFunctionsManifest;
+/**
+ * Append routes to the `routes-manifest.json` file.
+ * If the file does not exist, it will be created.
+ */
+async function _experimental_updateRoutesManifest({ workPath, redirects, rewrites, headers, dynamicRoutes, staticRoutes, }) {
+    const routesManifestPath = path_1.join(workPath, '.output', 'routes-manifest.json');
+    const routesManifest = await readJson(routesManifestPath);
+    if (!routesManifest.version)
+        routesManifest.version = 3;
+    if (routesManifest.pages404 === undefined)
+        routesManifest.pages404 = true;
+    if (redirects) {
+        if (!routesManifest.redirects)
+            routesManifest.redirects = [];
+        routesManifest.redirects.push(...redirects);
+    }
+    if (rewrites) {
+        if (!routesManifest.rewrites)
+            routesManifest.rewrites = [];
+        routesManifest.rewrites.push(...rewrites);
+    }
+    if (headers) {
+        if (!routesManifest.headers)
+            routesManifest.headers = [];
+        routesManifest.headers.push(...headers);
+    }
+    if (dynamicRoutes) {
+        if (!routesManifest.dynamicRoutes)
+            routesManifest.dynamicRoutes = [];
+        routesManifest.dynamicRoutes.push(...dynamicRoutes);
+    }
+    if (staticRoutes) {
+        if (!routesManifest.staticRoutes)
+            routesManifest.staticRoutes = [];
+        routesManifest.staticRoutes.push(...staticRoutes);
+    }
+    await fs_extra_1.default.writeFile(routesManifestPath, JSON.stringify(routesManifest));
+}
+exports._experimental_updateRoutesManifest = _experimental_updateRoutesManifest;
+
+
 /***/ }),
 
 /***/ 1868:
@@ -32044,6 +33110,7 @@ async function detectBuilders(files, pkg, options = {}) {
             redirectRoutes: null,
             rewriteRoutes: null,
             errorRoutes: null,
+            limitedRoutes: null,
         };
     }
     const sortedFiles = files.sort(sortFiles);
@@ -32091,6 +33158,7 @@ async function detectBuilders(files, pkg, options = {}) {
                     redirectRoutes: null,
                     rewriteRoutes: null,
                     errorRoutes: null,
+                    limitedRoutes: null,
                 };
             }
             if (apiRoute) {
@@ -32145,6 +33213,7 @@ async function detectBuilders(files, pkg, options = {}) {
                 defaultRoutes: null,
                 rewriteRoutes: null,
                 errorRoutes: null,
+                limitedRoutes: null,
             };
         }
         // If `outputDirectory` is an empty string,
@@ -32181,6 +33250,7 @@ async function detectBuilders(files, pkg, options = {}) {
             defaultRoutes: null,
             rewriteRoutes: null,
             errorRoutes: null,
+            limitedRoutes: null,
         };
     }
     const builders = [];
@@ -32199,7 +33269,7 @@ async function detectBuilders(files, pkg, options = {}) {
             });
         }
     }
-    const routesResult = getRouteResult(apiRoutes, dynamicRoutes, usedOutputDirectory, apiBuilders, frontendBuilder, options);
+    const routesResult = getRouteResult(pkg, apiRoutes, dynamicRoutes, usedOutputDirectory, apiBuilders, frontendBuilder, options);
     return {
         warnings,
         builders: builders.length ? builders : null,
@@ -32208,6 +33278,7 @@ async function detectBuilders(files, pkg, options = {}) {
         defaultRoutes: routesResult.defaultRoutes,
         rewriteRoutes: routesResult.rewriteRoutes,
         errorRoutes: routesResult.errorRoutes,
+        limitedRoutes: routesResult.limitedRoutes,
     };
 }
 exports.detectBuilders = detectBuilders;
@@ -32648,23 +33719,51 @@ function createRouteFromPath(filePath, featHandleMiss, cleanUrls) {
     }
     return { route, isDynamic };
 }
-function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders, frontendBuilder, options) {
+function getRouteResult(pkg, apiRoutes, dynamicRoutes, outputDirectory, apiBuilders, frontendBuilder, options) {
     var _a, _b;
+    const deps = Object.assign({}, pkg === null || pkg === void 0 ? void 0 : pkg.dependencies, pkg === null || pkg === void 0 ? void 0 : pkg.devDependencies);
     const defaultRoutes = [];
     const redirectRoutes = [];
     const rewriteRoutes = [];
     const errorRoutes = [];
+    const limitedRoutes = {
+        defaultRoutes: [],
+        redirectRoutes: [],
+        rewriteRoutes: [],
+    };
     const framework = ((_a = frontendBuilder === null || frontendBuilder === void 0 ? void 0 : frontendBuilder.config) === null || _a === void 0 ? void 0 : _a.framework) || '';
     const isNextjs = framework === 'nextjs' || _1.isOfficialRuntime('next', frontendBuilder === null || frontendBuilder === void 0 ? void 0 : frontendBuilder.use);
     const ignoreRuntimes = (_b = slugToFramework.get(framework)) === null || _b === void 0 ? void 0 : _b.ignoreRuntimes;
     if (apiRoutes && apiRoutes.length > 0) {
         if (options.featHandleMiss) {
+            // Exclude extension names if the corresponding plugin is not found in package.json
+            // detectBuilders({ignoreRoutesForBuilders: ['@vercel/python']})
+            // return a copy of routes.
+            // We should exclud errorRoutes and
             const extSet = detectApiExtensions(apiBuilders);
+            const withTag = options.tag ? `@${options.tag}` : '';
+            const extSetLimited = detectApiExtensions(apiBuilders.filter(b => {
+                if (b.use === `@vercel/python${withTag}` &&
+                    !('vercel-plugin-python' in deps)) {
+                    return false;
+                }
+                if (b.use === `@vercel/go${withTag}` &&
+                    !('vercel-plugin-go' in deps)) {
+                    return false;
+                }
+                if (b.use === `@vercel/ruby${withTag}` &&
+                    !('vercel-plugin-ruby' in deps)) {
+                    return false;
+                }
+                return true;
+            }));
             if (extSet.size > 0) {
-                const exts = Array.from(extSet)
+                const extGroup = `(?:\\.(?:${Array.from(extSet)
+                    .map(ext => ext.slice(1))
+                    .join('|')}))`;
+                const extGroupLimited = `(?:\\.(?:${Array.from(extSetLimited)
                     .map(ext => ext.slice(1))
-                    .join('|');
-                const extGroup = `(?:\\.(?:${exts}))`;
+                    .join('|')}))`;
                 if (options.cleanUrls) {
                     redirectRoutes.push({
                         src: `^/(api(?:.+)?)/index${extGroup}?/?$`,
@@ -32678,6 +33777,18 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
                         },
                         status: 308,
                     });
+                    limitedRoutes.redirectRoutes.push({
+                        src: `^/(api(?:.+)?)/index${extGroupLimited}?/?$`,
+                        headers: { Location: options.trailingSlash ? '/$1/' : '/$1' },
+                        status: 308,
+                    });
+                    limitedRoutes.redirectRoutes.push({
+                        src: `^/api/(.+)${extGroupLimited}/?$`,
+                        headers: {
+                            Location: options.trailingSlash ? '/api/$1/' : '/api/$1',
+                        },
+                        status: 308,
+                    });
                 }
                 else {
                     defaultRoutes.push({ handle: 'miss' });
@@ -32686,9 +33797,16 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
                         dest: '/api/$1',
                         check: true,
                     });
+                    limitedRoutes.defaultRoutes.push({ handle: 'miss' });
+                    limitedRoutes.defaultRoutes.push({
+                        src: `^/api/(.+)${extGroupLimited}$`,
+                        dest: '/api/$1',
+                        check: true,
+                    });
                 }
             }
             rewriteRoutes.push(...dynamicRoutes);
+            limitedRoutes.rewriteRoutes.push(...dynamicRoutes);
             if (typeof ignoreRuntimes === 'undefined') {
                 // This route is only necessary to hide the directory listing
                 // to avoid enumerating serverless function names.
@@ -32733,6 +33851,7 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
         redirectRoutes,
         rewriteRoutes,
         errorRoutes,
+        limitedRoutes,
     };
 }
 function sortFilesBySegmentCount(fileA, fileB) {
@@ -32759,6 +33878,187 @@ function sortFilesBySegmentCount(fileA, fileB) {
 }
 
 
+/***/ }),
+
+/***/ 1182:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.detectFileSystemAPI = void 0;
+const semver_1 = __importDefault(__webpack_require__(2879));
+const _1 = __webpack_require__(2855);
+const enableFileSystemApiFrameworks = new Set(['solidstart']);
+/**
+ * If the Deployment can be built with the new File System API,
+ * return the new Builder. Otherwise an "Exclusion Condition"
+ * was hit so return `null` builder with a `reason` for exclusion.
+ */
+async function detectFileSystemAPI({ files, projectSettings, builders, vercelConfig, pkg, tag, enableFlag = false, }) {
+    const framework = projectSettings.framework || '';
+    const deps = Object.assign({}, pkg === null || pkg === void 0 ? void 0 : pkg.dependencies, pkg === null || pkg === void 0 ? void 0 : pkg.devDependencies);
+    const plugins = Object.keys(deps).filter(dep => dep.startsWith('vercel-plugin-'));
+    const hasDotOutput = Object.keys(files).some(file => file.startsWith('.output/'));
+    const hasMiddleware = Boolean(files['_middleware.js'] || files['_middleware.ts']);
+    const metadata = {
+        plugins,
+        hasDotOutput,
+        hasMiddleware,
+    };
+    const isEnabled = enableFlag ||
+        hasMiddleware ||
+        hasDotOutput ||
+        enableFileSystemApiFrameworks.has(framework);
+    if (!isEnabled) {
+        return { metadata, fsApiBuilder: null, reason: 'Flag not enabled.' };
+    }
+    if ((vercelConfig === null || vercelConfig === void 0 ? void 0 : vercelConfig.builds) && vercelConfig.builds.length > 0) {
+        return {
+            metadata,
+            fsApiBuilder: null,
+            reason: 'Detected `builds` in vercel.json. Please remove it in favor of CLI plugins.',
+        };
+    }
+    if (Object.values((vercelConfig === null || vercelConfig === void 0 ? void 0 : vercelConfig.functions) || {}).some(fn => !!fn.runtime)) {
+        return {
+            metadata,
+            fsApiBuilder: null,
+            reason: 'Detected `functions.runtime` in vercel.json. Please remove it in favor of CLI plugins.',
+        };
+    }
+    if (process.env.HUGO_VERSION) {
+        return {
+            metadata,
+            fsApiBuilder: null,
+            reason: 'Detected `HUGO_VERSION` environment variable. Please remove it.',
+        };
+    }
+    if (process.env.ZOLA_VERSION) {
+        return {
+            metadata,
+            fsApiBuilder: null,
+            reason: 'Detected `ZOLA_VERSION` environment variable. Please remove it.',
+        };
+    }
+    if (process.env.GUTENBERG_VERSION) {
+        return {
+            metadata,
+            fsApiBuilder: null,
+            reason: 'Detected `GUTENBERG_VERSION` environment variable. Please remove it.',
+        };
+    }
+    const invalidBuilder = builders.find(({ use }) => {
+        const valid = _1.isOfficialRuntime('go', use) ||
+            _1.isOfficialRuntime('python', use) ||
+            _1.isOfficialRuntime('ruby', use) ||
+            _1.isOfficialRuntime('node', use) ||
+            _1.isOfficialRuntime('next', use) ||
+            _1.isOfficialRuntime('static', use) ||
+            _1.isOfficialRuntime('static-build', use);
+        return !valid;
+    });
+    if (invalidBuilder) {
+        return {
+            metadata,
+            fsApiBuilder: null,
+            reason: `Detected \`${invalidBuilder.use}\` in vercel.json. Please remove it in favor of CLI plugins.`,
+        };
+    }
+    for (const lang of ['go', 'python', 'ruby']) {
+        for (const { use } of builders) {
+            const plugin = 'vercel-plugin-' + lang;
+            if (_1.isOfficialRuntime(lang, use) && !deps[plugin]) {
+                return {
+                    metadata,
+                    fsApiBuilder: null,
+                    reason: `Detected \`${lang}\` Serverless Function usage without plugin \`${plugin}\`. Please run \`npm i ${plugin}\`.`,
+                };
+            }
+        }
+    }
+    if (framework === 'nuxtjs' ||
+        framework === 'sveltekit' ||
+        framework === 'redwoodjs') {
+        return {
+            metadata,
+            fsApiBuilder: null,
+            reason: `Detected framework \`${framework}\` that only supports legacy File System API. Please contact the framework author.`,
+        };
+    }
+    if (framework === 'nextjs' && !hasDotOutput) {
+        // Use the old pipeline if a custom output directory was specified for Next.js
+        // because `vercel build` cannot ensure that the directory will be in the same
+        // location as `.output`, which can break imports (not just nft.json files).
+        if (projectSettings === null || projectSettings === void 0 ? void 0 : projectSettings.outputDirectory) {
+            return {
+                metadata,
+                fsApiBuilder: null,
+                reason: `Detected Next.js with Output Directory \`${projectSettings.outputDirectory}\` override. Please change it back to the default.`,
+            };
+        }
+        const nextVersion = deps['next'];
+        if (!nextVersion) {
+            return {
+                metadata,
+                fsApiBuilder: null,
+                reason: `Detected Next.js in Project Settings but missing \`next\` package.json dependencies. Please run \`npm i next\`.`,
+            };
+        }
+        // TODO: Read version from lockfile instead of package.json
+        if (nextVersion !== 'latest' && nextVersion !== 'canary') {
+            const fixedVersion = semver_1.default.valid(semver_1.default.coerce(nextVersion) || '');
+            if (!fixedVersion || !semver_1.default.gte(fixedVersion, '12.0.0')) {
+                return {
+                    metadata,
+                    fsApiBuilder: null,
+                    reason: `Detected legacy Next.js version "${nextVersion}" in package.json. Please run \`npm i next@latest\` to upgrade.`,
+                };
+            }
+        }
+    }
+    if (!hasDotOutput) {
+        // TODO: Read version from lockfile instead of package.json
+        const vercelCliVersion = deps['vercel'];
+        if (vercelCliVersion &&
+            vercelCliVersion !== 'latest' &&
+            vercelCliVersion !== 'canary') {
+            const fixedVersion = semver_1.default.valid(semver_1.default.coerce(vercelCliVersion) || '');
+            // TODO: we might want to use '24.0.0' once its released
+            if (!fixedVersion || !semver_1.default.gte(fixedVersion, '23.1.3-canary.68')) {
+                return {
+                    metadata,
+                    fsApiBuilder: null,
+                    reason: `Detected legacy Vercel CLI version "${vercelCliVersion}" in package.json. Please run \`npm i vercel@latest\` to upgrade.`,
+                };
+            }
+        }
+    }
+    const frontendBuilder = builders.find(({ use }) => _1.isOfficialRuntime('next', use) ||
+        _1.isOfficialRuntime('static', use) ||
+        _1.isOfficialRuntime('static-build', use));
+    const config = (frontendBuilder === null || frontendBuilder === void 0 ? void 0 : frontendBuilder.config) || {};
+    const withTag = tag ? `@${tag}` : '';
+    const fsApiBuilder = {
+        use: `@vercelruntimes/file-system-api${withTag}`,
+        src: '**',
+        config: {
+            ...config,
+            fileSystemAPI: true,
+            framework: config.framework || framework || null,
+            projectSettings,
+            hasMiddleware,
+            hasDotOutput,
+        },
+    };
+    return { metadata, fsApiBuilder, reason: null };
+}
+exports.detectFileSystemAPI = detectFileSystemAPI;
+
+
 /***/ }),
 
 /***/ 5224:
@@ -33311,6 +34611,7 @@ const assert_1 = __importDefault(__webpack_require__(2357));
 const glob_1 = __importDefault(__webpack_require__(1104));
 const util_1 = __webpack_require__(1669);
 const fs_extra_1 = __webpack_require__(5392);
+const normalize_path_1 = __webpack_require__(6261);
 const file_fs_ref_1 = __importDefault(__webpack_require__(9331));
 const vanillaGlob = util_1.promisify(glob_1.default);
 async function glob(pattern, opts, mountpoint) {
@@ -33334,7 +34635,7 @@ async function glob(pattern, opts, mountpoint) {
     options.dot = true;
     const files = await vanillaGlob(pattern, options);
     for (const relativePath of files) {
-        const fsPath = path_1.default.join(options.cwd, relativePath).replace(/\\/g, '/');
+        const fsPath = normalize_path_1.normalizePath(path_1.default.join(options.cwd, relativePath));
         let stat = options.statCache[fsPath];
         assert_1.default(stat, `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`);
         const isSymlink = options.symlinks[fsPath];
@@ -33440,6 +34741,25 @@ function isDiscontinued({ discontinueDate }) {
 }
 
 
+/***/ }),
+
+/***/ 6261:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.normalizePath = void 0;
+const isWin = process.platform === 'win32';
+/**
+ * Convert Windows separators to Unix separators.
+ */
+function normalizePath(p) {
+    return isWin ? p.replace(/\\/g, '/') : p;
+}
+exports.normalizePath = normalizePath;
+
+
 /***/ }),
 
 /***/ 7792:
@@ -33870,6 +35190,73 @@ function streamToBuffer(stream) {
 exports.default = streamToBuffer;
 
 
+/***/ }),
+
+/***/ 1148:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const path_1 = __importDefault(__webpack_require__(5622));
+const fs_extra_1 = __importDefault(__webpack_require__(5392));
+const ignore_1 = __importDefault(__webpack_require__(3556));
+function isCodedError(error) {
+    return (error !== null &&
+        error !== undefined &&
+        error.code !== undefined);
+}
+function clearRelative(s) {
+    return s.replace(/(\n|^)\.\//g, '$1');
+}
+async function default_1(downloadPath, rootDirectory) {
+    const readFile = async (p) => {
+        try {
+            return await fs_extra_1.default.readFile(p, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' ||
+                (error instanceof Error && error.message.includes('ENOENT'))) {
+                return undefined;
+            }
+            throw error;
+        }
+    };
+    const vercelIgnorePath = path_1.default.join(downloadPath, rootDirectory || '', '.vercelignore');
+    const nowIgnorePath = path_1.default.join(downloadPath, rootDirectory || '', '.nowignore');
+    const ignoreContents = [];
+    try {
+        ignoreContents.push(...(await Promise.all([readFile(vercelIgnorePath), readFile(nowIgnorePath)])).filter(Boolean));
+    }
+    catch (error) {
+        if (isCodedError(error) && error.code === 'ENOTDIR') {
+            console.log(`Warning: Cannot read ignore file from ${vercelIgnorePath}`);
+        }
+        else {
+            throw error;
+        }
+    }
+    if (ignoreContents.length === 2) {
+        throw new Error('Cannot use both a `.vercelignore` and `.nowignore` file. Please delete the `.nowignore` file.');
+    }
+    if (ignoreContents.length === 0) {
+        return () => false;
+    }
+    const ignoreFilter = 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
+        if (p === 'now.json' || p === 'vercel.json')
+            return false;
+        return ignoreFilter.test(p).ignored;
+    };
+}
+exports.default = default_1;
+
+
 /***/ }),
 
 /***/ 2855:
@@ -33903,7 +35290,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.getPlatformEnv = exports.isStaticRuntime = exports.isOfficialRuntime = exports.readConfigFile = exports.DetectorFilesystem = exports.detectFramework = exports.detectApiExtensions = exports.detectApiDirectory = exports.detectOutputDirectory = exports.detectBuilders = exports.scanParentDirs = exports.getLambdaOptionsFromFunction = exports.isSymbolicLink = exports.debug = exports.shouldServe = exports.streamToBuffer = exports.getSpawnOptions = exports.getDiscontinuedNodeVersions = exports.getLatestNodeVersion = exports.getNodeVersion = exports.runShellScript = exports.runPipInstall = exports.runBundleInstall = exports.runNpmInstall = exports.getNodeBinPath = exports.walkParentDirs = exports.spawnCommand = exports.execCommand = exports.runPackageJsonScript = exports.installDependencies = exports.getScriptName = exports.spawnAsync = exports.execAsync = exports.rename = exports.glob = exports.getWriteableDirectory = exports.download = exports.Prerender = exports.createLambda = exports.Lambda = exports.FileRef = exports.FileFsRef = exports.FileBlob = void 0;
+exports.getPlatformEnv = exports.isStaticRuntime = exports.isOfficialRuntime = exports._experimental_updateRoutesManifest = exports._experimental_updateFunctionsManifest = exports._experimental_convertRuntimeToPlugin = exports.normalizePath = exports.readConfigFile = exports.DetectorFilesystem = exports.detectFramework = exports.detectFileSystemAPI = exports.detectApiExtensions = exports.detectApiDirectory = exports.detectOutputDirectory = exports.detectBuilders = exports.getIgnoreFilter = exports.scanParentDirs = exports.getLambdaOptionsFromFunction = exports.isSymbolicLink = exports.debug = exports.shouldServe = exports.streamToBuffer = exports.getSpawnOptions = exports.getDiscontinuedNodeVersions = exports.getLatestNodeVersion = exports.getNodeVersion = exports.runShellScript = exports.runPipInstall = exports.runBundleInstall = exports.runNpmInstall = exports.getNodeBinPath = exports.walkParentDirs = exports.spawnCommand = exports.execCommand = exports.runPackageJsonScript = exports.installDependencies = exports.getScriptName = exports.spawnAsync = exports.execAsync = exports.rename = exports.glob = exports.getWriteableDirectory = exports.download = exports.Prerender = exports.createLambda = exports.Lambda = exports.FileRef = exports.FileFsRef = exports.FileBlob = void 0;
 const file_blob_1 = __importDefault(__webpack_require__(2397));
 exports.FileBlob = file_blob_1.default;
 const file_fs_ref_1 = __importDefault(__webpack_require__(9331));
@@ -33952,17 +35339,27 @@ const should_serve_1 = __importDefault(__webpack_require__(2564));
 exports.shouldServe = should_serve_1.default;
 const debug_1 = __importDefault(__webpack_require__(1868));
 exports.debug = debug_1.default;
+const get_ignore_filter_1 = __importDefault(__webpack_require__(1148));
+exports.getIgnoreFilter = get_ignore_filter_1.default;
 var detect_builders_1 = __webpack_require__(4246);
 Object.defineProperty(exports, "detectBuilders", ({ enumerable: true, get: function () { return detect_builders_1.detectBuilders; } }));
 Object.defineProperty(exports, "detectOutputDirectory", ({ enumerable: true, get: function () { return detect_builders_1.detectOutputDirectory; } }));
 Object.defineProperty(exports, "detectApiDirectory", ({ enumerable: true, get: function () { return detect_builders_1.detectApiDirectory; } }));
 Object.defineProperty(exports, "detectApiExtensions", ({ enumerable: true, get: function () { return detect_builders_1.detectApiExtensions; } }));
+var detect_file_system_api_1 = __webpack_require__(1182);
+Object.defineProperty(exports, "detectFileSystemAPI", ({ enumerable: true, get: function () { return detect_file_system_api_1.detectFileSystemAPI; } }));
 var detect_framework_1 = __webpack_require__(5224);
 Object.defineProperty(exports, "detectFramework", ({ enumerable: true, get: function () { return detect_framework_1.detectFramework; } }));
 var filesystem_1 = __webpack_require__(461);
 Object.defineProperty(exports, "DetectorFilesystem", ({ enumerable: true, get: function () { return filesystem_1.DetectorFilesystem; } }));
 var read_config_file_1 = __webpack_require__(7792);
 Object.defineProperty(exports, "readConfigFile", ({ enumerable: true, get: function () { return read_config_file_1.readConfigFile; } }));
+var normalize_path_1 = __webpack_require__(6261);
+Object.defineProperty(exports, "normalizePath", ({ enumerable: true, get: function () { return normalize_path_1.normalizePath; } }));
+var convert_runtime_to_plugin_1 = __webpack_require__(7276);
+Object.defineProperty(exports, "_experimental_convertRuntimeToPlugin", ({ enumerable: true, get: function () { return convert_runtime_to_plugin_1._experimental_convertRuntimeToPlugin; } }));
+Object.defineProperty(exports, "_experimental_updateFunctionsManifest", ({ enumerable: true, get: function () { return convert_runtime_to_plugin_1._experimental_updateFunctionsManifest; } }));
+Object.defineProperty(exports, "_experimental_updateRoutesManifest", ({ enumerable: true, get: function () { return convert_runtime_to_plugin_1._experimental_updateRoutesManifest; } }));
 __exportStar(__webpack_require__(2416), exports);
 __exportStar(__webpack_require__(5748), exports);
 __exportStar(__webpack_require__(3983), exports);
@@ -34018,7 +35415,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.getLambdaOptionsFromFunction = exports.createZip = exports.createLambda = exports.Lambda = void 0;
+exports.getLambdaOptionsFromFunction = exports.createZip = exports.createLambda = exports.Lambda = exports.FILES_SYMBOL = void 0;
 const assert_1 = __importDefault(__webpack_require__(2357));
 const async_sema_1 = __importDefault(__webpack_require__(5758));
 const yazl_1 = __webpack_require__(1223);
@@ -34026,8 +35423,9 @@ const minimatch_1 = __importDefault(__webpack_require__(9566));
 const fs_extra_1 = __webpack_require__(5392);
 const download_1 = __webpack_require__(1611);
 const stream_to_buffer_1 = __importDefault(__webpack_require__(2560));
+exports.FILES_SYMBOL = Symbol('files');
 class Lambda {
-    constructor({ zipBuffer, handler, runtime, maxDuration, memory, environment, allowQuery, }) {
+    constructor({ zipBuffer, handler, runtime, maxDuration, memory, environment, allowQuery, regions, }) {
         this.type = 'Lambda';
         this.zipBuffer = zipBuffer;
         this.handler = handler;
@@ -34036,12 +35434,13 @@ class Lambda {
         this.maxDuration = maxDuration;
         this.environment = environment;
         this.allowQuery = allowQuery;
+        this.regions = regions;
     }
 }
 exports.Lambda = Lambda;
 const sema = new async_sema_1.default(10);
 const mtime = new Date(1540000000000);
-async function createLambda({ files, handler, runtime, memory, maxDuration, environment = {}, allowQuery, }) {
+async function createLambda({ files, handler, runtime, memory, maxDuration, environment = {}, allowQuery, regions, }) {
     assert_1.default(typeof files === 'object', '"files" must be an object');
     assert_1.default(typeof handler === 'string', '"handler" is not a string');
     assert_1.default(typeof runtime === 'string', '"runtime" is not a string');
@@ -34056,17 +35455,25 @@ async function createLambda({ files, handler, runtime, memory, maxDuration, envi
         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');
     }
+    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');
+    }
     await sema.acquire();
     try {
         const zipBuffer = await createZip(files);
-        return new Lambda({
+        const lambda = new Lambda({
             zipBuffer,
             handler,
             runtime,
             memory,
             maxDuration,
             environment,
+            regions,
         });
+        // @ts-ignore This symbol is a private API
+        lambda[exports.FILES_SYMBOL] = files;
+        return lambda;
     }
     finally {
         sema.release();