wasmtime 21.0.1 → 22.0.0

data/ext/cargo-vendor/wasi-common-21.0.1/src/string_array.rs

@@ -1,74 +0,0 @@
-use crate::{Error, ErrorExt};
-use wiggle::GuestPtr;
-
-pub struct StringArray {
-    elems: Vec<String>,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum StringArrayError {
-    #[error("Number of elements exceeds 2^32")]
-    NumberElements,
-    #[error("Element size exceeds 2^32")]
-    ElementSize,
-    #[error("Cumulative size exceeds 2^32")]
-    CumulativeSize,
-}
-
-impl StringArray {
-    pub fn new() -> Self {
-        StringArray { elems: Vec::new() }
-    }
-
-    pub fn push(&mut self, elem: String) -> Result<(), StringArrayError> {
-        if self.elems.len() + 1 > std::u32::MAX as usize {
-            return Err(StringArrayError::NumberElements);
-        }
-        if elem.as_bytes().len() + 1 > std::u32::MAX as usize {
-            return Err(StringArrayError::ElementSize);
-        }
-        if self.cumulative_size() as usize + elem.as_bytes().len() + 1 > std::u32::MAX as usize {
-            return Err(StringArrayError::CumulativeSize);
-        }
-        self.elems.push(elem);
-        Ok(())
-    }
-
-    pub fn number_elements(&self) -> u32 {
-        self.elems.len() as u32
-    }
-
-    pub fn cumulative_size(&self) -> u32 {
-        self.elems
-            .iter()
-            .map(|e| e.as_bytes().len() + 1)
-            .sum::<usize>() as u32
-    }
-
-    pub fn write_to_guest<'a>(
-        &self,
-        buffer: &GuestPtr<'a, u8>,
-        element_heads: &GuestPtr<'a, GuestPtr<'a, u8>>,
-    ) -> Result<(), Error> {
-        let element_heads = element_heads.as_array(self.number_elements());
-        let buffer = buffer.as_array(self.cumulative_size());
-        let mut cursor = 0;
-        for (elem, head) in self.elems.iter().zip(element_heads.iter()) {
-            let bytes = elem.as_bytes();
-            let len = bytes.len() as u32;
-            {
-                let elem_buffer = buffer
-                    .get_range(cursor..(cursor + len))
-                    .ok_or(Error::invalid_argument())?; // Elements don't fit in buffer provided
-                elem_buffer.copy_from_slice(bytes)?;
-            }
-            buffer
-                .get(cursor + len)
-                .ok_or(Error::invalid_argument())?
-                .write(0)?; // 0 terminate
-            head?.write(buffer.get(cursor).expect("already validated"))?;
-            cursor += len + 1;
-        }
-        Ok(())
-    }
-}

data/ext/cargo-vendor/wasi-common-21.0.1/src/sync/sched/windows.rs

