wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/cookie.rs

@@ -1,19 +1,12 @@
 //! HTTP Cookies
 
-use std::{convert::TryInto, fmt, sync::Arc, time::SystemTime};
+use std::{collections::HashMap, convert::TryInto, fmt, sync::Arc, time::SystemTime};
 
 use bytes::Bytes;
-use cookie::{Cookie as RawCookie, CookieJar, Expiration, SameSite};
-use http::Uri;
-
-use crate::{
-    IntoUri,
-    error::Error,
-    ext::UriExt,
-    hash::{HASHER, HashMap},
-    header::HeaderValue,
-    sync::RwLock,
-};
+use cookie::{Cookie as RawCookie, CookieJar, Expiration, SameSite, time::Duration};
+use http::{Uri, Version};
+
+use crate::{IntoUri, error::Error, ext::UriExt, header::HeaderValue, sync::RwLock};
 
 /// Cookie header values in two forms.
 #[derive(Debug, Clone)]
@@ -34,23 +27,28 @@ pub trait CookieStore: Send + Sync {
     /// Store a set of Set-Cookie header values received from `uri`
     fn set_cookies(&self, cookie_headers: &mut dyn Iterator<Item = &HeaderValue>, uri: &Uri);
 
-    /// Get any [`Cookies`] in the store for `uri`
-    fn cookies(&self, uri: &Uri) -> Cookies;
+    /// Returns cookies for the given URI and HTTP version.
+    ///
+    /// Following [RFC 9112 §5.6.3], HTTP/1.1 combines all cookies into a single header.
+    /// For [HTTP/2] and above, cookies are sent as separate header fields
+    /// as per [RFC 9113 §8.1.2.5].
+    ///
+    /// [RFC 9112 §5.6.3]: https://www.rfc-editor.org/rfc/rfc9112#section-5.6.3
+    /// [RFC 9113 §8.1.2.5]: https://www.rfc-editor.org/rfc/rfc9113#section-8.1.2.5
+    /// [HTTP/2]: https://datatracker.ietf.org/doc/html/rfc9113
+    fn cookies(&self, uri: &Uri, version: Version) -> Cookies;
 }
 
-/// Trait for converting types into a shared cookie store ([`Arc<dyn CookieStore>`]).
-///
-/// Implemented for any [`CookieStore`] type, [`Arc<T>`] where `T: CookieStore`, and [`Arc<dyn
-/// CookieStore>`]. Enables ergonomic conversion to a trait object for use in APIs without manual
-/// boxing.
-pub trait IntoCookieStore {
-    /// Converts the implementor into an [`Arc<dyn CookieStore>`].
+impl_into_shared!(
+    /// Trait for converting types into a shared cookie store ([`Arc<dyn CookieStore>`]).
     ///
-    /// This method allows ergonomic conversion of concrete cookie stores, [`Arc<T>`], or
-    /// existing [`Arc<dyn CookieStore>`] into a trait object suitable for APIs that expect
-    /// a shared cookie store.
-    fn into_cookie_store(self) -> Arc<dyn CookieStore>;
-}
+    /// Implemented for any [`CookieStore`] type, [`Arc<T>`] where `T: CookieStore`, and [`Arc<dyn
+    /// CookieStore>`]. Enables ergonomic conversion to a trait object for use in APIs without manual
+    /// boxing.
+    pub trait IntoCookieStore => CookieStore
+);
+
+impl_request_config_value!(Arc<dyn CookieStore>);
 
 /// Trait for converting types into an owned cookie ([`Cookie<'static>`]).
 pub trait IntoCookie {
@@ -67,43 +65,8 @@ pub struct Cookie<'a>(RawCookie<'a>);
 /// This is the implementation used when simply calling `cookie_store(true)`.
 /// This type is exposed to allow creating one and filling it with some
 /// existing cookies more easily, before creating a [`crate::Client`].
