imprimatur 0.2.0 → 0.4.0

data/ext/imprimatur_native/core/src/barcode/matrix.rs

@@ -0,0 +1,130 @@
+//! QR Code and Data Matrix, through the `qrcode` and `datamatrix` crates.
+
+use datamatrix::{DataMatrix, SymbolList};
+use qrcode::bits::Bits;
+use qrcode::{Color, EcLevel, QrCode, QrResult, Version};
+
+use super::Symbology;
+use super::gs1::Unit;
+use crate::Result;
+
+/// How much of a QR Code may be damaged and still read: about 7%, 15%, 25%
+/// or 30% of it.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
+pub enum Level {
+    Low,
+    #[default]
+    Medium,
+    Quartile,
+    High,
+}
+
+impl From<Level> for EcLevel {
+    fn from(level: Level) -> Self {
+        match level {
+            Level::Low => Self::L,
+            Level::Medium => Self::M,
+            Level::Quartile => Self::Q,
+            Level::High => Self::H,
+        }
+    }
+}
+
+/// Where FNC1 separates fields, GS1 symbols carry `GS` (ASCII 29), which
+/// is also what scanners transmit for it.
+const GS: u8 = 0x1D;
+/// Digits shorter than this stay in byte mode: switching to numeric mode
+/// and back costs more than it saves.
+const NUMERIC_RUN: usize = 6;
+
+/// A QR Code's side in modules and its modules, row by row.
+pub fn qr(data: &[u8], level: Level) -> Result<(usize, Vec<bool>)> {
+    let code = QrCode::with_error_correction_level(data, level.into())
+        .map_err(|_| too_long(Symbology::QrCode))?;
+    Ok(qr_modules(code))
+}
+
+/// A GS1 QR Code (FNC1 in first position) in the smallest version it fits.
+pub fn gs1_qr(units: &[Unit], level: Level) -> Result<(usize, Vec<bool>)> {
+    let level = EcLevel::from(level);
+    let data = bytes(units);
+    let bits = (1..=40)
+        .find_map(|version| gs1_bits(&data, Version::Normal(version), level).ok())
+        .ok_or_else(|| too_long(Symbology::QrCode))?;
+    let code = QrCode::with_bits(bits, level).map_err(|_| too_long(Symbology::QrCode))?;
+    Ok(qr_modules(code))
+}
+
+/// Long runs of digits in numeric mode, the rest in byte mode: alphanumeric
+/// mode would read a `%` in the data as a separator.
+fn gs1_bits(data: &[u8], version: Version, level: EcLevel) -> QrResult<Bits> {
+    let mut bits = Bits::new(version);
+    bits.push_fnc1_first_position()?;
+    let mut rest = data;
+    while !rest.is_empty() {
+        let digits = rest.iter().take_while(|byte| byte.is_ascii_digit()).count();
+        if digits >= NUMERIC_RUN {
+            bits.push_numeric_data(&rest[..digits])?;
+            rest = &rest[digits..];
+            continue;
+        }
+        let mut end = 0;
+        while end < rest.len() {
+            let run = rest[end..].iter().take_while(|byte| byte.is_ascii_digit()).count();
+            if run >= NUMERIC_RUN {
+                break;
+            }
+            end += run.max(1);
+        }
+        bits.push_byte_data(&rest[..end])?;
+        rest = &rest[end..];
+    }
+    bits.push_terminator(level)?;
+    Ok(bits)
+}
+
+/// A square Data Matrix's columns and rows, and its modules row by row.
+pub fn data_matrix(text: &str) -> Result<((usize, usize), Vec<bool>)> {
+    let code =
+        DataMatrix::encode_str(text, square()).map_err(|_| too_long(Symbology::DataMatrix))?;
+    Ok(modules(&code))
+}
+
+/// A square GS1 `DataMatrix`: FNC1 first, then the data.
+pub fn gs1_data_matrix(units: &[Unit]) -> Result<((usize, usize), Vec<bool>)> {
+    let code = DataMatrix::encode_gs1(&bytes(units), square())
+        .map_err(|_| too_long(Symbology::DataMatrix))?;
+    Ok(modules(&code))
+}
+
+fn qr_modules(code: QrCode) -> (usize, Vec<bool>) {
+    (code.width(), code.into_colors().into_iter().map(|color| color == Color::Dark).collect())
+}
+
+fn square() -> SymbolList {
+    SymbolList::default().enforce_square()
+}
+
+fn modules(code: &DataMatrix) -> ((usize, usize), Vec<bool>) {
+    let bitmap = code.bitmap();
+    let (columns, rows) = (bitmap.width(), bitmap.height());
+    let mut modules = vec![false; columns * rows];
+    for (x, y) in bitmap.pixels() {
+        modules[y * columns + x] = true;
+    }
+    ((columns, rows), modules)
+}
+
+fn bytes(units: &[Unit]) -> Vec<u8> {
+    units
+        .iter()
+        .map(|unit| match unit {
+            Unit::Char(byte) => *byte,
+            Unit::Fnc1 => GS,
+        })
+        .collect()
+}
+
+fn too_long(symbology: Symbology) -> crate::Error {
+    symbology.invalid("too much data for the largest symbol")
+}