@@ -1,221 +0,0 @@
-// The windows scheduler is unmaintained and due for a rewrite.
-//
-// Rather than use a polling mechanism for file read/write readiness,
-// it checks readiness just once, before sleeping for any timer subscriptions.
-// Checking stdin readiness uses a worker thread which, once started, lives for the
-// lifetime of the process.
-//
-// We suspect there are bugs in this scheduler, however, we have not
-// taken the time to improve it. See bug #2880.
-
-use crate::sched::subscription::{RwEventFlags, Subscription};
-use crate::{file::WasiFile, sched::Poll, Error, ErrorExt};
-use once_cell::sync::Lazy;
-use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
-use std::sync::Mutex;
-use std::thread;
-use std::time::Duration;
-
-pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
-    poll_oneoff_(poll, wasi_file_is_stdin).await
-}
-
-pub async fn poll_oneoff_<'a>(
-    poll: &mut Poll<'a>,
-    file_is_stdin: impl Fn(&dyn WasiFile) -> bool,
-) -> Result<(), Error> {
-    if poll.is_empty() {
-        return Ok(());
-    }
-
-    let mut ready = false;
-    let waitmode = if let Some(t) = poll.earliest_clock_deadline() {
-        if let Some(duration) = t.duration_until() {
-            WaitMode::Timeout(duration)
-        } else {
-            WaitMode::Immediate
-        }
-    } else {
-        if ready {
-            WaitMode::Immediate
-        } else {
-            WaitMode::Infinite
-        }
-    };
-
-    let mut stdin_read_subs = Vec::new();
-    let mut immediate_reads = Vec::new();
-    let mut immediate_writes = Vec::new();
-    for s in poll.rw_subscriptions() {
-        match s {
-            Subscription::Read(r) => {
-                if file_is_stdin(r.file) {
-                    stdin_read_subs.push(r);
-                } else if r.file.pollable().is_some() {
-                    immediate_reads.push(r);
-                } else {
-                    return Err(Error::invalid_argument().context("file is not pollable"));
-                }
-            }
-            Subscription::Write(w) => {
-                if w.file.pollable().is_some() {
-                    immediate_writes.push(w);
-                } else {
-                    return Err(Error::invalid_argument().context("file is not pollable"));
-                }
-            }
-            Subscription::MonotonicClock { .. } => unreachable!(),
-        }
-    }
-
-    if !stdin_read_subs.is_empty() {
-        let state = STDIN_POLL
-            .lock()
-            .map_err(|_| Error::trap(anyhow::Error::msg("failed to take lock of STDIN_POLL")))?
-            .poll(waitmode)?;
-        for readsub in stdin_read_subs.into_iter() {
-            match state {
-                PollState::Ready => {
-                    readsub.complete(1, RwEventFlags::empty());
-                    ready = true;
-                }
-                PollState::NotReady | PollState::TimedOut => {}
-                PollState::Error(ref e) => {
-                    // Unfortunately, we need to deliver the Error to each of the
-                    // subscriptions, but there is no Clone on std::io::Error. So, we convert it to the
-                    // kind, and then back to std::io::Error, and finally to anyhow::Error.
-                    // When its time to turn this into an errno elsewhere, the error kind will
-                    // be inspected.
-                    let ekind = e.kind();
-                    let ioerror = std::io::Error::from(ekind);
-                    readsub.error(ioerror.into());
-                    ready = true;
-                }
-            }
-        }
-    }
-    for r in immediate_reads {
-        match r.file.num_ready_bytes() {
-            Ok(ready_bytes) => {
-                r.complete(ready_bytes, RwEventFlags::empty());
-                ready = true;
-            }
-            Err(e) => {
-                r.error(e);
-                ready = true;
-            }
-        }
-    }
-    for w in immediate_writes {
-        // Everything is always ready for writing, apparently?
-        w.complete(0, RwEventFlags::empty());
-        ready = true;
-    }
-
-    if !ready {
-        if let WaitMode::Timeout(duration) = waitmode {
-            thread::sleep(duration);
-        }
-    }
-
-    Ok(())
-}
-
-pub fn wasi_file_is_stdin(f: &dyn WasiFile) -> bool {
-    f.as_any().is::<crate::sync::stdio::Stdin>()
-}
-
-enum PollState {
-    Ready,
-    NotReady, // Not ready, but did not wait
-    TimedOut, // Not ready, waited until timeout
-    Error(std::io::Error),
-}
-
-#[derive(Copy, Clone)]
-enum WaitMode {
-    Timeout(Duration),
-    Infinite,
-    Immediate,
-}
-
-struct StdinPoll {
-    request_tx: Sender<()>,
-    notify_rx: Receiver<PollState>,
-}
-
-static STDIN_POLL: Lazy<Mutex<StdinPoll>> = Lazy::new(StdinPoll::new);
-
-impl StdinPoll {
-    pub fn new() -> Mutex<Self> {
-        let (request_tx, request_rx) = mpsc::channel();
-        let (notify_tx, notify_rx) = mpsc::channel();
-        thread::spawn(move || Self::event_loop(request_rx, notify_tx));
-        Mutex::new(StdinPoll {
-            request_tx,
-            notify_rx,
-        })
-    }
-
-    // This function should not be used directly.
-    // Correctness of this function crucially depends on the fact that
-    // mpsc::Receiver is !Sync.
-    fn poll(&self, wait_mode: WaitMode) -> Result<PollState, Error> {
-        match self.notify_rx.try_recv() {
-            // Clean up possibly unread result from previous poll.
-            Ok(_) | Err(TryRecvError::Empty) => {}
-            Err(TryRecvError::Disconnected) => {
-                return Err(Error::trap(anyhow::Error::msg(
-                    "StdinPoll notify_rx channel closed",
-                )))
-            }
-        }
-
-        // Notify the worker thread to poll stdin
-        self.request_tx
-            .send(())
-            .map_err(|_| Error::trap(anyhow::Error::msg("request_tx channel closed")))?;
-
-        // Wait for the worker thread to send a readiness notification
-        match wait_mode {
-            WaitMode::Timeout(timeout) => match self.notify_rx.recv_timeout(timeout) {
-                Ok(r) => Ok(r),
-                Err(RecvTimeoutError::Timeout) => Ok(PollState::TimedOut),
-                Err(RecvTimeoutError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
-                    "StdinPoll notify_rx channel closed",
-                ))),
-            },
-            WaitMode::Infinite => self
-                .notify_rx
-                .recv()
-                .map_err(|_| Error::trap(anyhow::Error::msg("StdinPoll notify_rx channel closed"))),
-            WaitMode::Immediate => match self.notify_rx.try_recv() {
-                Ok(r) => Ok(r),
-                Err(TryRecvError::Empty) => Ok(PollState::NotReady),
-                Err(TryRecvError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
-                    "StdinPoll notify_rx channel closed",
-                ))),
-            },
-        }
-    }
-
-    fn event_loop(request_rx: Receiver<()>, notify_tx: Sender<PollState>) -> ! {
-        use std::io::BufRead;
-        loop {
-            // Wait on a request:
-            request_rx.recv().expect("request_rx channel");
-            // Wait for data to appear in stdin. If fill_buf returns any slice, it means
-            // that either:
-            // (a) there is some data in stdin, if non-empty,
-            // (b) EOF was recieved, if its empty
-            // Linux returns `POLLIN` in both cases, so we imitate this behavior.
-            let resp = match std::io::stdin().lock().fill_buf() {
-                Ok(_) => PollState::Ready,
-                Err(e) => PollState::Error(e),
-            };
-            // Notify about data in stdin. If the read on this channel has timed out, the
-            // next poller will have to clean the channel.
-            notify_tx.send(resp).expect("notify_tx channel");
-        }
-    }
-}

