diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a7f1a9..bff2141 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.3.0 (unreleased)
+
+### Added
+
+ - `dataurl::mime::MimeType` (also exported as `dataurl::MimeType`): the WHATWG MIME type parser used for
+   data URLs, available on its own, e.g. for `Content-Type` headers
+ - `DataUrl::set_mime_type()`, which sets the media type and all of its parameters from a `MimeType`
+ - `DataEncoding::Shortest`, which picks percent-encoding or base64, whichever results in a shorter data URL
+ - `Escaping::Minimal`, which only escapes what has to be when percent-encoding, for data URLs that go inside
+   double-quoted HTML attributes or CSS strings; this keeps text formats like SVG short and readable
+
+### Changed
+
+ - `DataUrl::mime_type()` returns a `MimeType` instead of a `String` (use `.to_string()` for the old result)
+ - `is_base64_encoded()` and `set_is_base64_encoded()` are replaced by `data_encoding()` and `set_data_encoding()`,
+   which use the new `DataEncoding` enum (`Percent`, `Base64` or `Shortest`)
+ - Percent-encoding now also escapes `&`, so that HTML entities can't alter the data
+   when a data URL is put into an HTML attribute by hand
+
 ## 0.2.1
 
 ### Added
diff --git a/README.md b/README.md
index 4087f04..13f8270 100644
--- a/README.md
+++ b/README.md
@@ -53,20 +53,20 @@ cat file.png | dataurl -b
 
 ```toml
 [dependencies]
-dataurl = { version = "0.2", default-features = false }
+dataurl = { version = "0.3", default-features = false }
 ```
 
 ```rust
-use dataurl::DataUrl;
+use dataurl::{DataEncoding, DataUrl};
 
 let data_url: DataUrl = "data:,Hello,%20World!".parse()?;
 
 assert_eq!(data_url.media_type(), "text/plain");
 assert_eq!(data_url.media_type_no_default(), None);
-assert_eq!(data_url.mime_type(), "text/plain;charset=US-ASCII");
+assert_eq!(data_url.mime_type().to_string(), "text/plain;charset=US-ASCII");
 assert_eq!(data_url.charset(), "US-ASCII");
 assert_eq!(data_url.charset_no_default(), None);
-assert!(!data_url.is_base64_encoded());
+assert_eq!(data_url.data_encoding(), DataEncoding::Percent);
 assert_eq!(data_url.data(), b"Hello, World!");
 assert_eq!(data_url.fragment(), None);
 assert_eq!(data_url.text(), "Hello, World!");
@@ -74,7 +74,7 @@ assert_eq!(data_url.to_string(), "data:,Hello,%20World!");
 
 let mut data_url = DataUrl::new();
 data_url.set_media_type(Some("image/png"))?;
-data_url.set_is_base64_encoded(true);
+data_url.set_data_encoding(DataEncoding::Base64);
 data_url.set_data(&[0x89, 0x50, 0x4E, 0x47]);
 assert_eq!(data_url.to_string(), "data:image/png;base64,iVBORw==");
 ```
@@ -82,6 +82,46 @@ assert_eq!(data_url.to_string(), "data:image/png;base64,iVBORw==");
 Data is stored as raw bytes and serialized as-is; use `set_text()` to store text encoded in the data URL's charset, and `text()` to decode it.
 Disabling default features skips the `cli` feature, which only matters for `cargo install`.
 
+### Choosing how data gets encoded
+
+`set_data_encoding()` picks percent-encoding (the default), base64, or `DataEncoding::Shortest`, whichever comes out shorter for the data.
+`set_escaping()` controls how much percent-encoding escapes: `Escaping::Full` (the default) makes the data URL safe anywhere,
+while `Escaping::Minimal` only escapes what has to be, which keeps text formats like SVG short and readable,
+for data URLs that go inside double-quoted HTML attributes or CSS strings:
+
+```rust
+use dataurl::{DataEncoding, DataUrl, Escaping};
+
+let mut data_url = DataUrl::new();
+data_url.set_media_type(Some("image/svg+xml"))?;
+data_url.set_data_encoding(DataEncoding::Shortest);
+data_url.set_escaping(Escaping::Minimal);
+data_url.set_data(b"<svg xmlns='http://www.w3.org/2000/svg'><circle r='4'/></svg>");
+
+assert_eq!(
+    data_url.to_string(),
+    "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg'%3E%3Ccircle r='4'/%3E%3C/svg%3E"
+);
+```
+
+### MIME types
+
+The WHATWG MIME type parser used for data URLs is available on its own, e.g. for `Content-Type` headers:
+
+```rust
+use dataurl::{DataUrl, MimeType};
+
+let mime_type: MimeType = "Text/CSS; charset=\"UTF-8\"".parse()?;
+assert_eq!(mime_type.essence(), "text/css");
+assert_eq!(mime_type.charset(), Some("UTF-8"));
+
+let mut data_url = DataUrl::new();
+data_url.set_mime_type(Some(&mime_type))?;
+assert_eq!(data_url.to_string(), "data:text/css;charset=UTF-8,");
+```
+
+### Media type detection
+
 Media types can be detected from the data's signature, falling back to the file extension
 (which is what text formats like CSS and JavaScript need):
 