data/ext/imprimatur_native/core/src/barcode.rs

@@ -0,0 +1,314 @@
+//! Barcodes: QR Code and Data Matrix, EAN-13, EAN-8, UPC-A and Code 128,
+//! and the GS1 forms of QR Code, Data Matrix and Code 128 (GS1-128), drawn
+//! as SVG, as PNG, or into a [`Document`](crate::doc::Document) as shapes.
+//!
+//! QR Code and Data Matrix come from the `qrcode` and `datamatrix` crates;
+//! the linear symbologies, GS1 element strings and the drawing are ours.
+//!
+//! ```
+//! use imprimatur::barcode::{Barcode, Level, Look};
+//!
+//! let qr = Barcode::qr("https://id.gs1.org/01/09506000134352", Level::Medium)?;
+//! assert!(qr.svg(4.0, &Look::default())?.starts_with("<svg"));
+//!
+//! let ean = Barcode::ean13("950600013435")?;
+//! assert_eq!(ean.text(), "9506000134352"); // the check digit, added
+//!
+//! let label = Barcode::gs1_128("(00)106141412345678908")?;
+//! assert!(label.png(3, &Look::default())?.starts_with(b"\x89PNG"));
+//! # Ok::<(), imprimatur::Error>(())
+//! ```
+
+mod code128;
+mod draw;
+mod ean;
+mod gs1;
+mod matrix;
+#[cfg(test)]
+mod tests;
+
+pub(crate) use draw::Shapes;
+pub use gs1::check_digit;
+pub use matrix::Level;
+
+use crate::style::Color;
+use crate::{Error, Result};
+
+/// The kinds of barcode.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum Symbology {
+    QrCode,
+    DataMatrix,
+    Ean13,
+    Ean8,
+    UpcA,
+    Code128,
+}
+
+impl Symbology {
+    #[must_use]
+    pub const fn name(self) -> &'static str {
+        match self {
+            Self::QrCode => "QR Code",
+            Self::DataMatrix => "Data Matrix",
+            Self::Ean13 => "EAN-13",
+            Self::Ean8 => "EAN-8",
+            Self::UpcA => "UPC-A",
+            Self::Code128 => "Code 128",
+        }
+    }
+
+    /// Whether it is one row of bars, read across.
+    #[must_use]
+    pub const fn is_linear(self) -> bool {
+        matches!(self, Self::Ean13 | Self::Ean8 | Self::UpcA | Self::Code128)
+    }
+
+    /// The blank margin readers need, in modules: left, right, and above
+    /// and below.
+    const fn quiet_zone(self) -> (usize, usize, usize) {
+        match self {
+            Self::QrCode => (4, 4, 4),
+            Self::DataMatrix => (1, 1, 1),
+            Self::Ean13 => (11, 7, 0),
+            Self::Ean8 => (7, 7, 0),
+            Self::UpcA => (9, 9, 0),
+            Self::Code128 => (10, 10, 0),
+        }
+    }
+
+    pub(crate) fn invalid(self, reason: impl Into<String>) -> Error {
+        Error::InvalidBarcode { symbology: self.name(), reason: reason.into() }
+    }
+}
+
+/// A barcode symbol: its modules, dark or light, ready to draw.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Barcode {
+    symbology: Symbology,
+    gs1: bool,
+    text: String,
+    columns: usize,
+    rows: usize,
+    /// Row by row; a linear code has one row.
+    modules: Vec<bool>,
+}
+
+impl Barcode {
+    /// A QR Code of text, such as a URL (a GS1 Digital Link is one).
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`] when the text does not fit at `level`.
+    pub fn qr(text: &str, level: Level) -> Result<Self> {
+        let (side, modules) = matrix::qr(text.as_bytes(), level)?;
+        Ok(Self::matrix(Symbology::QrCode, false, text, (side, side), modules))
+    }
+
+    /// A GS1 QR Code of an element string such as
+    /// `(01)09506000134352(10)AB12`.
+    ///
+    /// # Errors
+    /// [`Error::InvalidElementString`], or [`Error::InvalidBarcode`] when it
+    /// does not fit at `level`.
+    pub fn gs1_qr(element_string: &str, level: Level) -> Result<Self> {
+        let units = gs1::element_units(element_string)?;
+        let (side, modules) = matrix::gs1_qr(&units, level)?;
+        Ok(Self::matrix(Symbology::QrCode, true, element_string, (side, side), modules))
+    }
+
+    /// A square Data Matrix of text: Latin-1 as is, anything else as UTF-8.
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`] when the text does not fit.
+    pub fn data_matrix(text: &str) -> Result<Self> {
+        let (size, modules) = matrix::data_matrix(text)?;
+        Ok(Self::matrix(Symbology::DataMatrix, false, text, size, modules))
+    }
+
+    /// A square GS1 `DataMatrix` of an element string such as
+    /// `(01)09506000134352(17)251231(10)AB12`.
+    ///
+    /// # Errors
+    /// [`Error::InvalidElementString`], or [`Error::InvalidBarcode`] when it
+    /// does not fit.
+    pub fn gs1_data_matrix(element_string: &str) -> Result<Self> {
+        let units = gs1::element_units(element_string)?;
+        let (size, modules) = matrix::gs1_data_matrix(&units)?;
+        Ok(Self::matrix(Symbology::DataMatrix, true, element_string, size, modules))
+    }
+
+    /// An EAN-13 of a GTIN-13: 12 digits and the check digit is added, or
+    /// 13 and it is checked.
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`] for anything else, or a wrong check digit.
+    pub fn ean13(digits: &str) -> Result<Self> {
+        let digits = ean::digits(Symbology::Ean13, digits, 13)?;
+        Ok(Self::linear(Symbology::Ean13, false, ean::text(&digits), ean::ean13(&digits)))
+    }
+
+    /// An EAN-8 of a GTIN-8: 7 digits, or 8 with the check digit.
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`] for anything else, or a wrong check digit.
+    pub fn ean8(digits: &str) -> Result<Self> {
+        let digits = ean::digits(Symbology::Ean8, digits, 8)?;
+        Ok(Self::linear(Symbology::Ean8, false, ean::text(&digits), ean::ean8(&digits)))
+    }
+
+    /// A UPC-A of a GTIN-12: 11 digits, or 12 with the check digit. Its bars
+    /// are those of the EAN-13 with a leading zero.
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`] for anything else, or a wrong check digit.
+    pub fn upc_a(digits: &str) -> Result<Self> {
+        let digits = ean::digits(Symbology::UpcA, digits, 12)?;
+        let mut ean = Vec::with_capacity(13);
+        ean.push(0);
+        ean.extend_from_slice(&digits);
+        Ok(Self::linear(Symbology::UpcA, false, ean::text(&digits), ean::ean13(&ean)))
+    }
+
+    /// A Code 128 of ASCII text, switching to code set C for runs of digits.
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`] for text beyond ASCII, empty, or longer than
+    /// 128 characters.
+    pub fn code128(text: &str) -> Result<Self> {
+        let units: Vec<gs1::Unit> = text.bytes().map(gs1::Unit::Char).collect();
+        (!units.is_empty()).ok_or_else(|| Symbology::Code128.invalid("no text"))?;
+        (units.len() <= 128).ok_or_else(|| Symbology::Code128.invalid("128 characters at most"))?;
+        Ok(Self::linear(Symbology::Code128, false, text.to_owned(), code128::encode(&units)?))
+    }
+
+    /// A GS1-128 of an element string such as `(00)106141412345678908`:
+    /// Code 128 opening with FNC1, at most 48 characters with separators.
+    ///
+    /// # Errors
+    /// [`Error::InvalidElementString`], or [`Error::InvalidBarcode`] when it
+    /// is too long.
+    pub fn gs1_128(element_string: &str) -> Result<Self> {
+        let mut units = vec![gs1::Unit::Fnc1];
+        units.extend(gs1::element_units(element_string)?);
+        let characters = units.len() - 1;
+        (characters <= 48).ok_or_else(|| {
+            Symbology::Code128
+                .invalid(format!("GS1-128 holds 48 characters with separators, not {characters}"))
+        })?;
+        let modules = code128::encode(&units)?;
+        Ok(Self::linear(Symbology::Code128, true, element_string.to_owned(), modules))
+    }
+
+    fn matrix(
+        symbology: Symbology,
+        gs1: bool,
+        text: &str,
+        (columns, rows): (usize, usize),
+        modules: Vec<bool>,
+    ) -> Self {
+        Self { symbology, gs1, text: text.to_owned(), columns, rows, modules }
+    }
+
+    const fn linear(symbology: Symbology, gs1: bool, text: String, modules: Vec<bool>) -> Self {
+        Self { symbology, gs1, text, columns: modules.len(), rows: 1, modules }
+    }
+
+    #[must_use]
+    pub const fn symbology(&self) -> Symbology {
+        self.symbology
+    }
+
+    /// Whether it carries a GS1 element string (its FNC1 mode).
+    #[must_use]
+    pub const fn is_gs1(&self) -> bool {
+        self.gs1
+    }
+
+    /// What it encodes: the text or element string given, or a GTIN's
+    /// digits with the check digit.
+    #[must_use]
+    pub fn text(&self) -> &str {
+        &self.text
+    }
+
+    /// Columns and rows of modules, without the quiet zone; a linear code
+    /// is one row.
+    #[must_use]
+    pub const fn size(&self) -> (usize, usize) {
+        (self.columns, self.rows)
+    }
+
+    /// Whether the module at column `x`, row `y` is dark; false outside.
+    #[must_use]
+    pub fn is_dark(&self, x: usize, y: usize) -> bool {
+        x < self.columns && self.modules.get(y * self.columns + x).copied().unwrap_or(false)
+    }
+
+    /// SVG markup, `module` user units (pixels) a module.
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`] for a module outside 0.01 to 1000.
+    pub fn svg(&self, module: f64, look: &Look) -> Result<String> {
+        (0.01..=1000.0)
+            .contains(&module)
+            .ok_or_else(|| self.symbology.invalid("a module of 0.01 to 1000 units"))?;
+        Ok(draw::svg(&self.shapes(look.quiet_zone, look.bar_height), module, look))
+    }
+
+    /// A PNG, `scale` pixels a module.
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`] for a scale of 0, or an image above 65 536
+    /// pixels a side.
+    pub fn png(&self, scale: u32, look: &Look) -> Result<Vec<u8>> {
+        draw::png(&self.shapes(look.quiet_zone, look.bar_height), scale, look)
+            .ok_or_else(|| self.symbology.invalid("a scale of 1 or more, under 65 536 pixels"))
+    }
+
+    /// A module's size in points when a document is not told: 0.33 mm for
+    /// retail EAN and UPC, 0.495 mm for GS1-128 (logistics labels), 0.35 mm
+    /// for other Code 128, 0.7 mm for QR Code and Data Matrix.
+    pub(crate) const fn default_module(&self) -> f64 {
+        match self.symbology {
+            Symbology::Ean13 | Symbology::Ean8 | Symbology::UpcA => 0.935,
+            Symbology::Code128 if self.gs1 => 1.4,
+            Symbology::Code128 => 1.0,
+            Symbology::QrCode | Symbology::DataMatrix => 2.0,
+        }
+    }
+
+    /// A linear code's bar height in modules when not told: GS1's nominal
+    /// 22.85 mm (EAN-13, UPC-A) and 18.23 mm (EAN-8) at 0.33 mm, and for
+    /// Code 128 ISO/IEC 15417's 15% of its width, 20 modules at least.
+    const fn default_bar_height(&self) -> usize {
+        match self.symbology {
+            Symbology::Ean13 | Symbology::UpcA => 69,
+            Symbology::Ean8 => 55,
+            _ => {
+                let height = (self.columns * 15).div_ceil(100);
+                if height > 20 { height } else { 20 }
+            }
+        }
+    }
+}
+
+/// How a barcode is drawn as SVG or PNG.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Look {
+    pub dark: Color,
+    /// The background; `None` leaves it transparent.
+    pub light: Option<Color>,
+    /// Keep the blank margin the symbology needs around it.
+    pub quiet_zone: bool,
+    /// A linear code's bar height in modules; `None` takes the
+    /// symbology's nominal height.
+    pub bar_height: Option<u32>,
+}
+
+impl Default for Look {
+    /// Black on white, with its quiet zone.
+    fn default() -> Self {
+        Self { dark: Color::BLACK, light: Some(Color::WHITE), quiet_zone: true, bar_height: None }
+    }
+}