data/ext/cargo-vendor/wasi-common-21.0.1/src/tokio/file.rs

@@ -1,247 +0,0 @@
-use crate::tokio::block_on_dummy_executor;
-use crate::{
-    file::{Advice, FdFlags, FileType, Filestat, WasiFile},
-    Error,
-};
-#[cfg(windows)]
-use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
-#[cfg(not(windows))]
-use io_lifetimes::AsFd;
-use std::any::Any;
-use std::borrow::Borrow;
-use std::io;
-
-pub struct File(crate::sync::file::File);
-
-impl File {
-    pub(crate) fn from_inner(file: crate::sync::file::File) -> Self {
-        File(file)
-    }
-    pub fn from_cap_std(file: cap_std::fs::File) -> Self {
-        Self::from_inner(crate::sync::file::File::from_cap_std(file))
-    }
-}
-
-pub struct TcpListener(crate::sync::net::TcpListener);
-
-impl TcpListener {
-    pub(crate) fn from_inner(listener: crate::sync::net::TcpListener) -> Self {
-        TcpListener(listener)
-    }
-    pub fn from_cap_std(listener: cap_std::net::TcpListener) -> Self {
-        Self::from_inner(crate::sync::net::TcpListener::from_cap_std(listener))
-    }
-}
-
-pub struct TcpStream(crate::sync::net::TcpStream);
-
-impl TcpStream {
-    pub(crate) fn from_inner(stream: crate::sync::net::TcpStream) -> Self {
-        TcpStream(stream)
-    }
-    pub fn from_cap_std(stream: cap_std::net::TcpStream) -> Self {
-        Self::from_inner(crate::sync::net::TcpStream::from_cap_std(stream))
-    }
-}
-
-#[cfg(unix)]
-pub struct UnixListener(crate::sync::net::UnixListener);
-
-#[cfg(unix)]
-impl UnixListener {
-    pub(crate) fn from_inner(listener: crate::sync::net::UnixListener) -> Self {
-        UnixListener(listener)
-    }
-    pub fn from_cap_std(listener: cap_std::os::unix::net::UnixListener) -> Self {
-        Self::from_inner(crate::sync::net::UnixListener::from_cap_std(listener))
-    }
-}
-
-#[cfg(unix)]
-pub struct UnixStream(crate::sync::net::UnixStream);
-
-#[cfg(unix)]
-impl UnixStream {
-    fn from_inner(stream: crate::sync::net::UnixStream) -> Self {
-        UnixStream(stream)
-    }
-    pub fn from_cap_std(stream: cap_std::os::unix::net::UnixStream) -> Self {
-        Self::from_inner(crate::sync::net::UnixStream::from_cap_std(stream))
-    }
-}
-
-pub struct Stdin(crate::sync::stdio::Stdin);
-
-pub fn stdin() -> Stdin {
-    Stdin(crate::sync::stdio::stdin())
-}
-
-pub struct Stdout(crate::sync::stdio::Stdout);
-
-pub fn stdout() -> Stdout {
-    Stdout(crate::sync::stdio::stdout())
-}
-
-pub struct Stderr(crate::sync::stdio::Stderr);
-
-pub fn stderr() -> Stderr {
-    Stderr(crate::sync::stdio::stderr())
-}
-
-macro_rules! wasi_file_impl {
-    ($ty:ty) => {
-        #[wiggle::async_trait]
-        impl WasiFile for $ty {
-            fn as_any(&self) -> &dyn Any {
-                self
-            }
-            #[cfg(unix)]
-            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
-                Some(self.0.as_fd())
-            }
-            #[cfg(windows)]
-            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
-                Some(self.0.as_raw_handle_or_socket())
-            }
-            async fn datasync(&self) -> Result<(), Error> {
-                block_on_dummy_executor(|| self.0.datasync())
-            }
-            async fn sync(&self) -> Result<(), Error> {
-                block_on_dummy_executor(|| self.0.sync())
-            }
-            async fn get_filetype(&self) -> Result<FileType, Error> {
-                block_on_dummy_executor(|| self.0.get_filetype())
-            }
-            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
-                block_on_dummy_executor(|| self.0.get_fdflags())
-            }
-            async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
-                block_on_dummy_executor(|| self.0.set_fdflags(fdflags))
-            }
-            async fn get_filestat(&self) -> Result<Filestat, Error> {
-                block_on_dummy_executor(|| self.0.get_filestat())
-            }
-            async fn set_filestat_size(&self, size: u64) -> Result<(), Error> {
-                block_on_dummy_executor(move || self.0.set_filestat_size(size))
-            }
-            async fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
-                block_on_dummy_executor(move || self.0.advise(offset, len, advice))
-            }
-            async fn read_vectored<'a>(
-                &self,
-                bufs: &mut [io::IoSliceMut<'a>],
-            ) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.read_vectored(bufs))
-            }
-            async fn read_vectored_at<'a>(
-                &self,
-                bufs: &mut [io::IoSliceMut<'a>],
-                offset: u64,
-            ) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.read_vectored_at(bufs, offset))
-            }
-            async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.write_vectored(bufs))
-            }
-            async fn write_vectored_at<'a>(
-                &self,
-                bufs: &[io::IoSlice<'a>],
-                offset: u64,
-            ) -> Result<u64, Error> {
-                if bufs.iter().map(|i| i.len()).sum::<usize>() == 0 {
-                    return Ok(0);
-                }
-                block_on_dummy_executor(move || self.0.write_vectored_at(bufs, offset))
-            }
-            async fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.seek(pos))
-            }
-            async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.peek(buf))
-            }
-            async fn set_times(
-                &self,
-                atime: Option<crate::SystemTimeSpec>,
-                mtime: Option<crate::SystemTimeSpec>,
-            ) -> Result<(), Error> {
-                block_on_dummy_executor(move || self.0.set_times(atime, mtime))
-            }
-            fn num_ready_bytes(&self) -> Result<u64, Error> {
-                self.0.num_ready_bytes()
-            }
-            fn isatty(&self) -> bool {
-                self.0.isatty()
-            }
-
-            #[cfg(not(windows))]
-            async fn readable(&self) -> Result<(), Error> {
-                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
-                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
-                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
-                // async method to ensure this is the only Future which can access the RawFd during the
-                // lifetime of the AsyncFd.
-                use std::os::unix::io::AsRawFd;
-                use tokio::io::{unix::AsyncFd, Interest};
-                let rawfd = self.0.borrow().as_fd().as_raw_fd();
-                match AsyncFd::with_interest(rawfd, Interest::READABLE) {
-                    Ok(asyncfd) => {
-                        let _ = asyncfd.readable().await?;
-                        Ok(())
-                    }
-                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
-                        // if e is EPERM, this file isnt supported by epoll because it is immediately
-                        // available for reading:
-                        Ok(())
-                    }
-                    Err(e) => Err(e.into()),
-                }
-            }
-
-            #[cfg(not(windows))]
-            async fn writable(&self) -> Result<(), Error> {
-                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
-                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
-                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
-                // async method to ensure this is the only Future which can access the RawFd during the
-                // lifetime of the AsyncFd.
-                use std::os::unix::io::AsRawFd;
-                use tokio::io::{unix::AsyncFd, Interest};
-                let rawfd = self.0.borrow().as_fd().as_raw_fd();
-                match AsyncFd::with_interest(rawfd, Interest::WRITABLE) {
-                    Ok(asyncfd) => {
-                        let _ = asyncfd.writable().await?;
-                        Ok(())
-                    }
-                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
-                        // if e is EPERM, this file isnt supported by epoll because it is immediately
-                        // available for writing:
-                        Ok(())
-                    }
-                    Err(e) => Err(e.into()),
-                }
-            }
-
-            async fn sock_accept(&self, fdflags: FdFlags) -> Result<Box<dyn WasiFile>, Error> {
-                block_on_dummy_executor(|| self.0.sock_accept(fdflags))
-            }
-        }
-        #[cfg(windows)]
-        impl AsRawHandleOrSocket for $ty {
-            #[inline]
-            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
-                self.0.borrow().as_raw_handle_or_socket()
-            }
-        }
-    };
-}
-
-wasi_file_impl!(File);
-wasi_file_impl!(TcpListener);
-wasi_file_impl!(TcpStream);
-#[cfg(unix)]
-wasi_file_impl!(UnixListener);
-#[cfg(unix)]
-wasi_file_impl!(UnixStream);
-wasi_file_impl!(Stdin);
-wasi_file_impl!(Stdout);
-wasi_file_impl!(Stderr);

