Deleted vendor folder

5 files changed, 0 insertions, 1419 deletions

diff --git a/vendor/tempfile/src/file/imp/mod.rs b/vendor/tempfile/src/file/imp/mod.rs
deleted file mode 100644
index fbb2bbf..0000000
--- a/vendor/tempfile/src/file/imp/mod.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-cfg_if::cfg_if! {
-    if #[cfg(any(unix, target_os = "redox", target_os = "wasi"))] {
-        mod unix;
-        pub use self::unix::*;
-    } else if #[cfg(windows)] {
-        mod windows;
-        pub use self::windows::*;
-    } else {
-        mod other;
-        pub use self::other::*;
-    }
-}
diff --git a/vendor/tempfile/src/file/imp/other.rs b/vendor/tempfile/src/file/imp/other.rs
deleted file mode 100644
index 8721d2d..0000000
--- a/vendor/tempfile/src/file/imp/other.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use std::fs::{File, OpenOptions};
-use std::io;
-use std::path::Path;
-
-fn not_supported<T>() -> io::Result<T> {
-    Err(io::Error::new(
-        io::ErrorKind::Other,
-        "operation not supported on this platform",
-    ))
-}
-
-pub fn create_named(_path: &Path, _open_options: &mut OpenOptions) -> io::Result<File> {
-    not_supported()
-}
-
-pub fn create(_dir: &Path) -> io::Result<File> {
-    not_supported()
-}
-
-pub fn reopen(_file: &File, _path: &Path) -> io::Result<File> {
-    not_supported()
-}
-
-pub fn persist(_old_path: &Path, _new_path: &Path, _overwrite: bool) -> io::Result<()> {
-    not_supported()
-}
-
-pub fn keep(_path: &Path) -> io::Result<()> {
-    not_supported()
-}
diff --git a/vendor/tempfile/src/file/imp/unix.rs b/vendor/tempfile/src/file/imp/unix.rs
deleted file mode 100644
index 79aba78..0000000
--- a/vendor/tempfile/src/file/imp/unix.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-use std::env;
-use std::ffi::OsStr;
-use std::fs::{self, File, OpenOptions};
-use std::io;
-cfg_if::cfg_if! {
-    if #[cfg(not(target_os = "wasi"))] {
-        use std::os::unix::fs::{MetadataExt, OpenOptionsExt};
-    } else {
-        #[cfg(feature = "nightly")]
-        use std::os::wasi::fs::MetadataExt;
-    }
-}
-use crate::util;
-use std::path::Path;
-
-#[cfg(not(target_os = "redox"))]
-use {
-    rustix::fs::{rename, unlink},
-    std::fs::hard_link,
-};
-
-pub fn create_named(path: &Path, open_options: &mut OpenOptions) -> io::Result<File> {
-    open_options.read(true).write(true).create_new(true);
-
-    #[cfg(not(target_os = "wasi"))]
-    {
-        open_options.mode(0o600);
-    }
-
-    open_options.open(path)
-}
-
-fn create_unlinked(path: &Path) -> io::Result<File> {
-    let tmp;
-    // shadow this to decrease the lifetime. It can't live longer than `tmp`.
-    let mut path = path;
-    if !path.is_absolute() {
-        let cur_dir = env::current_dir()?;
-        tmp = cur_dir.join(path);
-        path = &tmp;
-    }
-
-    let f = create_named(path, &mut OpenOptions::new())?;
-    // don't care whether the path has already been unlinked,
-    // but perhaps there are some IO error conditions we should send up?
-    let _ = fs::remove_file(path);
-    Ok(f)
-}
-
-#[cfg(target_os = "linux")]
-pub fn create(dir: &Path) -> io::Result<File> {
-    use rustix::{fs::OFlags, io::Errno};
-    OpenOptions::new()
-        .read(true)
-        .write(true)
-        .custom_flags(OFlags::TMPFILE.bits() as i32) // do not mix with `create_new(true)`
-        .open(dir)
-        .or_else(|e| {
-            match Errno::from_io_error(&e) {
-                // These are the three "not supported" error codes for O_TMPFILE.
-                Some(Errno::OPNOTSUPP) | Some(Errno::ISDIR) | Some(Errno::NOENT) => {
-                    create_unix(dir)
-                }
-                _ => Err(e),
-            }
-        })
-}
-
-#[cfg(not(target_os = "linux"))]
-pub fn create(dir: &Path) -> io::Result<File> {
-    create_unix(dir)
-}
-
-fn create_unix(dir: &Path) -> io::Result<File> {
-    util::create_helper(
-        dir,
-        OsStr::new(".tmp"),
-        OsStr::new(""),
-        crate::NUM_RAND_CHARS,
-        |path| create_unlinked(&path),
-    )
-}
-
-#[cfg(any(not(target_os = "wasi"), feature = "nightly"))]
-pub fn reopen(file: &File, path: &Path) -> io::Result<File> {
-    let new_file = OpenOptions::new().read(true).write(true).open(path)?;
-    let old_meta = file.metadata()?;
-    let new_meta = new_file.metadata()?;
-    if old_meta.dev() != new_meta.dev() || old_meta.ino() != new_meta.ino() {
-        return Err(io::Error::new(
-            io::ErrorKind::NotFound,
-            "original tempfile has been replaced",
-        ));
-    }
-    Ok(new_file)
-}
-
-#[cfg(all(target_os = "wasi", not(feature = "nightly")))]
-pub fn reopen(_file: &File, _path: &Path) -> io::Result<File> {
-    return Err(io::Error::new(
-        io::ErrorKind::Other,
-        "this operation is supported on WASI only on nightly Rust (with `nightly` feature enabled)",
-    ));
-}
-
-#[cfg(not(target_os = "redox"))]
-pub fn persist(old_path: &Path, new_path: &Path, overwrite: bool) -> io::Result<()> {
-    if overwrite {
-        rename(old_path, new_path)?;
-    } else {
-        // On Linux, use `renameat_with` to avoid overwriting an existing name,
-        // if the kernel and the filesystem support it.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        {
-            use rustix::fs::{renameat_with, RenameFlags, CWD};
-            use rustix::io::Errno;
-            use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
-
-            static NOSYS: AtomicBool = AtomicBool::new(false);
-            if !NOSYS.load(Relaxed) {
-                match renameat_with(CWD, old_path, CWD, new_path, RenameFlags::NOREPLACE) {
-                    Ok(()) => return Ok(()),
-                    Err(Errno::NOSYS) => NOSYS.store(true, Relaxed),
-                    Err(Errno::INVAL) => {}
-                    Err(e) => return Err(e.into()),
-                }
-            }
-        }
-
-        // Otherwise use `hard_link` to create the new filesystem name, which
-        // will fail if the name already exists, and then `unlink` to remove
-        // the old name.
-        hard_link(old_path, new_path)?;
-
-        // Ignore unlink errors. Can we do better?
-        let _ = unlink(old_path);
-    }
-    Ok(())
-}
-
-#[cfg(target_os = "redox")]
-pub fn persist(_old_path: &Path, _new_path: &Path, _overwrite: bool) -> io::Result<()> {
-    // XXX implement when possible
-    Err(io::Error::from_raw_os_error(syscall::ENOSYS))
-}
-
-pub fn keep(_: &Path) -> io::Result<()> {
-    Ok(())
-}
diff --git a/vendor/tempfile/src/file/imp/windows.rs b/vendor/tempfile/src/file/imp/windows.rs
deleted file mode 100644
index 9df65f9..0000000
--- a/vendor/tempfile/src/file/imp/windows.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use std::ffi::OsStr;
-use std::fs::{File, OpenOptions};
-use std::os::windows::ffi::OsStrExt;
-use std::os::windows::fs::OpenOptionsExt;
-use std::os::windows::io::{AsRawHandle, FromRawHandle, RawHandle};
-use std::path::Path;
-use std::{io, iter};
-
-use windows_sys::Win32::Foundation::{HANDLE, INVALID_HANDLE_VALUE};
-use windows_sys::Win32::Storage::FileSystem::{
-    MoveFileExW, ReOpenFile, SetFileAttributesW, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_TEMPORARY,
-    FILE_FLAG_DELETE_ON_CLOSE, FILE_GENERIC_READ, FILE_GENERIC_WRITE, FILE_SHARE_DELETE,
-    FILE_SHARE_READ, FILE_SHARE_WRITE, MOVEFILE_REPLACE_EXISTING,
-};
-
-use crate::util;
-
-fn to_utf16(s: &Path) -> Vec<u16> {
-    s.as_os_str().encode_wide().chain(iter::once(0)).collect()
-}
-
-pub fn create_named(path: &Path, open_options: &mut OpenOptions) -> io::Result<File> {
-    open_options
-        .create_new(true)
-        .read(true)
-        .write(true)
-        .custom_flags(FILE_ATTRIBUTE_TEMPORARY)
-        .open(path)
-}
-
-pub fn create(dir: &Path) -> io::Result<File> {
-    util::create_helper(
-        dir,
-        OsStr::new(".tmp"),
-        OsStr::new(""),
-        crate::NUM_RAND_CHARS,
-        |path| {
-            OpenOptions::new()
-                .create_new(true)
-                .read(true)
-                .write(true)
-                .share_mode(0)
-                .custom_flags(FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE)
-                .open(path)
-        },
-    )
-}
-
-pub fn reopen(file: &File, _path: &Path) -> io::Result<File> {
-    let handle = file.as_raw_handle();
-    unsafe {
-        let handle = ReOpenFile(
-            handle as HANDLE,
-            FILE_GENERIC_READ | FILE_GENERIC_WRITE,
-            FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
-            0,
-        );
-        if handle == INVALID_HANDLE_VALUE {
-            Err(io::Error::last_os_error())
-        } else {
-            Ok(FromRawHandle::from_raw_handle(handle as RawHandle))
-        }
-    }
-}
-
-pub fn keep(path: &Path) -> io::Result<()> {
-    unsafe {
-        let path_w = to_utf16(path);
-        if SetFileAttributesW(path_w.as_ptr(), FILE_ATTRIBUTE_NORMAL) == 0 {
-            Err(io::Error::last_os_error())
-        } else {
-            Ok(())
-        }
-    }
-}
-
-pub fn persist(old_path: &Path, new_path: &Path, overwrite: bool) -> io::Result<()> {
-    unsafe {
-        let old_path_w = to_utf16(old_path);
-        let new_path_w = to_utf16(new_path);
-
-        // Don't succeed if this fails. We don't want to claim to have successfully persisted a file
-        // still marked as temporary because this file won't have the same consistency guarantees.
-        if SetFileAttributesW(old_path_w.as_ptr(), FILE_ATTRIBUTE_NORMAL) == 0 {
-            return Err(io::Error::last_os_error());
-        }
-
-        let mut flags = 0;
-
-        if overwrite {
-            flags |= MOVEFILE_REPLACE_EXISTING;
-        }
-
-        if MoveFileExW(old_path_w.as_ptr(), new_path_w.as_ptr(), flags) == 0 {
-            let e = io::Error::last_os_error();
-            // If this fails, the temporary file is now un-hidden and no longer marked temporary
-            // (slightly less efficient) but it will still work.
-            let _ = SetFileAttributesW(old_path_w.as_ptr(), FILE_ATTRIBUTE_TEMPORARY);
-            Err(e)
-        } else {
-            Ok(())
-        }
-    }
-}
diff --git a/vendor/tempfile/src/file/mod.rs b/vendor/tempfile/src/file/mod.rs
deleted file mode 100644
index 8a28343..0000000
--- a/vendor/tempfile/src/file/mod.rs
+++ /dev/null
@@ -1,1124 +0,0 @@
-use std::env;
-use std::error;
-use std::ffi::OsStr;
-use std::fmt;
-use std::fs::{self, File, OpenOptions};
-use std::io::{self, Read, Seek, SeekFrom, Write};
-use std::mem;
-use std::ops::Deref;
-#[cfg(unix)]
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
-#[cfg(target_os = "wasi")]
-use std::os::wasi::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
-#[cfg(windows)]
-use std::os::windows::io::{AsHandle, AsRawHandle, BorrowedHandle, RawHandle};
-use std::path::{Path, PathBuf};
-
-use crate::error::IoResultExt;
-use crate::Builder;
-
-mod imp;
-
-/// Create a new temporary file.
-///
-/// The file will be created in the location returned by [`std::env::temp_dir()`].
-///
-/// # Security
-///
-/// This variant is secure/reliable in the presence of a pathological temporary file cleaner.
-///
-/// # Resource Leaking
-///
-/// The temporary file will be automatically removed by the OS when the last handle to it is closed.
-/// This doesn't rely on Rust destructors being run, so will (almost) never fail to clean up the temporary file.
-///
-/// # Errors
-///
-/// If the file can not be created, `Err` is returned.
-///
-/// # Examples
-///
-/// ```
-/// use tempfile::tempfile;
-/// use std::io::{self, Write};
-///
-/// # fn main() {
-/// #     if let Err(_) = run() {
-/// #         ::std::process::exit(1);
-/// #     }
-/// # }
-/// # fn run() -> Result<(), io::Error> {
-/// // Create a file inside of `std::env::temp_dir()`.
-/// let mut file = tempfile()?;
-///
-/// writeln!(file, "Brian was here. Briefly.")?;
-/// # Ok(())
-/// # }
-/// ```
-///
-/// [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html
-pub fn tempfile() -> io::Result<File> {
-    tempfile_in(env::temp_dir())
-}
-
-/// Create a new temporary file in the specified directory.
-///
-/// # Security
-///
-/// This variant is secure/reliable in the presence of a pathological temporary file cleaner.
-/// If the temporary file isn't created in [`std::env::temp_dir()`] then temporary file cleaners aren't an issue.
-///
-/// # Resource Leaking
-///
-/// The temporary file will be automatically removed by the OS when the last handle to it is closed.
-/// This doesn't rely on Rust destructors being run, so will (almost) never fail to clean up the temporary file.
-///
-/// # Errors
-///
-/// If the file can not be created, `Err` is returned.
-///
-/// # Examples
-///
-/// ```
-/// use tempfile::tempfile_in;
-/// use std::io::{self, Write};
-///
-/// # fn main() {
-/// #     if let Err(_) = run() {
-/// #         ::std::process::exit(1);
-/// #     }
-/// # }
-/// # fn run() -> Result<(), io::Error> {
-/// // Create a file inside of the current working directory
-/// let mut file = tempfile_in("./")?;
-///
-/// writeln!(file, "Brian was here. Briefly.")?;
-/// # Ok(())
-/// # }
-/// ```
-///
-/// [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html
-pub fn tempfile_in<P: AsRef<Path>>(dir: P) -> io::Result<File> {
-    imp::create(dir.as_ref())
-}
-
-/// Error returned when persisting a temporary file path fails.
-#[derive(Debug)]
-pub struct PathPersistError {
-    /// The underlying IO error.
-    pub error: io::Error,
-    /// The temporary file path that couldn't be persisted.
-    pub path: TempPath,
-}
-
-impl From<PathPersistError> for io::Error {
-    #[inline]
-    fn from(error: PathPersistError) -> io::Error {
-        error.error
-    }
-}
-
-impl From<PathPersistError> for TempPath {
-    #[inline]
-    fn from(error: PathPersistError) -> TempPath {
-        error.path
-    }
-}
-
-impl fmt::Display for PathPersistError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "failed to persist temporary file path: {}", self.error)
-    }
-}
-
-impl error::Error for PathPersistError {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        Some(&self.error)
-    }
-}
-
-/// A path to a named temporary file without an open file handle.
-///
-/// This is useful when the temporary file needs to be used by a child process,
-/// for example.
-///
-/// When dropped, the temporary file is deleted.
-pub struct TempPath {
-    path: Box<Path>,
-}
-
-impl TempPath {
-    /// Close and remove the temporary file.
-    ///
-    /// Use this if you want to detect errors in deleting the file.
-    ///
-    /// # Errors
-    ///
-    /// If the file cannot be deleted, `Err` is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io;
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), io::Error> {
-    /// let file = NamedTempFile::new()?;
-    ///
-    /// // Close the file, but keep the path to it around.
-    /// let path = file.into_temp_path();
-    ///
-    /// // By closing the `TempPath` explicitly, we can check that it has
-    /// // been deleted successfully. If we don't close it explicitly, the
-    /// // file will still be deleted when `file` goes out of scope, but we
-    /// // won't know whether deleting the file succeeded.
-    /// path.close()?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn close(mut self) -> io::Result<()> {
-        let result = fs::remove_file(&self.path).with_err_path(|| &*self.path);
-        self.path = PathBuf::new().into_boxed_path();
-        mem::forget(self);
-        result
-    }
-
-    /// Persist the temporary file at the target path.
-    ///
-    /// If a file exists at the target path, persist will atomically replace it.
-    /// If this method fails, it will return `self` in the resulting
-    /// [`PathPersistError`].
-    ///
-    /// Note: Temporary files cannot be persisted across filesystems. Also
-    /// neither the file contents nor the containing directory are
-    /// synchronized, so the update may not yet have reached the disk when
-    /// `persist` returns.
-    ///
-    /// # Security
-    ///
-    /// Only use this method if you're positive that a temporary file cleaner
-    /// won't have deleted your file. Otherwise, you might end up persisting an
-    /// attacker controlled file.
-    ///
-    /// # Errors
-    ///
-    /// If the file cannot be moved to the new location, `Err` is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io::{self, Write};
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), io::Error> {
-    /// let mut file = NamedTempFile::new()?;
-    /// writeln!(file, "Brian was here. Briefly.")?;
-    ///
-    /// let path = file.into_temp_path();
-    /// path.persist("./saved_file.txt")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// [`PathPersistError`]: struct.PathPersistError.html
-    pub fn persist<P: AsRef<Path>>(mut self, new_path: P) -> Result<(), PathPersistError> {
-        match imp::persist(&self.path, new_path.as_ref(), true) {
-            Ok(_) => {
-                // Don't drop `self`. We don't want to try deleting the old
-                // temporary file path. (It'll fail, but the failure is never
-                // seen.)
-                self.path = PathBuf::new().into_boxed_path();
-                mem::forget(self);
-                Ok(())
-            }
-            Err(e) => Err(PathPersistError {
-                error: e,
-                path: self,
-            }),
-        }
-    }
-
-    /// Persist the temporary file at the target path if and only if no file exists there.
-    ///
-    /// If a file exists at the target path, fail. If this method fails, it will
-    /// return `self` in the resulting [`PathPersistError`].
-    ///
-    /// Note: Temporary files cannot be persisted across filesystems. Also Note:
-    /// This method is not atomic. It can leave the original link to the
-    /// temporary file behind.
-    ///
-    /// # Security
-    ///
-    /// Only use this method if you're positive that a temporary file cleaner
-    /// won't have deleted your file. Otherwise, you might end up persisting an
-    /// attacker controlled file.
-    ///
-    /// # Errors
-    ///
-    /// If the file cannot be moved to the new location or a file already exists
-    /// there, `Err` is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io::{self, Write};
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), io::Error> {
-    /// let mut file = NamedTempFile::new()?;
-    /// writeln!(file, "Brian was here. Briefly.")?;
-    ///
-    /// let path = file.into_temp_path();
-    /// path.persist_noclobber("./saved_file.txt")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// [`PathPersistError`]: struct.PathPersistError.html
-    pub fn persist_noclobber<P: AsRef<Path>>(
-        mut self,
-        new_path: P,
-    ) -> Result<(), PathPersistError> {
-        match imp::persist(&self.path, new_path.as_ref(), false) {
-            Ok(_) => {
-                // Don't drop `self`. We don't want to try deleting the old
-                // temporary file path. (It'll fail, but the failure is never
-                // seen.)
-                self.path = PathBuf::new().into_boxed_path();
-                mem::forget(self);
-                Ok(())
-            }
-            Err(e) => Err(PathPersistError {
-                error: e,
-                path: self,
-            }),
-        }
-    }
-
-    /// Keep the temporary file from being deleted. This function will turn the
-    /// temporary file into a non-temporary file without moving it.
-    ///
-    ///
-    /// # Errors
-    ///
-    /// On some platforms (e.g., Windows), we need to mark the file as
-    /// non-temporary. This operation could fail.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io::{self, Write};
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), io::Error> {
-    /// let mut file = NamedTempFile::new()?;
-    /// writeln!(file, "Brian was here. Briefly.")?;
-    ///
-    /// let path = file.into_temp_path();
-    /// let path = path.keep()?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// [`PathPersistError`]: struct.PathPersistError.html
-    pub fn keep(mut self) -> Result<PathBuf, PathPersistError> {
-        match imp::keep(&self.path) {
-            Ok(_) => {
-                // Don't drop `self`. We don't want to try deleting the old
-                // temporary file path. (It'll fail, but the failure is never
-                // seen.)
-                let path = mem::replace(&mut self.path, PathBuf::new().into_boxed_path());
-                mem::forget(self);
-                Ok(path.into())
-            }
-            Err(e) => Err(PathPersistError {
-                error: e,
-                path: self,
-            }),
-        }
-    }
-
-    /// Create a new TempPath from an existing path. This can be done even if no
-    /// file exists at the given path.
-    ///
-    /// This is mostly useful for interacting with libraries and external
-    /// components that provide files to be consumed or expect a path with no
-    /// existing file to be given.
-    pub fn from_path(path: impl Into<PathBuf>) -> Self {
-        Self {
-            path: path.into().into_boxed_path(),
-        }
-    }
-}
-
-impl fmt::Debug for TempPath {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.path.fmt(f)
-    }
-}
-
-impl Drop for TempPath {
-    fn drop(&mut self) {
-        let _ = fs::remove_file(&self.path);
-    }
-}
-
-impl Deref for TempPath {
-    type Target = Path;
-
-    fn deref(&self) -> &Path {
-        &self.path
-    }
-}
-
-impl AsRef<Path> for TempPath {
-    fn as_ref(&self) -> &Path {
-        &self.path
-    }
-}
-
-impl AsRef<OsStr> for TempPath {
-    fn as_ref(&self) -> &OsStr {
-        self.path.as_os_str()
-    }
-}
-
-/// A named temporary file.
-///
-/// The default constructor, [`NamedTempFile::new()`], creates files in
-/// the location returned by [`std::env::temp_dir()`], but `NamedTempFile`
-/// can be configured to manage a temporary file in any location
-/// by constructing with [`NamedTempFile::new_in()`].
-///
-/// # Security
-///
-/// Most operating systems employ temporary file cleaners to delete old
-/// temporary files. Unfortunately these temporary file cleaners don't always
-/// reliably _detect_ whether the temporary file is still being used.
-///
-/// Specifically, the following sequence of events can happen:
-///
-/// 1. A user creates a temporary file with `NamedTempFile::new()`.
-/// 2. Time passes.
-/// 3. The temporary file cleaner deletes (unlinks) the temporary file from the
-///    filesystem.
-/// 4. Some other program creates a new file to replace this deleted temporary
-///    file.
-/// 5. The user tries to re-open the temporary file (in the same program or in a
-///    different program) by path. Unfortunately, they'll end up opening the
-///    file created by the other program, not the original file.
-///
-/// ## Operating System Specific Concerns
-///
-/// The behavior of temporary files and temporary file cleaners differ by
-/// operating system.
-///
-/// ### Windows
-///
-/// On Windows, open files _can't_ be deleted. This removes most of the concerns
-/// around temporary file cleaners.
-///
-/// Furthermore, temporary files are, by default, created in per-user temporary
-/// file directories so only an application running as the same user would be
-/// able to interfere (which they could do anyways). However, an application
-/// running as the same user can still _accidentally_ re-create deleted
-/// temporary files if the number of random bytes in the temporary file name is
-/// too small.
-///
-/// So, the only real concern on Windows is:
-///
-/// 1. Opening a named temporary file in a world-writable directory.
-/// 2. Using the `into_temp_path()` and/or `into_parts()` APIs to close the file
-///    handle without deleting the underlying file.
-/// 3. Continuing to use the file by path.
-///
-/// ### UNIX
-///
-/// Unlike on Windows, UNIX (and UNIX like) systems allow open files to be
-/// "unlinked" (deleted).
-///
-/// #### MacOS
-///
-/// Like on Windows, temporary files are created in per-user temporary file
-/// directories by default so calling `NamedTempFile::new()` should be
-/// relatively safe.
-///
-/// #### Linux
-///
-/// Unfortunately, most _Linux_ distributions don't create per-user temporary
-/// file directories. Worse, systemd's tmpfiles daemon (a common temporary file
-/// cleaner) will happily remove open temporary files if they haven't been
-/// modified within the last 10 days.
-///
-/// # Resource Leaking
-///
-/// If the program exits before the `NamedTempFile` destructor is
-/// run, the temporary file will not be deleted. This can happen
-/// if the process exits using [`std::process::exit()`], a segfault occurs,
-/// receiving an interrupt signal like `SIGINT` that is not handled, or by using
-/// a statically declared `NamedTempFile` instance (like with [`lazy_static`]).
-///
-/// Use the [`tempfile()`] function unless you need a named file path.
-///
-/// [`tempfile()`]: fn.tempfile.html
-/// [`NamedTempFile::new()`]: #method.new
-/// [`NamedTempFile::new_in()`]: #method.new_in
-/// [`std::env::temp_dir()`]: https://doc.rust-lang.org/std/env/fn.temp_dir.html
-/// [`std::process::exit()`]: http://doc.rust-lang.org/std/process/fn.exit.html
-/// [`lazy_static`]: https://github.com/rust-lang-nursery/lazy-static.rs/issues/62
-pub struct NamedTempFile<F = File> {
-    path: TempPath,
-    file: F,
-}
-
-impl<F> fmt::Debug for NamedTempFile<F> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "NamedTempFile({:?})", self.path)
-    }
-}
-
-impl<F> AsRef<Path> for NamedTempFile<F> {
-    #[inline]
-    fn as_ref(&self) -> &Path {
-        self.path()
-    }
-}
-
-/// Error returned when persisting a temporary file fails.
-pub struct PersistError<F = File> {
-    /// The underlying IO error.
-    pub error: io::Error,
-    /// The temporary file that couldn't be persisted.
-    pub file: NamedTempFile<F>,
-}
-
-impl<F> fmt::Debug for PersistError<F> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "PersistError({:?})", self.error)
-    }
-}
-
-impl<F> From<PersistError<F>> for io::Error {
-    #[inline]
-    fn from(error: PersistError<F>) -> io::Error {
-        error.error
-    }
-}
-
-impl<F> From<PersistError<F>> for NamedTempFile<F> {
-    #[inline]
-    fn from(error: PersistError<F>) -> NamedTempFile<F> {
-        error.file
-    }
-}
-
-impl<F> fmt::Display for PersistError<F> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "failed to persist temporary file: {}", self.error)
-    }
-}
-
-impl<F> error::Error for PersistError<F> {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        Some(&self.error)
-    }
-}
-
-impl NamedTempFile<File> {
-    /// Create a new named temporary file.
-    ///
-    /// See [`Builder`] for more configuration.
-    ///
-    /// # Security
-    ///
-    /// This will create a temporary file in the default temporary file
-    /// directory (platform dependent). This has security implications on many
-    /// platforms so please read the security section of this type's
-    /// documentation.
-    ///
-    /// Reasons to use this method:
-    ///
-    ///   1. The file has a short lifetime and your temporary file cleaner is
-    ///      sane (doesn't delete recently accessed files).
-    ///
-    ///   2. You trust every user on your system (i.e. you are the only user).
-    ///
-    ///   3. You have disabled your system's temporary file cleaner or verified
-    ///      that your system doesn't have a temporary file cleaner.
-    ///
-    /// Reasons not to use this method:
-    ///
-    ///   1. You'll fix it later. No you won't.
-    ///
-    ///   2. You don't care about the security of the temporary file. If none of
-    ///      the "reasons to use this method" apply, referring to a temporary
-    ///      file by name may allow an attacker to create/overwrite your
-    ///      non-temporary files. There are exceptions but if you don't already
-    ///      know them, don't use this method.
-    ///
-    /// # Errors
-    ///
-    /// If the file can not be created, `Err` is returned.
-    ///
-    /// # Examples
-    ///
-    /// Create a named temporary file and write some data to it:
-    ///
-    /// ```no_run
-    /// # use std::io::{self, Write};
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), ::std::io::Error> {
-    /// let mut file = NamedTempFile::new()?;
-    ///
-    /// writeln!(file, "Brian was here. Briefly.")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// [`Builder`]: struct.Builder.html
-    pub fn new() -> io::Result<NamedTempFile> {
-        Builder::new().tempfile()
-    }
-
-    /// Create a new named temporary file in the specified directory.
-    ///
-    /// This is equivalent to:
-    ///
-    /// ```ignore
-    /// Builder::new().tempfile_in(dir)
-    /// ```
-    ///
-    /// See [`NamedTempFile::new()`] for details.
-    ///
-    /// [`NamedTempFile::new()`]: #method.new
-    pub fn new_in<P: AsRef<Path>>(dir: P) -> io::Result<NamedTempFile> {
-        Builder::new().tempfile_in(dir)
-    }
-
-    /// Create a new named temporary file with the specified filename prefix.
-    ///
-    /// See [`NamedTempFile::new()`] for details.
-    ///
-    /// [`NamedTempFile::new()`]: #method.new
-    pub fn with_prefix<S: AsRef<OsStr>>(prefix: S) -> io::Result<NamedTempFile> {
-        Builder::new().prefix(&prefix).tempfile()
-    }
-    /// Create a new named temporary file with the specified filename prefix,
-    /// in the specified directory.
-    ///
-    /// This is equivalent to:
-    ///
-    /// ```ignore
-    /// Builder::new().prefix(&prefix).tempfile_in(directory)
-    /// ```
-    ///
-    /// See [`NamedTempFile::new()`] for details.
-    ///
-    /// [`NamedTempFile::new()`]: #method.new
-    pub fn with_prefix_in<S: AsRef<OsStr>, P: AsRef<Path>>(
-        prefix: S,
-        dir: P,
-    ) -> io::Result<NamedTempFile> {
-        Builder::new().prefix(&prefix).tempfile_in(dir)
-    }
-}
-
-impl<F> NamedTempFile<F> {
-    /// Get the temporary file's path.
-    ///
-    /// # Security
-    ///
-    /// Referring to a temporary file's path may not be secure in all cases.
-    /// Please read the security section on the top level documentation of this
-    /// type for details.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io::{self, Write};
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), ::std::io::Error> {
-    /// let file = NamedTempFile::new()?;
-    ///
-    /// println!("{:?}", file.path());
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[inline]
-    pub fn path(&self) -> &Path {
-        &self.path
-    }
-
-    /// Close and remove the temporary file.
-    ///
-    /// Use this if you want to detect errors in deleting the file.
-    ///
-    /// # Errors
-    ///
-    /// If the file cannot be deleted, `Err` is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io;
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), io::Error> {
-    /// let file = NamedTempFile::new()?;
-    ///
-    /// // By closing the `NamedTempFile` explicitly, we can check that it has
-    /// // been deleted successfully. If we don't close it explicitly,
-    /// // the file will still be deleted when `file` goes out
-    /// // of scope, but we won't know whether deleting the file
-    /// // succeeded.
-    /// file.close()?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn close(self) -> io::Result<()> {
-        let NamedTempFile { path, .. } = self;
-        path.close()
-    }
-
-    /// Persist the temporary file at the target path.
-    ///
-    /// If a file exists at the target path, persist will atomically replace it.
-    /// If this method fails, it will return `self` in the resulting
-    /// [`PersistError`].
-    ///
-    /// Note: Temporary files cannot be persisted across filesystems. Also
-    /// neither the file contents nor the containing directory are
-    /// synchronized, so the update may not yet have reached the disk when
-    /// `persist` returns.
-    ///
-    /// # Security
-    ///
-    /// This method persists the temporary file using its path and may not be
-    /// secure in all cases. Please read the security section on the top
-    /// level documentation of this type for details.
-    ///
-    /// # Errors
-    ///
-    /// If the file cannot be moved to the new location, `Err` is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io::{self, Write};
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), io::Error> {
-    /// let file = NamedTempFile::new()?;
-    ///
-    /// let mut persisted_file = file.persist("./saved_file.txt")?;
-    /// writeln!(persisted_file, "Brian was here. Briefly.")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// [`PersistError`]: struct.PersistError.html
-    pub fn persist<P: AsRef<Path>>(self, new_path: P) -> Result<F, PersistError<F>> {
-        let NamedTempFile { path, file } = self;
-        match path.persist(new_path) {
-            Ok(_) => Ok(file),
-            Err(err) => {
-                let PathPersistError { error, path } = err;
-                Err(PersistError {
-                    file: NamedTempFile { path, file },
-                    error,
-                })
-            }
-        }
-    }
-
-    /// Persist the temporary file at the target path if and only if no file exists there.
-    ///
-    /// If a file exists at the target path, fail. If this method fails, it will
-    /// return `self` in the resulting PersistError.
-    ///
-    /// Note: Temporary files cannot be persisted across filesystems. Also Note:
-    /// This method is not atomic. It can leave the original link to the
-    /// temporary file behind.
-    ///
-    /// # Security
-    ///
-    /// This method persists the temporary file using its path and may not be
-    /// secure in all cases. Please read the security section on the top
-    /// level documentation of this type for details.
-    ///
-    /// # Errors
-    ///
-    /// If the file cannot be moved to the new location or a file already exists there,
-    /// `Err` is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io::{self, Write};
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), io::Error> {
-    /// let file = NamedTempFile::new()?;
-    ///
-    /// let mut persisted_file = file.persist_noclobber("./saved_file.txt")?;
-    /// writeln!(persisted_file, "Brian was here. Briefly.")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn persist_noclobber<P: AsRef<Path>>(self, new_path: P) -> Result<F, PersistError<F>> {
-        let NamedTempFile { path, file } = self;
-        match path.persist_noclobber(new_path) {
-            Ok(_) => Ok(file),
-            Err(err) => {
-                let PathPersistError { error, path } = err;
-                Err(PersistError {
-                    file: NamedTempFile { path, file },
-                    error,
-                })
-            }
-        }
-    }
-
-    /// Keep the temporary file from being deleted. This function will turn the
-    /// temporary file into a non-temporary file without moving it.
-    ///
-    ///
-    /// # Errors
-    ///
-    /// On some platforms (e.g., Windows), we need to mark the file as
-    /// non-temporary. This operation could fail.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io::{self, Write};
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), io::Error> {
-    /// let mut file = NamedTempFile::new()?;
-    /// writeln!(file, "Brian was here. Briefly.")?;
-    ///
-    /// let (file, path) = file.keep()?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// [`PathPersistError`]: struct.PathPersistError.html
-    pub fn keep(self) -> Result<(F, PathBuf), PersistError<F>> {
-        let (file, path) = (self.file, self.path);
-        match path.keep() {
-            Ok(path) => Ok((file, path)),
-            Err(PathPersistError { error, path }) => Err(PersistError {
-                file: NamedTempFile { path, file },
-                error,
-            }),
-        }
-    }
-
-    /// Get a reference to the underlying file.
-    pub fn as_file(&self) -> &F {
-        &self.file
-    }
-
-    /// Get a mutable reference to the underlying file.
-    pub fn as_file_mut(&mut self) -> &mut F {
-        &mut self.file
-    }
-
-    /// Convert the temporary file into a `std::fs::File`.
-    ///
-    /// The inner file will be deleted.
-    pub fn into_file(self) -> F {
-        self.file
-    }
-
-    /// Closes the file, leaving only the temporary file path.
-    ///
-    /// This is useful when another process must be able to open the temporary
-    /// file.
-    pub fn into_temp_path(self) -> TempPath {
-        self.path
-    }
-
-    /// Converts the named temporary file into its constituent parts.
-    ///
-    /// Note: When the path is dropped, the file is deleted but the file handle
-    /// is still usable.
-    pub fn into_parts(self) -> (F, TempPath) {
-        (self.file, self.path)
-    }
-
-    /// Creates a `NamedTempFile` from its constituent parts.
-    ///
-    /// This can be used with [`NamedTempFile::into_parts`] to reconstruct the
-    /// `NamedTempFile`.
-    pub fn from_parts(file: F, path: TempPath) -> Self {
-        Self { file, path }
-    }
-}
-
-impl NamedTempFile<File> {
-    /// Securely reopen the temporary file.
-    ///
-    /// This function is useful when you need multiple independent handles to
-    /// the same file. It's perfectly fine to drop the original `NamedTempFile`
-    /// while holding on to `File`s returned by this function; the `File`s will
-    /// remain usable. However, they may not be nameable.
-    ///
-    /// # Errors
-    ///
-    /// If the file cannot be reopened, `Err` is returned.
-    ///
-    /// # Security
-    ///
-    /// Unlike `File::open(my_temp_file.path())`, `NamedTempFile::reopen()`
-    /// guarantees that the re-opened file is the _same_ file, even in the
-    /// presence of pathological temporary file cleaners.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use std::io;
-    /// use tempfile::NamedTempFile;
-    ///
-    /// # fn main() {
-    /// #     if let Err(_) = run() {
-    /// #         ::std::process::exit(1);
-    /// #     }
-    /// # }
-    /// # fn run() -> Result<(), io::Error> {
-    /// let file = NamedTempFile::new()?;
-    ///
-    /// let another_handle = file.reopen()?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn reopen(&self) -> io::Result<File> {
-        imp::reopen(self.as_file(), NamedTempFile::path(self))
-            .with_err_path(|| NamedTempFile::path(self))
-    }
-}
-
-impl<F: Read> Read for NamedTempFile<F> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.as_file_mut().read(buf).with_err_path(|| self.path())
-    }
-
-    fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result<usize> {
-        self.as_file_mut()
-            .read_vectored(bufs)
-            .with_err_path(|| self.path())
-    }
-
-    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
-        self.as_file_mut()
-            .read_to_end(buf)
-            .with_err_path(|| self.path())
-    }
-
-    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
-        self.as_file_mut()
-            .read_to_string(buf)
-            .with_err_path(|| self.path())
-    }
-
-    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
-        self.as_file_mut()
-            .read_exact(buf)
-            .with_err_path(|| self.path())
-    }
-}
-
-impl Read for &NamedTempFile<File> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.as_file().read(buf).with_err_path(|| self.path())
-    }
-
-    fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result<usize> {
-        self.as_file()
-            .read_vectored(bufs)
-            .with_err_path(|| self.path())
-    }
-
-    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
-        self.as_file()
-            .read_to_end(buf)
-            .with_err_path(|| self.path())
-    }
-
-    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
-        self.as_file()
-            .read_to_string(buf)
-            .with_err_path(|| self.path())
-    }
-
-    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
-        self.as_file().read_exact(buf).with_err_path(|| self.path())
-    }
-}
-
-impl<F: Write> Write for NamedTempFile<F> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.as_file_mut().write(buf).with_err_path(|| self.path())
-    }
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        self.as_file_mut().flush().with_err_path(|| self.path())
-    }
-
-    fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
-        self.as_file_mut()
-            .write_vectored(bufs)
-            .with_err_path(|| self.path())
-    }
-
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.as_file_mut()
-            .write_all(buf)
-            .with_err_path(|| self.path())
-    }
-
-    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
-        self.as_file_mut()
-            .write_fmt(fmt)
-            .with_err_path(|| self.path())
-    }
-}
-
-impl Write for &NamedTempFile<File> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.as_file().write(buf).with_err_path(|| self.path())
-    }
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        self.as_file().flush().with_err_path(|| self.path())
-    }
-
-    fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
-        self.as_file()
-            .write_vectored(bufs)
-            .with_err_path(|| self.path())
-    }
-
-    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.as_file().write_all(buf).with_err_path(|| self.path())
-    }
-
-    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
-        self.as_file().write_fmt(fmt).with_err_path(|| self.path())
-    }
-}
-
-impl<F: Seek> Seek for NamedTempFile<F> {
-    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
-        self.as_file_mut().seek(pos).with_err_path(|| self.path())
-    }
-}
-
-impl Seek for &NamedTempFile<File> {
-    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
-        self.as_file().seek(pos).with_err_path(|| self.path())
-    }
-}
-
-#[cfg(any(unix, target_os = "wasi"))]
-impl<F: AsFd> AsFd for NamedTempFile<F> {
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        self.as_file().as_fd()
-    }
-}
-
-#[cfg(any(unix, target_os = "wasi"))]
-impl<F: AsRawFd> AsRawFd for NamedTempFile<F> {
-    #[inline]
-    fn as_raw_fd(&self) -> RawFd {
-        self.as_file().as_raw_fd()
-    }
-}
-
-#[cfg(windows)]
-impl<F: AsHandle> AsHandle for NamedTempFile<F> {
-    #[inline]
-    fn as_handle(&self) -> BorrowedHandle<'_> {
-        self.as_file().as_handle()
-    }
-}
-
-#[cfg(windows)]
-impl<F: AsRawHandle> AsRawHandle for NamedTempFile<F> {
-    #[inline]
-    fn as_raw_handle(&self) -> RawHandle {
-        self.as_file().as_raw_handle()
-    }
-}
-
-pub(crate) fn create_named(
-    mut path: PathBuf,
-    open_options: &mut OpenOptions,
-) -> io::Result<NamedTempFile> {
-    // Make the path absolute. Otherwise, changing directories could cause us to
-    // delete the wrong file.
-    if !path.is_absolute() {
-        path = env::current_dir()?.join(path)
-    }
-    imp::create_named(&path, open_options)
-        .with_err_path(|| path.clone())
-        .map(|file| NamedTempFile {
-            path: TempPath {
-                path: path.into_boxed_path(),
-            },
-            file,
-        })
-}