-pub struct Jar {
-    compression: bool,
-    store: Arc<RwLock<HashMap<String, HashMap<String, CookieJar>>>>,
-}
-
-// ===== impl CookieStore =====
-
-impl_request_config_value!(Arc<dyn CookieStore>);
-
-// ===== impl IntoCookieStore =====
-
-impl IntoCookieStore for Arc<dyn CookieStore> {
-    #[inline]
-    fn into_cookie_store(self) -> Arc<dyn CookieStore> {
-        self
-    }
-}
-
-impl<R> IntoCookieStore for Arc<R>
-where
-    R: CookieStore + 'static,
-{
-    #[inline]
-    fn into_cookie_store(self) -> Arc<dyn CookieStore> {
-        self
-    }
-}
-
-impl<R> IntoCookieStore for R
-where
-    R: CookieStore + 'static,
-{
-    #[inline]
-    fn into_cookie_store(self) -> Arc<dyn CookieStore> {
-        Arc::new(self)
-    }
-}
+#[derive(Debug, Default)]
+pub struct Jar(RwLock<HashMap<String, HashMap<String, CookieJar>>>);
 
 // ===== impl IntoCookie =====
 
@@ -243,30 +206,6 @@ macro_rules! into_uri {
 }
 
 impl Jar {
-    /// Creates a new [`Jar`] with the specified compression setting.
-    pub fn new(compression: bool) -> Self {
-        Self {
-            compression,
-            store: Arc::new(RwLock::new(HashMap::with_hasher(HASHER))),
-        }
-    }
-
-    /// Clone this [`Jar`], sharing storage but enabling compression.
-    pub fn compressed(self: &Arc<Self>) -> Arc<Self> {
-        Arc::new(Jar {
-            compression: true,
-            store: self.store.clone(),
-        })
-    }
-
-    /// Clone this [`Jar`], sharing storage but disabling compression.
-    pub fn uncompressed(self: &Arc<Self>) -> Arc<Self> {
-        Arc::new(Jar {
-            compression: false,
-            store: self.store.clone(),
-        })
-    }
-
     /// Get a cookie by name for a given Uri.
     ///
     /// Returns the cookie with the specified name for the domain and path
@@ -276,16 +215,17 @@ impl Jar {
     /// ```
     /// use wreq::cookie::Jar;
     /// let jar = Jar::default();
-    /// jar.add_cookie_str("foo=bar; Path=/foo; Domain=example.com", "http://example.com/foo");
+    /// jar.add("foo=bar; Path=/foo; Domain=example.com", "http://example.com/foo");
     /// let cookie = jar.get("foo", "http://example.com/foo").unwrap();
     /// assert_eq!(cookie.value(), "bar");
     /// ```
     pub fn get<U: IntoUri>(&self, name: &str, uri: U) -> Option<Cookie<'static>> {
         let uri = uri.into_uri().ok()?;
+        let host = normalize_domain(uri.host()?);
         let cookie = self
-            .store
+            .0
             .read()
-            .get(uri.host()?)?
+            .get(host)?
             .get(uri.path())?
             .get(name)?
             .clone()
@@ -302,20 +242,30 @@ impl Jar {
     /// ```
     /// use wreq::cookie::Jar;
     /// let jar = Jar::default();
-    /// jar.add_cookie_str("foo=bar; Domain=example.com", "http://example.com");
+    /// jar.add("foo=bar; Domain=example.com", "http://example.com");
     /// for cookie in jar.get_all() {
     ///     println!("{}={}", cookie.name(), cookie.value());
     /// }
     /// ```
     pub fn get_all(&self) -> impl Iterator<Item = Cookie<'static>> {
-        self.store
+        self.0
             .read()
             .iter()
-            .flat_map(|(_, path_map)| {
-                path_map.iter().flat_map(|(_, name_map)| {
-                    name_map
-                        .iter()
-                        .map(|cookie| Cookie(cookie.clone().into_owned()))
+            .flat_map(|(domain, path_map)| {
+                path_map.iter().flat_map(|(path, name_map)| {
+                    name_map.iter().map(|cookie| {
+                        let mut cookie = cookie.clone().into_owned();
+
+                        if cookie.domain().is_none() {
+                            cookie.set_domain(domain.to_owned());
+                        }
+
+                        if cookie.path().is_none() {
+                            cookie.set_path(path.to_owned());
+                        }
+
+                        Cookie(cookie)
+                    })
                 })
             })
             .collect::<Vec<_>>()
@@ -348,19 +298,51 @@ impl Jar {
         U: IntoUri,
     {
         if let Some(cookie) = cookie.into_cookie() {
-            let cookie: RawCookie<'static> = cookie.into();
             let uri = into_uri!(uri);
-            let domain = cookie
-                .domain()
-                .map(normalize_domain)
-                .or_else(|| uri.host())
-                .unwrap_or_default();
-            let path = cookie.path().unwrap_or_else(|| normalize_path(&uri));
-
-            let mut inner = self.store.write();
+            let mut cookie: RawCookie<'static> = cookie.into();
+
+            // If the request-uri contains no host component:
+            let Some(host) = uri.host() else {
+                return;
+            };
+
+            // If the canonicalized request-host does not domain-match the
+            // domain-attribute:
+            //    Ignore the cookie entirely and abort these steps.
+            //
+            // RFC 6265 §5.3 + §5.1.3:
+            // https://datatracker.ietf.org/doc/html/rfc6265#section-5.3
+            // https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.3
+            let domain = if let Some(domain) = cookie.domain() {
+                let domain = normalize_domain(domain);
+                if domain.is_empty() || !domain_match(normalize_domain(host), domain) {
+                    return;
+                }
+                domain
+            } else {
+                normalize_domain(host)
+            };
+
+            // If the request-uri contains no path component or if the first character of the
+            // path component of the request-uri is not a %x2F ("/") OR if the cookie's path-
+            // attribute is missing or does not start with a %x2F ("/"):
+            //    Let cookie-path be the default-path of the request-uri.
+            // Otherwise:
+            //    Let cookie-path be the substring of the request-uri's path from the first
+            // character    up to, not including, the right-most %x2F ("/").
+            //
+            // RFC 6265 §5.2.4 + §5.1.4:
+            // https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.4
+            // https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4
+            let path = cookie
+                .path()
+                .filter(|path| path.starts_with(DEFAULT_PATH))
+                .unwrap_or_else(|| normalize_path(uri.path()));
+
+            let mut inner = self.0.write();
             let name_map = inner
                 .entry(domain.to_owned())
-                .or_insert_with(|| HashMap::with_hasher(HASHER))
+                .or_default()
                 .entry(path.to_owned())
                 .or_default();
 
@@ -368,11 +350,12 @@ impl Jar {
             let expired = cookie
                 .expires_datetime()
                 .is_some_and(|dt| dt <= SystemTime::now())
-                || cookie.max_age().is_some_and(|age| age.is_zero());
+                || cookie.max_age().is_some_and(Duration::is_zero);
 
             if expired {
                 name_map.remove(cookie);
             } else {
+                cookie.set_path(path.to_owned());
                 name_map.add(cookie);
             }
         }
@@ -387,7 +370,7 @@ impl Jar {
     /// ```
     /// use wreq::cookie::Jar;
     /// let jar = Jar::default();
-    /// jar.add_cookie_str("foo=bar; Path=/foo; Domain=example.com", "http://example.com/foo");
+    /// jar.add("foo=bar; Path=/foo; Domain=example.com", "http://example.com/foo");
     /// assert!(jar.get("foo", "http://example.com/foo").is_some());
     /// jar.remove("foo", "http://example.com/foo");
     /// assert!(jar.get("foo", "http://example.com/foo").is_none());
@@ -399,7 +382,8 @@ impl Jar {
     {
         let uri = into_uri!(uri);
         if let Some(host) = uri.host() {
-            let mut inner = self.store.write();
+            let host = normalize_domain(host);
+            let mut inner = self.0.write();
             if let Some(path_map) = inner.get_mut(host) {
                 if let Some(name_map) = path_map.get_mut(uri.path()) {
                     name_map.remove(cookie.into());
@@ -416,13 +400,13 @@ impl Jar {
     /// ```
     /// use wreq::cookie::Jar;
     /// let jar = Jar::default();
-    /// jar.add_cookie_str("foo=bar; Domain=example.com", "http://example.com");
+    /// jar.add("foo=bar; Domain=example.com", "http://example.com");
     /// assert_eq!(jar.get_all().count(), 1);
     /// jar.clear();
     /// assert_eq!(jar.get_all().count(), 0);
     /// ```
     pub fn clear(&self) {
-        self.store.write().clear();
+        self.0.write().clear();
     }
 }
 
@@ -438,13 +422,13 @@ impl CookieStore for Jar {
         }
     }
 
-    fn cookies(&self, uri: &Uri) -> Cookies {
+    fn cookies(&self, uri: &Uri, version: Version) -> Cookies {
         let host = match uri.host() {
-            Some(h) => h,
+            Some(h) => normalize_domain(h),
             None => return Cookies::Empty,
         };
 
-        let store = self.store.read();
+        let store = self.0.read();
         let iter = store
             .iter()
             .filter(|(domain, _)| domain_match(host, domain))
@@ -470,7 +454,24 @@ impl CookieStore for Jar {
                     })
             });
 
-        if self.compression {
+        if matches!(version, Version::HTTP_2 | Version::HTTP_3) {
+            let cookies = iter
+                .map(|cookie| {
+                    let name = cookie.name();
+                    let value = cookie.value();
+
+                    let mut cookie_str = String::with_capacity(name.len() + 1 + value.len());
+                    cookie_str.push_str(name);
+                    cookie_str.push('=');
+                    cookie_str.push_str(value);
+
+                    HeaderValue::from_maybe_shared(Bytes::from(cookie_str))
+                })
+                .filter_map(Result::ok)
+                .collect();
+
+            Cookies::Uncompressed(cookies)
+        } else {
             let cookies = iter.fold(String::new(), |mut cookies, cookie| {
                 if !cookies.is_empty() {
                     cookies.push_str("; ");
@@ -488,33 +489,10 @@ impl CookieStore for Jar {
             HeaderValue::from_maybe_shared(Bytes::from(cookies))
                 .map(Cookies::Compressed)
                 .unwrap_or(Cookies::Empty)
-        } else {
-            let cookies = iter
-                .map(|cookie| {
-                    let name = cookie.name();
-                    let value = cookie.value();
-
-                    let mut cookie_str = String::with_capacity(name.len() + 1 + value.len());
-                    cookie_str.push_str(name);
-                    cookie_str.push('=');
-                    cookie_str.push_str(value);
-
-                    HeaderValue::from_maybe_shared(Bytes::from(cookie_str))
-                })
-                .filter_map(Result::ok)
-                .collect();
-
-            Cookies::Uncompressed(cookies)
         }
     }
 }
 
-impl Default for Jar {
-    fn default() -> Self {
-        Self::new(true)
-    }
-}
-
 const DEFAULT_PATH: &str = "/";
 
 /// Determines if the given `host` matches the cookie `domain` according to
@@ -556,7 +534,11 @@ fn path_match(req_path: &str, cookie_path: &str) -> bool {
 /// the domain attribute of a cookie must not include a port. If a port is present (non-standard),
 /// it will be ignored for domain matching purposes.
 fn normalize_domain(domain: &str) -> &str {
-    domain.split(':').next().unwrap_or(domain)
+    let host_without_port = domain.split(':').next().unwrap_or(domain);
+    let without_leading = host_without_port
+        .strip_prefix(".")
+        .unwrap_or(host_without_port);
+    without_leading.strip_suffix(".").unwrap_or(without_leading)
 }
 
 /// Computes the normalized default path for a cookie as specified in
@@ -564,8 +546,7 @@ fn normalize_domain(domain: &str) -> &str {
 ///
 /// This function normalizes the path for a cookie, ensuring it matches
 /// browser and server expectations for default cookie scope.
-fn normalize_path(uri: &Uri) -> &str {
-    let path = uri.path();
+fn normalize_path(path: &str) -> &str {
     if !path.starts_with(DEFAULT_PATH) {
         return DEFAULT_PATH;
     }
@@ -577,3 +558,182 @@ fn normalize_path(uri: &Uri) -> &str {
     }
     DEFAULT_PATH
 }
+
+#[cfg(test)]
+mod tests {
+    use http::{Uri, Version};
+
+    use super::{CookieStore, Cookies, Jar};
+
+    #[test]
+    fn jar_get_all_backfills_domain_and_path() {
+        let jar = Jar::default();
+        jar.add("session=abc", "http://example.com/foo/bar");
+
+        let cookies = jar.get_all().collect::<Vec<_>>();
+        assert_eq!(cookies.len(), 1);
+
+        let cookie = &cookies[0];
+        assert_eq!(cookie.name(), "session");
+        assert_eq!(cookie.value(), "abc");
+        assert_eq!(cookie.domain(), Some("example.com"));
+        assert_eq!(cookie.path(), Some("/foo"));
+    }
+
+    #[test]
+    fn jar_get_all_keeps_existing_domain_and_path() {
+        let jar = Jar::default();
+        jar.add(
+            "session=abc; Domain=example.com; Path=/custom",
+            "http://example.com/foo/bar",
+        );
+
+        let cookies = jar.get_all().collect::<Vec<_>>();
+        assert_eq!(cookies.len(), 1);
+
+        let cookie = &cookies[0];
+        assert_eq!(cookie.name(), "session");
+        assert_eq!(cookie.value(), "abc");
+        assert_eq!(cookie.domain(), Some("example.com"));
+        assert_eq!(cookie.path(), Some("/custom"));
+    }
+
+    #[test]
+    fn jar_get_all_backfills_only_missing_field() {
+        let jar = Jar::default();
+        jar.add("a=1; Domain=example.com", "http://example.com/foo/bar");
+        jar.add("b=2; Path=/fixed", "http://example.com/foo/bar");
+
+        let mut cookies = jar.get_all().collect::<Vec<_>>();
+        cookies.sort_by(|left, right| left.name().cmp(right.name()));
+
+        let a = &cookies[0];
+        assert_eq!(a.name(), "a");
+        assert_eq!(a.domain(), Some("example.com"));
+        assert_eq!(a.path(), Some("/foo"));
+
+        let b = &cookies[1];
+        assert_eq!(b.name(), "b");
+        assert_eq!(b.domain(), Some("example.com"));
+        assert_eq!(b.path(), Some("/fixed"));
+    }
+
+    #[test]
+    fn jar_add_rejects_mismatched_domain() {
+        let jar = Jar::default();
+        jar.add("session=abc; Domain=other.com", "http://example.com/foo");
+
+        assert_eq!(jar.get_all().count(), 0);
+    }
+
+    #[test]
+    fn jar_add_accepts_matching_parent_domain() {
+        let jar = Jar::default();
+        jar.add(
+            "session=abc; Domain=example.com",
+            "http://api.example.com/foo",
+        );
+
+        let cookies = jar.get_all().collect::<Vec<_>>();
+        assert_eq!(cookies.len(), 1);
+        assert_eq!(cookies[0].domain(), Some("example.com"));
+    }
+
+    #[test]
+    fn jar_get_all_export_import_keeps_effective_path() {
+        let source = Jar::default();
+        source.add("session=abc", "http://example.com/foo/bar");
+
+        let exported = source.get_all().collect::<Vec<_>>();
+        assert_eq!(exported.len(), 1);
+        assert_eq!(exported[0].path(), Some("/foo"));
+
+        let target = Jar::default();
+        for cookie in exported {
+            target.add(cookie, "http://example.com/another/deeper");
+        }
+
+        let imported = target.get_all().collect::<Vec<_>>();
+        assert_eq!(imported.len(), 1);
+        assert_eq!(imported[0].path(), Some("/foo"));
+    }
+
+    #[test]
+    fn cookie_store_invalid_explicit_path_falls_back_to_default_path() {
+        let jar = Jar::default();
+        jar.add("key=val; Path=noslash", "http://example.com/foo/bar");
+
+        assert!(jar.get("key", "http://example.com/foo").is_some());
+        assert!(jar.get("key", "http://example.com/noslash").is_none());
+
+        let cookies = jar.get_all().collect::<Vec<_>>();
+        assert_eq!(cookies.len(), 1);
+        assert_eq!(cookies[0].path(), Some("/foo"));
+    }
+
+    #[test]
+    fn jar_sends_parent_domain_cookie_to_subdomain() {
+        let jar = Jar::default();
+        jar.add(
+            "session=abc; Domain=example.com; Path=/",
+            "http://example.com/login",
+        );
+
+        let should_receive = [
+            "http://example.com/dashboard",
+            "http://api.example.com/dashboard",
+            "http://sub.api.example.com/dashboard",
+        ];
+        for uri_str in &should_receive {
+            let uri = Uri::from_static(uri_str);
+            match jar.cookies(&uri, Version::HTTP_11) {
+                Cookies::Compressed(v) => assert_eq!(
+                    v.to_str().unwrap(),
+                    "session=abc",
+                    "expected cookie to be sent to {uri_str}"
+                ),
+                other => panic!("expected Compressed cookie for {uri_str}, got {other:?}"),
+            }
+        }
+
+        let should_not_receive = [
+            "http://notexample.com/dashboard",
+            "http://fakeexample.com/dashboard",
+        ];
+        for uri_str in &should_not_receive {
+            let uri = Uri::from_static(uri_str);
+            assert!(
+                matches!(jar.cookies(&uri, Version::HTTP_11), Cookies::Empty),
+                "cookie must NOT be sent to {uri_str}"
+            );
+        }
+    }
+
+    #[test]
+    fn jar_subdomain_cookie_does_not_leak_to_parent_or_sibling() {
+        let jar = Jar::default();
+        jar.add(
+            "token=xyz; Domain=api.example.com; Path=/",
+            "http://api.example.com/",
+        );
+
+        let uri = Uri::from_static("http://api.example.com/");
+        assert!(
+            matches!(jar.cookies(&uri, Version::HTTP_11), Cookies::Compressed(_)),
+            "cookie must be sent to api.example.com"
+        );
+
+        let must_not_receive = [
+            "http://example.com/",
+            "http://other.example.com/",
+            "http://notapi.example.com/",
+        ];
+        for uri_str in &must_not_receive {
+            let uri = Uri::from_static(uri_str);
+            assert!(
+                matches!(jar.cookies(&uri, Version::HTTP_11), Cookies::Empty),
+                "cookie must NOT leak to {uri_str}"
+            );
+        }
+    }
+}

data/vendor/wreq/src/dns/gai/compio.rs

@@ -0,0 +1,77 @@
+// This module contains the `GaiResolver` implementation for the `compio` runtime.
+
+use std::{
+    future::Future,
+    io,
+    net::ToSocketAddrs,
+    pin::Pin,
+    task::{self, Poll},
+};
+
+use tower::Service;
+
+use super::{GaiAddrs, GaiResolver};
+use crate::dns::{Addrs, Name, Resolve, Resolving, SocketAddrs};
+
+/// A future to resolve a name returned by `GaiResolver`.
+pub struct GaiFuture {
+    inner: compio::runtime::JoinHandle<Result<SocketAddrs, io::Error>>,
+}
+
+// ==== impl GaiResolver ====
+
+impl GaiResolver {
+    /// Creates a new [`GaiResolver`].
+    pub fn new() -> Self {
+        GaiResolver { _priv: () }
+    }
+}
+
+impl Service<Name> for GaiResolver {
+    type Response = GaiAddrs;
+    type Error = io::Error;
+    type Future = GaiFuture;
+
+    #[inline]
+    fn poll_ready(&mut self, _cx: &mut task::Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, name: Name) -> Self::Future {
+        let blocking = compio::runtime::spawn_blocking(move || {
+            debug!("resolving {}", name);
+            (name.as_str(), 0)
+                .to_socket_addrs()
+                .map(|i| SocketAddrs::new(i.collect()))
+        });
+        GaiFuture { inner: blocking }
+    }
+}
+
+impl Resolve for GaiResolver {
+    fn resolve(&self, name: Name) -> Resolving {
+        let mut this = self.clone();
+        Box::pin(async move {
+            this.call(name)
+                .await
+                .map(|addrs| Box::new(addrs) as Addrs)
+                .map_err(Into::into)
+        })
+    }
+}
+
+// ==== impl GaiFuture ====
+
+impl Future for GaiFuture {
+    type Output = Result<GaiAddrs, io::Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.inner).poll(cx).map(|res| match res {
+            Ok(Ok(addrs)) => Ok(GaiAddrs { inner: addrs }),
+            Ok(Err(err)) => Err(err),
+            Err(join_err) => Err(io::Error::other(format!(
+                "DNS resolution blocked task panicked: {join_err}"
+            ))),
+        })
+    }
+}