data/ext/cargo-vendor/wasm-encoder-0.207.0/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"89d2633e5a4c68c66e9891fb848039bbc57394e0f9ae64f7488f93dc8d8091ae","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"ac016c4843a7e1a5737255b39418732783592222dc518020730edf9dd46a1c13","src/component.rs":"700351503077106eadf612f46079418e0b437ed0a6179dc16979768205b2ecbf","src/component/aliases.rs":"be5215154b872ed5664f3bfe2aa1391f36a2575aa9d53971ab61868a1c446e9d","src/component/builder.rs":"ea35c74cb0369181e9c0ce9729ff175d25f05bd63b48dcbbf703a53dfc113c7c","src/component/canonicals.rs":"a4f9c7a2b8ac3783d7337a5579cf71df2f33b315b354965980bd2c483d3aa141","src/component/components.rs":"07b8cae3a400e1955cc39d142569910b4fef2136021053d0ddbd6404d810aa52","src/component/exports.rs":"1af747401f153ccd5c5adfcab55dc4d75e241536cbbdc62624c3a07dd7620056","src/component/imports.rs":"a6cd7f914de7706a1a93a40fb8d0031b4b140786a347da636c70d093401079cd","src/component/instances.rs":"a76c5e7ba0ef73ae4bff5569d177198b7f3a9959dbe9f5c1b4bae7d1a9c839b1","src/component/modules.rs":"9e80907e72360fae4d8057b6b0e7a6b58edd7ba6aba6e63ba17346518e169617","src/component/names.rs":"ca2f46a6dbc872a9cdb297d58c958e16acaf8893318bfdba30e468841107d886","src/component/start.rs":"4055553d5c99c99abbc01bb8abb928ecb8b909d148b647a9977fbd444bb464a3","src/component/types.rs":"069f0ee5fc4001c26a0db4bab32c8db268af68a11bf50a55f07c9365f2317e5f","src/core.rs":"a00656f82a623656c59a2d7230b40a5849a5083e117bc57061746f6e3022c7bb","src/core/code.rs":"49d8b8414f62d2851e7dc1bb5965037a12d2ef2a02bec8f96349779b352e7d9e","src/core/custom.rs":"4b9f07b701dc7b6990d92fb43016c28fb971411670bb6a48553b92b1c35eb9a3","src/core/data.rs":"f209e23710ab75600dd200af176e23940c88fac8a6ca31c3df67b97a911f2c55","src/core/dump.rs":"8feaa532e3851186277ec1f4906e7fdc82c6399b211b8c928b16e293db1205b0","src/core/elements.rs":"2f6840d2eb689f74ba73ac303d3bc8826d1fa1d99cc8c86d02cf5c7d2becd2b2","src/core/exports.rs":"9e1eb3db0e0f73e00b66d82431257923feec8c052ac8b98717c8f36ffcc03537","src/core/functions.rs":"c18b9872ac0c21048a3ce32e5e44e8e702f97a57fa1b3a07bdd98c7f6c820f09","src/core/globals.rs":"15408072945d2d96d16c1020ec1a029a348fbe22da26eb35d02d695527f675ba","src/core/imports.rs":"af26ca7dd09cb2b8ecfbe347378252f4d12b92e23818e23d72512591ceee671c","src/core/linking.rs":"2f1053d9c2671e91a2b6e253dd38921bfc5f1b8a1a047b10c843033fe0f492de","src/core/memories.rs":"9e437e878e61933bc731ef20994aefedb0ac4ac6b9464e36b38a8cdc26019dd8","src/core/names.rs":"2624a58835b27b17260fdbd20704856dce04e1826eb2b3b6196f8f1ffcf560ef","src/core/producers.rs":"f4916c1cf61e26170cd10fe350de7dad18005461c362909b9557c16c507517bc","src/core/start.rs":"a01d4a91bcd93048977ccafc6af160357297450395bf598351f5a3e6d322e0de","src/core/tables.rs":"c133fef97ce13656455a42f2ba8909434c7c1b88b35bbe9b577c737cfb232241","src/core/tags.rs":"66251072d5108dfde8177039cef95deac21606a361cddb04f37c08b8a8969db4","src/core/types.rs":"1f3f5b2bc09ea6f4a569ddfb7e343bf3fb450d8508b3bf338915dad98aad9582","src/lib.rs":"e61325ab8de1b4c404f4ee7665eef404fca2d23322a9c8f94efec8426edc166b","src/raw.rs":"a6a72cfe8f88ea6476eccee4acf362030ba2d2e5710215bc4f13cde7de6d71ae"},"package":"d996306fb3aeaee0d9157adbe2f670df0236caf19f6728b221e92d0f27b3fe17"}