@@ -93,7 +133,7 @@ assert_eq!(detect_media_type(b"body{}", Some("style.css")), Some("text/css"));
 ```
 
 If all you need is parsing, [data-url](https://crates.io/crates/data-url) (from the Servo project) is another spec-compliant option;
-dataurl also generates data URLs, and comes with a CLI tool.
+dataurl also generates data URLs (picking the shortest encoding if asked to), handles charsets, detects media types, and comes with a CLI tool.
 
 
 ---------------------------------------------------
diff --git a/src/lib.rs b/src/lib.rs
index 8890a5b..d41bb89 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,20 +6,31 @@
 //! forgiving base64, and MIME type parsing.
 //!
 //! ```
-//! use dataurl::DataUrl;
+//! use dataurl::{DataEncoding, DataUrl, Escaping};
 //!
 //! let data_url: DataUrl = "data:,Hello,%20World!".parse()?;
 //! assert_eq!(data_url.media_type(), "text/plain");
-//! assert_eq!(data_url.mime_type(), "text/plain;charset=US-ASCII");
+//! assert_eq!(data_url.mime_type().to_string(), "text/plain;charset=US-ASCII");
 //! assert_eq!(data_url.charset(), "US-ASCII");
 //! assert_eq!(data_url.data(), b"Hello, World!");
 //! assert_eq!(data_url.text(), "Hello, World!");
 //!
 //! let mut data_url = DataUrl::new();
 //! data_url.set_media_type(Some("image/png"))?;
-//! data_url.set_is_base64_encoded(true);
+//! data_url.set_data_encoding(DataEncoding::Base64);
 //! data_url.set_data(&[0x89, 0x50, 0x4E, 0x47]);
 //! assert_eq!(data_url.to_string(), "data:image/png;base64,iVBORw==");
+//!
+//! // For text, percent-encoding with minimal escaping is often much shorter than base64
+//! let mut data_url = DataUrl::new();
+//! data_url.set_media_type(Some("image/svg+xml"))?;
+//! data_url.set_data_encoding(DataEncoding::Shortest);
+//! data_url.set_escaping(Escaping::Minimal);
+//! data_url.set_data(b"<svg xmlns='http://www.w3.org/2000/svg'><circle r='4'/></svg>");
+//! assert_eq!(
+//!     data_url.to_string(),
+//!     "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg'%3E%3Ccircle r='4'/%3E%3C/svg%3E"
+//! );
 //! # Ok::<(), dataurl::Error>(())
 //! ```
 //!
@@ -27,10 +38,11 @@
 
 mod base64;
 mod detect;
-mod mime;
+pub mod mime;
 mod percent;
 
 pub use detect::detect_media_type;
+pub use mime::MimeType;
 
 use encoding_rs::{Encoding, REPLACEMENT, UTF_16BE, UTF_16LE, WINDOWS_1252};
 use std::borrow::Cow;