data/ext/imprimatur_native/core/src/doc/paragraph.rs

@@ -46,8 +46,9 @@ impl Run {
     }
 }
 
-/// Runs of text laid out together. Left aligned unless told otherwise, or
-/// right aligned when right to left.
+/// Runs of text laid out together, in the direction set or else that of
+/// their first letter. Left aligned unless told otherwise, or right aligned
+/// when right to left.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct Paragraph {
     pub(crate) runs: Vec<Run>,
@@ -102,9 +103,15 @@ impl Paragraph {
         &self.runs
     }
 
+    /// The direction the paragraph reads in: as set, or else that of its
+    /// first letter.
+    pub(crate) fn effective_direction(&self) -> Option<TextDirection> {
+        self.direction.or_else(|| self.runs.iter().find_map(|run| TextDirection::of(&run.text)))
+    }
+
     /// The alignment the paragraph is laid out with.
     pub(crate) fn effective_align(&self) -> Align {
-        self.align.unwrap_or(match self.direction {
+        self.align.unwrap_or_else(|| match self.effective_direction() {
             Some(TextDirection::RightToLeft) => Align::Right,
             _ => Align::Left,
         })

data/ext/imprimatur_native/core/src/doc/picture.rs

@@ -0,0 +1,192 @@
+//! Pictures: PNG or JPEG files, read once for what PDF and DOCX need.
+
+use std::sync::Arc;
+
+use crate::style::Align;
+use crate::{Error, Result};
+
+/// Pixels per point at 96 pixels an inch: a picture's size when none is set.
+const POINTS_PER_PIXEL: f64 = 0.75;
+/// The largest side, in points, a picture may be set to: PDF's page limit.
+const MAX_POINTS: f64 = 14_400.0;
+/// The largest side, in pixels, a picture may have.
+const MAX_PIXELS: u32 = 1 << 16;
+
+/// A PNG or JPEG drawn in the document's flow.
+///
+/// It is drawn at the width or height set (in points, the other following
+/// its proportions), or else at 96 pixels an inch, never larger than the
+/// page leaves room for.
+///
+/// ```no_run
+/// use imprimatur::doc::{Document, Picture};
+/// use imprimatur::style::Align;
+///
+/// let mut doc = Document::new();
+/// doc.picture(Picture::new(std::fs::read("logo.png")?)?.width(144.0)?.align(Align::Center));
+/// # Ok::<(), imprimatur::Error>(())
+/// ```
+#[derive(Debug, Clone, PartialEq)]
+pub struct Picture {
+    pub(crate) data: Arc<[u8]>,
+    pub(crate) kind: Kind,
+    pub(crate) pixels: (u32, u32),
+    width: Option<f64>,
+    height: Option<f64>,
+    pub(crate) align: Option<Align>,
+}
+
+/// The format, and what writing it takes.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Kind {
+    Png(Png),
+    /// Gray (1), RGB (3) or CMYK (4) components; Adobe's CMYK is inverted.
+    Jpeg {
+        components: u8,
+        inverted: bool,
+    },
+}
+
+/// A PNG's pixel layout and its compressed pixels (its `IDAT` chunks).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Png {
+    pub depth: u8,
+    /// 0 gray, 2 RGB, 3 palette, 4 gray and alpha, 6 RGB and alpha.
+    pub color: u8,
+    pub palette: Vec<u8>,
+    /// The `tRNS` chunk: a palette's alphas, or the transparent color.
+    pub transparency: Vec<u8>,
+    pub compressed: Vec<u8>,
+}
+
+impl Picture {
+    /// # Errors
+    /// [`Error::InvalidImage`] for data that is no PNG or JPEG, a damaged
+    /// one, an interlaced PNG, a JPEG other than 8 bits a sample, or one
+    /// larger than 65 536 pixels a side.
+    pub fn new(data: impl Into<Vec<u8>>) -> Result<Self> {
+        let data: Arc<[u8]> = data.into().into();
+        let (kind, pixels) = if data.starts_with(b"\x89PNG\r\n\x1a\n") {
+            png(&data)?
+        } else if data.starts_with(&[0xFF, 0xD8, 0xFF]) {
+            jpeg(&data)?
+        } else {
+            return Err(Error::InvalidImage("not a PNG or JPEG image"));
+        };
+        let valid = (1..=MAX_PIXELS).contains(&pixels.0) && (1..=MAX_PIXELS).contains(&pixels.1);
+        valid.ok_or(Error::InvalidImage("a picture of 1 to 65 536 pixels a side"))?;
+        Ok(Self { data, kind, pixels, width: None, height: None, align: None })
+    }
+
+    /// Its width in points; the height follows unless set too.
+    ///
+    /// # Errors
+    /// [`Error::InvalidImage`] outside 1 to 14 400 points.
+    pub fn width(mut self, points: f64) -> Result<Self> {
+        self.width = Some(points_in_range(points)?);
+        Ok(self)
+    }
+
+    /// Its height in points; the width follows unless set too.
+    ///
+    /// # Errors
+    /// [`Error::InvalidImage`] outside 1 to 14 400 points.
+    pub fn height(mut self, points: f64) -> Result<Self> {
+        self.height = Some(points_in_range(points)?);
+        Ok(self)
+    }
+
+    #[must_use]
+    pub const fn align(mut self, align: Align) -> Self {
+        self.align = Some(align);
+        self
+    }
+
+    /// The size it is drawn at, in points, fitted into `room` (the width
+    /// and height between the margins).
+    pub(crate) fn size(&self, room: (f64, f64)) -> (f64, f64) {
+        let (pixels_wide, pixels_high) = (f64::from(self.pixels.0), f64::from(self.pixels.1));
+        let (width, height) = match (self.width, self.height) {
+            (Some(width), Some(height)) => (width, height),
+            (Some(width), None) => (width, width * pixels_high / pixels_wide),
+            (None, Some(height)) => (height * pixels_wide / pixels_high, height),
+            (None, None) => (pixels_wide * POINTS_PER_PIXEL, pixels_high * POINTS_PER_PIXEL),
+        };
+        let scale = (room.0 / width).min(room.1 / height).min(1.0);
+        (width * scale, height * scale)
+    }
+}
+
+fn points_in_range(points: f64) -> Result<f64> {
+    (1.0..=MAX_POINTS)
+        .contains(&points)
+        .then_some(points)
+        .ok_or(Error::InvalidImage("a picture of 1 to 14 400 points a side"))
+}
+
+/// A PNG's chunks; interlaced ones are refused.
+fn png(data: &[u8]) -> Result<(Kind, (u32, u32))> {
+    let damaged = || Error::InvalidImage("a damaged PNG");
+    let mut png = Png {
+        depth: 0,
+        color: 0,
+        palette: Vec::new(),
+        transparency: Vec::new(),
+        compressed: Vec::new(),
+    };
+    let (mut pixels, mut at) = (None, 8);
+    while let Some(head) = data.get(at..at + 8) {
+        let length = u32::from_be_bytes([head[0], head[1], head[2], head[3]]) as usize;
+        let body = data.get(at + 8..at + 8 + length).ok_or_else(damaged)?;
+        match &head[4..8] {
+            b"IHDR" if body.len() == 13 => {
+                let side = |at: usize| {
+                    u32::from_be_bytes([body[at], body[at + 1], body[at + 2], body[at + 3]])
+                };
+                pixels = Some((side(0), side(4)));
+                (png.depth, png.color) = (body[8], body[9]);
+                (body[12] == 0).ok_or(Error::InvalidImage("an interlaced PNG"))?;
+            }
+            b"PLTE" => png.palette = body.to_vec(),
+            b"tRNS" => png.transparency = body.to_vec(),
+            b"IDAT" => png.compressed.extend_from_slice(body),
+            b"IEND" => break,
+            _ => {}
+        }
+        at += 12 + length;
+    }
+    let layout = matches!(
+        (png.color, png.depth),
+        (0, 1 | 2 | 4 | 8 | 16) | (3, 1 | 2 | 4 | 8) | (2 | 4 | 6, 8 | 16)
+    );
+    let palette = png.color != 3 || !png.palette.is_empty();
+    let pixels = pixels.filter(|_| layout && palette && !png.compressed.is_empty());
+    Ok((Kind::Png(png), pixels.ok_or_else(damaged)?))
+}
+
+/// A JPEG's frame header (`SOF`), and Adobe's mark, which inverts CMYK.
+fn jpeg(data: &[u8]) -> Result<(Kind, (u32, u32))> {
+    let damaged = || Error::InvalidImage("a damaged JPEG");
+    let (mut at, mut inverted) = (2, false);
+    loop {
+        let &[0xFF, marker, high, low] = data.get(at..at + 4).ok_or_else(damaged)? else {
+            return Err(damaged());
+        };
+        let length = usize::from(u16::from_be_bytes([high, low]));
+        if marker == 0xEE && data.get(at + 4..at + 9) == Some(b"Adobe") {
+            inverted = true;
+        }
+        // SOF0 to SOF15, but DHT, JPG and DAC share the range.
+        if (0xC0..=0xCF).contains(&marker) && !matches!(marker, 0xC4 | 0xC8 | 0xCC) {
+            let frame = data.get(at + 4..at + 10).ok_or_else(damaged)?;
+            (frame[0] == 8).ok_or(Error::InvalidImage("a JPEG of 8 bits a sample"))?;
+            let height = u32::from(u16::from_be_bytes([frame[1], frame[2]]));
+            let width = u32::from(u16::from_be_bytes([frame[3], frame[4]]));
+            let components = frame[5];
+            matches!(components, 1 | 3 | 4).ok_or_else(damaged)?;
+            let kind = Kind::Jpeg { components, inverted: inverted && components == 4 };
+            return Ok((kind, (width, height)));
+        }
+        at += 2 + length;
+    }
+}