data/ext/cargo-vendor/wasm-encoder-0.207.0/Cargo.toml

@@ -1,45 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2021"
-name = "wasm-encoder"
-version = "0.207.0"
-authors = ["Nick Fitzgerald <fitzgen@gmail.com>"]
-description = """
-A low-level WebAssembly encoder.
-"""
-homepage = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wasm-encoder"
-documentation = "https://docs.rs/wasm-encoder"
-readme = "README.md"
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wasm-encoder"
-
-[dependencies.leb128]
-version = "0.2.4"
-
-[dependencies.wasmparser]
-version = "0.207.0"
-features = ["std"]
-optional = true
-default-features = false
-
-[dev-dependencies.anyhow]
-version = "1.0.58"
-
-[dev-dependencies.tempfile]
-version = "3.2.0"
-
-[lints.clippy]
-all = "allow"
-
-[lints.rust]
-unsafe_code = "deny"

data/ext/cargo-vendor/wasm-encoder-0.207.0/README.md

@@ -1,80 +0,0 @@
-<div align="center">
-  <h1><code>wasm-encoder</code></h1>
-
-<strong>A <a href="https://bytecodealliance.org/">Bytecode Alliance</a> project</strong>
-
-  <p>
-    <strong>A WebAssembly encoder for Rust.</strong>
-  </p>
-
-  <p>
-    <a href="https://crates.io/crates/wasm-encoder"><img src="https://img.shields.io/crates/v/wasm-encoder.svg?style=flat-square" alt="Crates.io version" /></a>
-    <a href="https://crates.io/crates/wasm-encoder"><img src="https://img.shields.io/crates/d/wasm-encoder.svg?style=flat-square" alt="Download" /></a>
-    <a href="https://docs.rs/wasm-encoder/"><img src="https://img.shields.io/static/v1?label=docs&message=wasm-encoder&color=blue&style=flat-square" alt="docs.rs docs" /></a>
-  </p>
-</div>
-
-## Usage
-
-Add `wasm-encoder` to your `Cargo.toml`
-
-```sh
-$ cargo add wasm-encoder
-```
-
-And then you can encode WebAssembly binaries via:
-
-```rust
-use wasm_encoder::{
-    CodeSection, ExportKind, ExportSection, Function, FunctionSection, Instruction,
-    Module, TypeSection, ValType,
-};
-
-let mut module = Module::new();
-
-// Encode the type section.
-let mut types = TypeSection::new();
-let params = vec![ValType::I32, ValType::I32];
-let results = vec![ValType::I32];
-types.function(params, results);
-module.section(&types);
-
-// Encode the function section.
-let mut functions = FunctionSection::new();
-let type_index = 0;
-functions.function(type_index);
-module.section(&functions);
-
-// Encode the export section.
-let mut exports = ExportSection::new();
-exports.export("f", ExportKind::Func, 0);
-module.section(&exports);
-
-// Encode the code section.
-let mut codes = CodeSection::new();
-let locals = vec![];
-let mut f = Function::new(locals);
-f.instruction(&Instruction::LocalGet(0));
-f.instruction(&Instruction::LocalGet(1));
-f.instruction(&Instruction::I32Add);
-f.instruction(&Instruction::End);
-codes.function(&f);
-module.section(&codes);
-
-// Extract the encoded Wasm bytes for this module.
-let wasm_bytes = module.finish();
-
-// We generated a valid Wasm module!
-assert!(wasmparser::validate(&wasm_bytes).is_ok());
-```
-
-# License
-
-This project is licensed under the Apache 2.0 license with the LLVM exception.
-See [LICENSE](LICENSE) for more details.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this project by you, as defined in the Apache-2.0 license,
-shall be licensed as above, without any additional terms or conditions.