@@ -92,6 +104,39 @@ impl fmt::Display for Error {
 
 impl std::error::Error for Error {}
 
+/// How the data part of a data URL gets encoded when serializing.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+#[non_exhaustive]
+pub enum DataEncoding {
+    /// Percent-encoding (`data:,Hello%2C%20World`), which keeps text readable.
+    #[default]
+    Percent,
+    /// Base64 (`data:;base64,SGVsbG8sIFdvcmxk`), which is more compact for binary data.
+    Base64,
+    /// Whichever of the two results in a shorter data URL, given the [`Escaping`] in use.
+    /// Parsing never yields this value, since a parsed data URL is either one or the other.
+    Shortest,
+}
+
+/// How much of the data gets escaped when it's percent-encoded.
+///
+/// Some characters always get escaped, whichever option is used: those that can't appear in
+/// a data URL (controls, non-ASCII, `%`, `#`), those that would end or alter a double-quoted
+/// HTML attribute, a CSS string, or a `<style>` or `<script>` element containing the data URL
+/// (`"`, `&`, `<`, `>`, `\`), and spaces at the very end (which URL parsers strip).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+#[non_exhaustive]
+pub enum Escaping {
+    /// Also escapes spaces and `'`, `(`, `)` and `` ` ``, so the data URL is safe to put anywhere:
+    /// unquoted HTML attributes, unquoted CSS `url()`, `srcset`, or plain text.
+    #[default]
+    Full,
+    /// Only escapes what has to be, which keeps text formats like SVG short and readable,
+    /// but the result must only be used inside double quotes (an HTML attribute or a CSS string),
+    /// and not in `srcset`, which splits on spaces.
+    Minimal,
+}
+
 /// A parsed (or under construction) data URL.
 ///
 /// The data is always kept as raw bytes, exactly as it was decoded or set.
@@ -101,7 +146,8 @@ impl std::error::Error for Error {}
 pub struct DataUrl {
     media_type: Option<String>, // Lowercased type/subtype; None if omitted ("text/plain" implied)
     parameters: Vec<(String, String)>, // Media type parameters (charset, etc), names lowercased
-    is_base64_encoded: bool,
+    data_encoding: DataEncoding,
+    escaping: Escaping,
     data: Vec<u8>,
     fragment: Option<String>,
 }
@@ -112,7 +158,8 @@ impl fmt::Debug for DataUrl {
         f.debug_struct("DataUrl")
             .field("media_type", &self.media_type)
             .field("parameters", &self.parameters)
-            .field("is_base64_encoded", &self.is_base64_encoded)
+            .field("data_encoding", &self.data_encoding)
+            .field("escaping", &self.escaping)
             .field("data", &format_args!("[{} bytes]", self.data.len()))
             .field("fragment", &self.fragment)
             .finish()
@@ -167,13 +214,13 @@ impl DataUrl {
 
         let mut data: Vec<u8> = percent::decode(encoded_data.as_bytes());
 
-        let is_base64_encoded = match strip_base64_marker(mime_type) {
+        let data_encoding = match strip_base64_marker(mime_type) {
             Some(stripped) => {
                 data = base64::decode_forgiving(&data).ok_or(Error::InvalidBase64)?;
                 mime_type = stripped;
-                true
+                DataEncoding::Base64
             }
-            None => false,
+            None => DataEncoding::Percent,
         };
 
         let (media_type, parameters) = if mime_type.starts_with(';') {
@@ -194,7 +241,8 @@ impl DataUrl {
         Ok(DataUrl {
             media_type,
             parameters,
-            is_base64_encoded,
+            data_encoding,
+            escaping: Escaping::default(),
             data,
             fragment,
         })
@@ -222,15 +270,46 @@ impl DataUrl {
     }
 
     /// The full MIME type including parameters, the way browsers report it,
-    /// e.g. `"text/plain;charset=US-ASCII"` for `data:,`.
-    pub fn mime_type(&self) -> String {
+    /// e.g. `text/plain;charset=US-ASCII` for `data:,`.
+    pub fn mime_type(&self) -> MimeType {
         if self.media_type.is_none() && self.parameters.is_empty() {
-            return format!("{DEFAULT_MEDIA_TYPE};charset={DEFAULT_CHARSET}");
+            return MimeType {
+                essence: DEFAULT_MEDIA_TYPE.to_string(),
+                parameters: vec![("charset".to_string(), DEFAULT_CHARSET.to_string())],
+            };
         }
 
-        let mut mime_type = self.media_type().to_string();
-        mime::serialize_parameters(&mut mime_type, &self.parameters);
-        mime_type
+        MimeType {
+            essence: self.media_type().to_string(),
+            parameters: self.parameters.clone(),
+        }
+    }
+
+    /// Sets the media type and all of its parameters at once, e.g. from a `Content-Type` header,
+    /// or removes both with `None`.
+    ///
+    /// Fails if a parameter value can't be represented in a data URL
+    /// (see [`set_parameter`](DataUrl::set_parameter)), in which case nothing changes.
+    pub fn set_mime_type(&mut self, mime_type: Option<&MimeType>) -> Result<(), Error> {
+        match mime_type {
+            Some(mime_type) => {
+                if !mime_type
+                    .parameters
+                    .iter()
+                    .all(|(_, value)| is_representable_parameter_value(value))
+                {
+                    return Err(Error::InvalidParameter);
+                }
+                self.media_type = Some(mime_type.essence.clone());
+                self.parameters = mime_type.parameters.clone();
+            }
+            None => {
+                self.media_type = None;
+                self.parameters.clear();
+            }
+        }
+
+        Ok(())
     }
 
     /// Sets the media type essence (e.g. `"image/png"`), or removes it with `None`.
@@ -281,10 +360,7 @@ impl DataUrl {
 
         match value {
             Some(value) => {
-                if !value
-                    .bytes()
-                    .all(|b| matches!(b, b' '..=b'~') && b != b',' && b != b'#')
-                {
+                if !is_representable_parameter_value(value) {
                     return Err(Error::InvalidParameter);
                 }
                 match self.parameters.iter_mut().find(|(n, _)| *n == name) {
@@ -332,14 +408,25 @@ impl DataUrl {
             .unwrap_or(WINDOWS_1252)
     }
 
-    /// Whether the data gets serialized as base64 (and whether it was, when parsed).
-    pub fn is_base64_encoded(&self) -> bool {
-        self.is_base64_encoded
+    /// How the data gets encoded when serializing; for a parsed data URL,
+    /// how it was encoded ([`Percent`](DataEncoding::Percent) or [`Base64`](DataEncoding::Base64)).
+    pub fn data_encoding(&self) -> DataEncoding {
+        self.data_encoding
+    }
+
+    /// Sets how the data gets encoded when serializing.
+    pub fn set_data_encoding(&mut self, data_encoding: DataEncoding) {
+        self.data_encoding = data_encoding;
     }
 
-    /// Sets whether the data gets serialized as base64 or percent-encoded.
-    pub fn set_is_base64_encoded(&mut self, is_base64_encoded: bool) {
-        self.is_base64_encoded = is_base64_encoded;
+    /// How much of the data gets escaped when it's percent-encoded.
+    pub fn escaping(&self) -> Escaping {
+        self.escaping
+    }
+
+    /// Sets how much of the data gets escaped when it's percent-encoded.
+    pub fn set_escaping(&mut self, escaping: Escaping) {
+        self.escaping = escaping;
     }
 
     /// The raw data.
@@ -407,12 +494,26 @@ impl fmt::Display for DataUrl {
         }
         mime::serialize_parameters(&mut output, &self.parameters);
 
-        if self.is_base64_encoded {
+        let should_encode: fn(u8) -> bool = match self.escaping {
+            Escaping::Full => percent::in_data_set,
+            Escaping::Minimal => percent::in_minimal_data_set,
+        };
+        let use_base64 = match self.data_encoding {
+            DataEncoding::Percent => false,
+            DataEncoding::Base64 => true,
+            DataEncoding::Shortest => {
+                // ";base64" plus 4 characters for every 3 bytes, versus 1 or 3 characters per byte
+                let base64_length = 7 + self.data.len().div_ceil(3) * 4;
+                base64_length < percent::encoded_length(&self.data, should_encode)
+            }
+        };
+
+        if use_base64 {
             output.push_str(";base64,");
             base64::encode_into(&mut output, &self.data);
         } else {
             output.push(',');
-            percent::encode_into(&mut output, &self.data, percent::in_data_set);
+            percent::encode_data_into(&mut output, &self.data, should_encode);
         }
 
         if let Some(fragment) = &self.fragment {
@@ -440,6 +541,14 @@ impl TryFrom<&str> for DataUrl {
     }
 }
 
+/// Whether a parameter value can be put in the metadata part of a data URL as is:
+/// printable ASCII, except for "," (which ends the metadata) and "#" (which starts the fragment).
+fn is_representable_parameter_value(value: &str) -> bool {
+    value
+        .bytes()
+        .all(|b| matches!(b, b' '..=b'~') && b != b',' && b != b'#')
+}
+
 /// If the metadata ends with ";base64" (optionally with spaces after the semicolon),
 /// returns the metadata without it.
 fn strip_base64_marker(mime_type: &str) -> Option<&str> {
diff --git a/src/main.rs b/src/main.rs
index 9c5d50f..f024d4f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,4 @@
-use dataurl::{detect_media_type, DataUrl};
+use dataurl::{detect_media_type, DataEncoding, DataUrl};
 use std::ffi::OsString;
 use std::fs;
 use std::io::{self, IsTerminal, Read, Write};
@@ -201,7 +201,9 @@ fn main() {
     } else {
         let mut data_url = DataUrl::new();
 
-        data_url.set_is_base64_encoded(options.base64);
+        if options.base64 {
+            data_url.set_data_encoding(DataEncoding::Base64);
+        }
 
         if let Some(media_type) = &options.media_type {
             data_url
diff --git a/src/mime.rs b/src/mime.rs
index 0e68249..cb23bd7 100644
--- a/src/mime.rs
+++ b/src/mime.rs
@@ -1,11 +1,107 @@
 //! MIME type parsing and serialization, as defined by the WHATWG MIME Sniffing
 //! Standard (<https://mimesniff.spec.whatwg.org/#parsing-a-mime-type>).
+//!
+//! This is the parser used for data URLs, but it works for any MIME type,
+//! such as the value of a `Content-Type` header:
+//!
+//! ```
+//! use dataurl::mime::MimeType;
+//!
+//! let mime_type: MimeType = "Text/HTML; charset=\"Shift_JIS\"; foo=bar".parse()?;
+//! assert_eq!(mime_type.essence(), "text/html");
+//! assert_eq!(mime_type.main_type(), "text");
+//! assert_eq!(mime_type.subtype(), "html");
+//! assert_eq!(mime_type.charset(), Some("Shift_JIS"));
+//! assert_eq!(mime_type.to_string(), "text/html;charset=Shift_JIS;foo=bar");
+//! # Ok::<(), dataurl::Error>(())
+//! ```
+
+use std::fmt;
+use std::str::FromStr;
+
+use crate::Error;
 
 pub(crate) type Parameters = Vec<(String, String)>;
 
-pub(crate) struct MimeType {
-    pub essence: String, // Lowercased "type/subtype"
-    pub parameters: Parameters,
+/// A parsed MIME type: its essence (`type/subtype`, lowercase) and its parameters.
+///
+/// Parameter names are lowercase, and only the first occurrence of each is kept,
+/// the way browsers do it. Parameters that aren't valid are dropped rather than
+/// making the whole MIME type invalid.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct MimeType {
+    pub(crate) essence: String,
+    pub(crate) parameters: Parameters,
+}
+
+impl MimeType {
+    /// Parses a MIME type, failing if its `type/subtype` part isn't valid.
+    pub fn parse(input: &str) -> Result<MimeType, Error> {
+        parse(input).ok_or(Error::InvalidMediaType)
+    }
+
+    /// The `type/subtype` part, lowercase (e.g. `"image/svg+xml"`).
+    pub fn essence(&self) -> &str {
+        &self.essence
+    }
+
+    /// The part before the slash (e.g. `"image"`).
+    pub fn main_type(&self) -> &str {
+        self.essence
+            .split_once('/')
+            .map_or("", |(main_type, _)| main_type)
+    }
+
+    /// The part after the slash (e.g. `"svg+xml"`).
+    pub fn subtype(&self) -> &str {
+        self.essence
+            .split_once('/')
+            .map_or("", |(_, subtype)| subtype)
+    }
+
+    /// Iterates over parameters as `(name, value)` pairs, in order.
+    pub fn parameters(&self) -> impl Iterator<Item = (&str, &str)> {
+        self.parameters
+            .iter()
+            .map(|(n, v)| (n.as_str(), v.as_str()))
+    }
+
+    /// Returns the value of a parameter (names are case-insensitive).
+    pub fn parameter(&self, name: &str) -> Option<&str> {
+        self.parameters
+            .iter()
+            .find(|(n, _)| n.eq_ignore_ascii_case(name))
+            .map(|(_, v)| v.as_str())
+    }
+
+    /// The charset parameter, if present.
+    pub fn charset(&self) -> Option<&str> {
+        self.parameter("charset")
+    }
+}
+
+impl fmt::Display for MimeType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut output = self.essence.clone();
+        serialize_parameters(&mut output, &self.parameters);
+        f.write_str(&output)
+    }
+}
+
+impl FromStr for MimeType {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<MimeType, Error> {
+        MimeType::parse(input)
+    }
+}
+
+impl TryFrom<&str> for MimeType {
+    type Error = Error;
+
+    fn try_from(input: &str) -> Result<MimeType, Error> {
+        MimeType::parse(input)
+    }
 }
 
 pub(crate) fn is_http_whitespace(c: char) -> bool {
diff --git a/src/percent.rs b/src/percent.rs
index 7a2f8cb..94b58be 100644
--- a/src/percent.rs
+++ b/src/percent.rs
@@ -2,15 +2,59 @@
 
 const HEX: &[u8; 16] = b"0123456789ABCDEF";
 
-/// Bytes that get percent-encoded in the data portion of a data URL.
-/// Besides what URLs require (controls, space, non-ASCII, "%", "#"), this also covers
-/// characters that would break out of HTML attributes or unquoted CSS url() values.
+/// Bytes that always get percent-encoded in the data portion of a data URL: what URLs require
+/// (controls, non-ASCII, "%", "#"), and what would end or alter a double-quoted HTML attribute,
+/// CSS string, or a STYLE or SCRIPT element the data URL is in ("\"", "&", "<", ">", "\\").
+pub(crate) fn in_minimal_data_set(byte: u8) -> bool {
+    !matches!(byte, 0x20..=0x7E) || matches!(byte, b'"' | b'#' | b'%' | b'&' | b'<' | b'>' | b'\\')
+}
+
+/// Bytes that get percent-encoded in the data portion of a data URL by default: on top of the
+/// minimal set, characters that would break unquoted HTML attributes, unquoted CSS url() values,
+/// or srcset (space, "'", "(", ")", "`").
 pub(crate) fn in_data_set(byte: u8) -> bool {
-    !matches!(byte, 0x21..=0x7E)
-        || matches!(
-            byte,
-            b'"' | b'#' | b'%' | b'\'' | b'(' | b')' | b'<' | b'>' | b'\\' | b'`'
-        )
+    in_minimal_data_set(byte) || matches!(byte, b' ' | b'\'' | b'(' | b')' | b'`')
+}
+
+/// Where the trailing spaces of the data start; URL parsers strip them, so they always get encoded
+fn trailing_spaces_start(data: &[u8]) -> usize {
+    data.len() - data.iter().rev().take_while(|&&b| b == b' ').count()
+}
+
+/// Percent-encodes the data portion of a data URL.
+pub(crate) fn encode_data_into(output: &mut String, data: &[u8], should_encode: fn(u8) -> bool) {
+    let trailing_spaces_start = trailing_spaces_start(data);
+    output.reserve(data.len());
+
+    for (i, &byte) in data.iter().enumerate() {
+        if should_encode(byte) || i >= trailing_spaces_start {
+            push_encoded(output, byte);
+        } else {
+            output.push(byte as char);
+        }
+    }
+}
+
+/// How long the data portion would be once percent-encoded, without encoding it.
+pub(crate) fn encoded_length(data: &[u8], should_encode: fn(u8) -> bool) -> usize {
+    let trailing_spaces_start = trailing_spaces_start(data);
+
+    data.iter()
+        .enumerate()
+        .map(|(i, &byte)| {
+            if should_encode(byte) || i >= trailing_spaces_start {
+                3
+            } else {
+                1
+            }
+        })
+        .sum()
+}
+
+fn push_encoded(output: &mut String, byte: u8) {
+    output.push('%');
+    output.push(HEX[(byte >> 4) as usize] as char);
+    output.push(HEX[(byte & 0x0F) as usize] as char);
 }
 
 /// Bytes that get percent-encoded in a fragment ("%" is kept as is, to preserve existing escapes).
@@ -29,9 +73,7 @@ pub(crate) fn encode_into(output: &mut String, input: &[u8], should_encode: fn(u
 
     for &byte in input {
         if should_encode(byte) {
-            output.push('%');
-            output.push(HEX[(byte >> 4) as usize] as char);
-            output.push(HEX[(byte & 0x0F) as usize] as char);
+            push_encoded(output, byte);
         } else {
             output.push(byte as char);
         }
@@ -66,6 +108,14 @@ pub(crate) fn decode(input: &[u8]) -> Vec<u8> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn trailing_spaces_always_get_encoded() {
+        let mut s = String::new();
+        encode_data_into(&mut s, b"a b  ", in_minimal_data_set);
+        assert_eq!(s, "a b%20%20");
+        assert_eq!(encoded_length(b"a b  ", in_minimal_data_set), s.len());
+    }
+
     #[test]
     fn decodes_valid_and_keeps_malformed_sequences() {
         assert_eq!(decode(b"%41%4a%zz%4%"), b"AJ%zz%4%");
@@ -75,9 +125,12 @@ mod tests {
     #[test]
     fn encoding_round_trips() {
         let data: Vec<u8> = (0..=255).collect();
-        let mut s = String::new();
-        encode_into(&mut s, &data, in_data_set);
-        assert!(s.is_ascii());
-        assert_eq!(decode(s.as_bytes()), data);
+        for set in [in_data_set, in_minimal_data_set] {
+            let mut s = String::new();
+            encode_data_into(&mut s, &data, set);
+            assert!(s.is_ascii());
+            assert_eq!(s.len(), encoded_length(&data, set));
+            assert_eq!(decode(s.as_bytes()), data);
+        }
     }
 }
diff --git a/tests/encoding.rs b/tests/encoding.rs
new file mode 100644
index 0000000..12c745d
--- /dev/null
+++ b/tests/encoding.rs
@@ -0,0 +1,151 @@
+use dataurl::{DataEncoding, DataUrl, Error, Escaping};
+
+const LIZARD_PNG: &[u8] = include_bytes!("_data_/lizard.png");
+
+const SVG: &[u8] = br##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill="#09f" d="M8 0a8 8 0 1 0 0 16A8 8 0 0 0 8 0z"/><text x="2" y="12">A &amp; B's</text></svg>"##;
+
+fn serialize(data: &[u8], data_encoding: DataEncoding, escaping: Escaping) -> String {
+    let mut data_url = DataUrl::new();
+    data_url.set_data_encoding(data_encoding);
+    data_url.set_escaping(escaping);
+    data_url.set_data(data);
+    data_url.to_string()
+}
+
+#[test]
+fn defaults() {
+    let data_url = DataUrl::new();
+    assert_eq!(data_url.data_encoding(), DataEncoding::Percent);
+    assert_eq!(data_url.escaping(), Escaping::Full);
+}
+
+#[test]
+fn parsed_encoding() -> Result<(), Error> {
+    assert_eq!(
+        DataUrl::parse("data:,x")?.data_encoding(),
+        DataEncoding::Percent
+    );
+    assert_eq!(
+        DataUrl::parse("data:;base64,eA==")?.data_encoding(),
+        DataEncoding::Base64
+    );
+    Ok(())
+}
+
+#[test]
+fn full_escaping() {
+    assert_eq!(
+        serialize(b"a b'(c)`\"<&>\\#%", DataEncoding::Percent, Escaping::Full),
+        "data:,a%20b%27%28c%29%60%22%3C%26%3E%5C%23%25"
+    );
+}
+
+#[test]
+fn minimal_escaping() {
+    assert_eq!(
+        serialize(
+            b"a b'(c)`\"<&>\\#%",
+            DataEncoding::Percent,
+            Escaping::Minimal
+        ),
+        "data:,a b'(c)`%22%3C%26%3E%5C%23%25"
+    );
+    // Controls, non-ASCII and trailing spaces always get escaped
+    assert_eq!(
+        serialize(
+            "\tcafé \n  ".as_bytes(),
+            DataEncoding::Percent,
+            Escaping::Minimal
+        ),
+        "data:,%09caf%C3%A9 %0A%20%20"
+    );
+}
+
+#[test]
+fn minimal_escaping_is_safe_in_double_quotes_and_style_elements() {
+    let serialized = serialize(SVG, DataEncoding::Percent, Escaping::Minimal);
+    for forbidden in ['"', '\\', '<', '>', '&', '#', '\n'] {
+        assert!(
+            !serialized.contains(forbidden),
+            "{forbidden:?} in {serialized}"
+        );
+    }
+    assert!(serialized.is_ascii());
+}
+
+#[test]
+fn shortest_picks_percent_for_text_and_base64_for_binary() {
+    let text = serialize(SVG, DataEncoding::Shortest, Escaping::Minimal);
+    assert!(text.starts_with("data:,%3Csvg xmlns="), "{text}");
+
+    let binary = serialize(LIZARD_PNG, DataEncoding::Shortest, Escaping::Minimal);
+    assert!(binary.starts_with("data:;base64,iVBOR"));
+
+    // Whichever is picked, it's never longer than either option
+    for data in [SVG, LIZARD_PNG, b"", b" ", b"\x00\x01\x02"] {
+        for escaping in [Escaping::Full, Escaping::Minimal] {
+            let shortest = serialize(data, DataEncoding::Shortest, escaping).len();
+            assert!(shortest <= serialize(data, DataEncoding::Percent, escaping).len());
+            assert!(shortest <= serialize(data, DataEncoding::Base64, escaping).len());
+        }
+    }
+}
+
+#[test]
+fn shortest_prefers_percent_on_ties() {
+    // "abc" is 3 characters percent-encoded, and ";base64" + "YWJj" is 11
+    assert_eq!(
+        serialize(b"abc", DataEncoding::Shortest, Escaping::Full),
+        "data:,abc"
+    );
+    assert_eq!(
+        serialize(b"", DataEncoding::Shortest, Escaping::Full),
+        "data:,"
+    );
+}
+
+#[test]
+fn minimal_escaping_makes_svg_much_shorter() {
+    let full = serialize(SVG, DataEncoding::Percent, Escaping::Full).len();
+    let minimal = serialize(SVG, DataEncoding::Percent, Escaping::Minimal).len();
+    let base64 = serialize(SVG, DataEncoding::Base64, Escaping::Full).len();
+    assert!(
+        minimal < base64 && base64 < full,
+        "minimal {minimal}, base64 {base64}, full {full}"
+    );
+}
+
+#[test]
+fn every_combination_round_trips() -> Result<(), Error> {
+    let all_bytes: Vec<u8> = (0..=255).collect();
+    for data in [SVG, LIZARD_PNG, &all_bytes, b"  leading and trailing  "] {
+        for data_encoding in [
+            DataEncoding::Percent,
+            DataEncoding::Base64,
+            DataEncoding::Shortest,
+        ] {
+            for escaping in [Escaping::Full, Escaping::Minimal] {
+                let mut data_url = DataUrl::new();
+                data_url.set_media_type(Some("image/svg+xml"))?;
+                data_url.set_data_encoding(data_encoding);
+                data_url.set_escaping(escaping);
+                data_url.set_fragment(Some("frag ment"));
+                data_url.set_data(data);
+
+                let parsed = DataUrl::parse(&data_url.to_string())?;
+                assert_eq!(parsed.data(), data, "{data_encoding:?} {escaping:?}");
+                assert_eq!(parsed.media_type(), "image/svg+xml");
+                assert_eq!(parsed.fragment(), Some("frag%20ment"));
+            }
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn escaping_does_not_affect_base64() {
+    assert_eq!(
+        serialize(&[0xFB, 0xFF], DataEncoding::Base64, Escaping::Minimal),
+        serialize(&[0xFB, 0xFF], DataEncoding::Base64, Escaping::Full)
+    );
+}
diff --git a/tests/lib.rs b/tests/lib.rs
index 3c3183b..e523a75 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -1,4 +1,4 @@
-use dataurl::{DataUrl, Error};
+use dataurl::{DataEncoding, DataUrl, Error, Escaping};
 
 const LIZARD_PNG: &[u8] = include_bytes!("_data_/lizard.png");
 
@@ -10,10 +10,13 @@ mod parse {
         let data_url = DataUrl::parse("data:,")?;
         assert_eq!(data_url.media_type(), "text/plain");
         assert_eq!(data_url.media_type_no_default(), None);
-        assert_eq!(data_url.mime_type(), "text/plain;charset=US-ASCII");
+        assert_eq!(
+            data_url.mime_type().to_string(),
+            "text/plain;charset=US-ASCII"
+        );
         assert_eq!(data_url.charset(), "US-ASCII");
         assert_eq!(data_url.charset_no_default(), None);
-        assert!(!data_url.is_base64_encoded());
+        assert_eq!(data_url.data_encoding(), DataEncoding::Percent);
         assert_eq!(data_url.data(), b"");
         assert_eq!(data_url.fragment(), None);
         Ok(())
@@ -24,7 +27,7 @@ mod parse {
         // The standard base64 alphabet uses "+" and "/" (0.1.x expected "-" and "_" instead)
         let data_url = DataUrl::parse("data:application/octet-stream;base64,+/8=")?;
         assert_eq!(data_url.data(), [0xFB, 0xFF]);
-        assert!(data_url.is_base64_encoded());
+        assert_eq!(data_url.data_encoding(), DataEncoding::Base64);
         Ok(())
     }
 
@@ -55,7 +58,7 @@ mod parse {
     fn charset_after_whitespace() -> Result<(), Error> {
         let data_url = DataUrl::parse("data:text/html; charset=utf-8,x")?;
         assert_eq!(data_url.charset(), "utf-8");
-        assert_eq!(data_url.mime_type(), "text/html;charset=utf-8");
+        assert_eq!(data_url.mime_type().to_string(), "text/html;charset=utf-8");
         Ok(())
     }
 
@@ -160,7 +163,7 @@ mod serialize {
     fn empty() {
         let mut data_url = DataUrl::new();
         assert_eq!(data_url.to_string(), "data:,");
-        data_url.set_is_base64_encoded(true);
+        data_url.set_data_encoding(DataEncoding::Base64);
         assert_eq!(data_url.to_string(), "data:;base64,");
     }
 
@@ -178,7 +181,7 @@ mod serialize {
     fn base64_uses_standard_alphabet() {
         let mut data_url = DataUrl::new();
         data_url.set_media_type(Some("image/png")).unwrap();
-        data_url.set_is_base64_encoded(true);
+        data_url.set_data_encoding(DataEncoding::Base64);
         data_url.set_data(&[0xFB, 0xFF]);
         assert_eq!(data_url.to_string(), "data:image/png;base64,+/8=");
     }
@@ -198,7 +201,7 @@ mod serialize {
         let mut data_url = DataUrl::new();
         data_url.set_charset(Some("utf8")).unwrap();
         assert_eq!(data_url.to_string(), "data:;charset=UTF-8,");
-        assert_eq!(data_url.mime_type(), "text/plain;charset=UTF-8");
+        assert_eq!(data_url.mime_type().to_string(), "text/plain;charset=UTF-8");
     }
 
     #[test]
@@ -227,15 +230,22 @@ mod serialize {
 
     #[test]
     fn round_trips_binary_file() -> Result<(), Error> {
-        for base64 in [true, false] {
-            let mut data_url = DataUrl::new();
-            data_url.set_media_type(Some("image/png"))?;
-            data_url.set_is_base64_encoded(base64);
-            data_url.set_data(LIZARD_PNG);
-
-            let parsed = DataUrl::parse(&data_url.to_string())?;
-            assert_eq!(parsed, data_url);
-            assert_eq!(parsed.into_data(), LIZARD_PNG);
+        for data_encoding in [
+            DataEncoding::Percent,
+            DataEncoding::Base64,
+            DataEncoding::Shortest,
+        ] {
+            for escaping in [Escaping::Full, Escaping::Minimal] {
+                let mut data_url = DataUrl::new();
+                data_url.set_media_type(Some("image/png"))?;
+                data_url.set_data_encoding(data_encoding);
+                data_url.set_escaping(escaping);
+                data_url.set_data(LIZARD_PNG);
+
+                let parsed = DataUrl::parse(&data_url.to_string())?;
+                assert_eq!(parsed.media_type(), "image/png");
+                assert_eq!(parsed.into_data(), LIZARD_PNG);
+            }
         }
         Ok(())
     }
@@ -274,7 +284,7 @@ mod setters {
         let mut data_url = DataUrl::new();
         data_url.set_charset(Some("utf-8")).unwrap();
         data_url.set_media_type(Some("text/html")).unwrap();
-        assert_eq!(data_url.mime_type(), "text/html;charset=UTF-8");
+        assert_eq!(data_url.mime_type().to_string(), "text/html;charset=UTF-8");
     }
 
     #[test]
diff --git a/tests/mime.rs b/tests/mime.rs
new file mode 100644
index 0000000..1e9451e
--- /dev/null
+++ b/tests/mime.rs
@@ -0,0 +1,108 @@
+use dataurl::mime::MimeType;
+use dataurl::{DataUrl, Error};
+
+#[test]
+fn parse_and_accessors() -> Result<(), Error> {
+    let mime_type = MimeType::parse(" Image/SVG+XML ; Charset=\"utf-8\" ; foo=bar ")?;
+    assert_eq!(mime_type.essence(), "image/svg+xml");
+    assert_eq!(mime_type.main_type(), "image");
+    assert_eq!(mime_type.subtype(), "svg+xml");
+    assert_eq!(mime_type.charset(), Some("utf-8"));
+    assert_eq!(mime_type.parameter("FOO"), Some("bar"));
+    assert_eq!(mime_type.parameter("missing"), None);
+    assert_eq!(
+        mime_type.parameters().collect::<Vec<_>>(),
+        [("charset", "utf-8"), ("foo", "bar")]
+    );
+    Ok(())
+}
+
+#[test]
+fn display_uses_quotes_only_when_needed() -> Result<(), Error> {
+    let mime_type: MimeType = "text/plain;a=b;c=\"d e\";f=\"\\\"\"".parse()?;
+    assert_eq!(mime_type.to_string(), "text/plain;a=b;c=\"d e\";f=\"\\\"\"");
+    assert_eq!(MimeType::parse(&mime_type.to_string())?, mime_type);
+    Ok(())
+}
+
+#[test]
+fn invalid_parameters_are_dropped() -> Result<(), Error> {
+    // Whitespace before "=", empty values, and duplicates don't count; the MIME type itself stays valid
+    let mime_type = MimeType::parse("text/html;charset =x;a=;b=1;b=2")?;
+    assert_eq!(mime_type.parameters().collect::<Vec<_>>(), [("b", "1")]);
+    Ok(())
+}
+
+#[test]
+fn invalid_mime_types() {
+    for input in [
+        "",
+        "text",
+        "text/",
+        "/html",
+        "te xt/html",
+        "text/html/x",
+        "†/†",
+    ] {
+        assert_eq!(
+            MimeType::parse(input),
+            Err(Error::InvalidMediaType),
+            "{input:?}"
+        );
+        assert!(input.parse::<MimeType>().is_err());
+        assert!(MimeType::try_from(input).is_err());
+    }
+}
+
+#[test]
+fn data_url_mime_type() -> Result<(), Error> {
+    let data_url = DataUrl::parse("data:,")?;
+    assert_eq!(
+        data_url.mime_type().to_string(),
+        "text/plain;charset=US-ASCII"
+    );
+    assert_eq!(data_url.mime_type().charset(), Some("US-ASCII"));
+
+    let data_url = DataUrl::parse("data:image/svg+xml;charset=utf-8,x")?;
+    assert_eq!(
+        data_url.mime_type(),
+        MimeType::parse("image/svg+xml;charset=utf-8")?
+    );
+    Ok(())
+}
+
+#[test]
+fn set_mime_type_from_content_type_header() -> Result<(), Error> {
+    let mut data_url = DataUrl::new();
+    data_url.set_parameter("old", Some("gone"))?;
+    data_url.set_mime_type(Some(&MimeType::parse("Text/CSS; charset=\"UTF-8\"")?))?;
+    assert_eq!(data_url.media_type(), "text/css");
+    assert_eq!(data_url.charset(), "UTF-8");
+    assert_eq!(data_url.parameter("old"), None);
+    assert_eq!(data_url.to_string(), "data:text/css;charset=UTF-8,");
+
+    data_url.set_mime_type(None)?;
+    assert_eq!(data_url.media_type_no_default(), None);
+    assert_eq!(data_url.parameters().count(), 0);
+    Ok(())
+}
+
+#[test]
+fn set_mime_type_rejects_unrepresentable_parameters() -> Result<(), Error> {
+    // Commas end a data URL's metadata, and non-ASCII would get percent-encoded by URL parsers
+    let mut data_url = DataUrl::new();
+    data_url.set_media_type(Some("text/plain"))?;
+    for input in ["text/html;a=\"x,y\"", "text/html;a=caf\u{e9}"] {
+        let mime_type = MimeType::parse(input)?;
+        assert_eq!(
+            data_url.set_mime_type(Some(&mime_type)),
+            Err(Error::InvalidParameter)
+        );
+        assert_eq!(
+            data_url.media_type(),
+            "text/plain",
+            "nothing changes on error"
+        );
+    }
+    Ok(())
+}
diff --git a/tests/wpt.rs b/tests/wpt.rs
index d43b077..4ad53f4 100644
--- a/tests/wpt.rs
+++ b/tests/wpt.rs
@@ -19,12 +19,20 @@ fn wpt_data_urls() {
             Some(expected_mime_type) => {
                 let data_url = DataUrl::parse(input)
                     .unwrap_or_else(|e| panic!("{input:?} must be parsed, got {e:?}"));
-                assert_eq!(data_url.mime_type(), expected_mime_type, "{input:?}");
+                assert_eq!(
+                    data_url.mime_type().to_string(),
+                    expected_mime_type,
+                    "{input:?}"
+                );
                 assert_eq!(data_url.data(), test[2].as_bytes(), "{input:?}");
 
                 // Serializing and parsing again must yield the same result
                 let reparsed = DataUrl::parse(&data_url.to_string()).unwrap();
-                assert_eq!(reparsed.mime_type(), expected_mime_type, "{input:?}");
+                assert_eq!(
+                    reparsed.mime_type().to_string(),
+                    expected_mime_type,
+                    "{input:?}"
+                );
                 assert_eq!(reparsed.data(), data_url.data(), "{input:?}");
             }
             None => assert!(DataUrl::parse(input).is_err(), "{input:?} must fail"),