imprimatur 0.3.0 → 0.5.0

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/symbol.rs

@@ -0,0 +1,136 @@
+//! Barcodes in the flow: shapes in a PDF, a picture in DOCX.
+
+use crate::Result;
+use crate::barcode::{Barcode, Look, Shapes};
+use crate::doc::Picture;
+use crate::style::{Align, Color};
+
+/// The largest side, in points, a symbol may be set to: PDF's page limit.
+const MAX_POINTS: f64 = 14_400.0;
+/// Pixels an inch a DOCX picture of a symbol has at least.
+const DOCX_DPI: f64 = 300.0;
+
+/// A [`Barcode`] drawn in a document's flow.
+///
+/// It is drawn at the width or height set (in points; a QR Code or Data
+/// Matrix keeps square modules, a linear code's height is its bars'), or
+/// else at its symbology's usual module size, never larger than the page
+/// leaves room for. Its quiet zone is part of its size.
+///
+/// ```
+/// use imprimatur::barcode::{Barcode, Level};
+/// use imprimatur::doc::{Document, Symbol};
+/// use imprimatur::style::Align;
+///
+/// let mut doc = Document::new();
+/// let qr = Barcode::qr("https://example.com", Level::Medium)?;
+/// doc.barcode(Symbol::new(qr).width(144.0)?.align(Align::Center));
+/// doc.barcode(Barcode::ean13("950600013435")?);
+/// assert!(doc.to_pdf()?.starts_with(b"%PDF-"));
+/// # Ok::<(), imprimatur::Error>(())
+/// ```
+#[derive(Debug, Clone, PartialEq)]
+pub struct Symbol {
+    pub(crate) barcode: Barcode,
+    width: Option<f64>,
+    height: Option<f64>,
+    pub(crate) align: Option<Align>,
+    pub(crate) color: Color,
+}
+
+impl Symbol {
+    #[must_use]
+    pub const fn new(barcode: Barcode) -> Self {
+        Self { barcode, width: None, height: None, align: None, color: Color::BLACK }
+    }
+
+    /// Its width in points, quiet zone included.
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`](crate::Error::InvalidBarcode) outside 1 to
+    /// 14 400 points.
+    pub fn width(mut self, points: f64) -> Result<Self> {
+        self.width = Some(self.points_in_range(points)?);
+        Ok(self)
+    }
+
+    /// Its height in points: a linear code's bars, a QR Code or Data
+    /// Matrix's whole (quiet zone included).
+    ///
+    /// # Errors
+    /// [`Error::InvalidBarcode`](crate::Error::InvalidBarcode) outside 1 to
+    /// 14 400 points.
+    pub fn height(mut self, points: f64) -> Result<Self> {
+        self.height = Some(self.points_in_range(points)?);
+        Ok(self)
+    }
+
+    #[must_use]
+    pub const fn align(mut self, align: Align) -> Self {
+        self.align = Some(align);
+        self
+    }
+
+    /// The bars' color; black unless set.
+    #[must_use]
+    pub const fn color(mut self, color: Color) -> Self {
+        self.color = color;
+        self
+    }
+
+    /// Its rectangles and the size they are drawn at, in points, fitted
+    /// into `room` (the width and height between the margins).
+    pub(crate) fn placed(&self, room: (f64, f64)) -> (Shapes, (f64, f64)) {
+        let shapes = self.barcode.shapes(true, None);
+        let (columns, rows) = shapes.extent();
+        let module = self.barcode.default_module();
+        let (width, height) = if self.barcode.symbology().is_linear() {
+            let width = self.width.unwrap_or(columns * module);
+            (width, self.height.unwrap_or(rows * width / columns))
+        } else {
+            let module = match (self.width, self.height) {
+                (Some(width), Some(height)) => (width / columns).min(height / rows),
+                (Some(width), None) => width / columns,
+                (None, Some(height)) => height / rows,
+                (None, None) => module,
+            };
+            (columns * module, rows * module)
+        };
+        let scale = (room.0 / width).min(room.1 / height).min(1.0);
+        (shapes, (width * scale, height * scale))
+    }
+
+    /// A PNG of it at 300 pixels an inch or more, for formats that take
+    /// pictures only.
+    pub(crate) fn picture(&self, room: (f64, f64)) -> Result<Picture> {
+        let (shapes, (width, height)) = self.placed(room);
+        let module = width / shapes.extent().0;
+        #[expect(clippy::cast_possible_truncation, clippy::cast_sign_loss, reason = "1 to 64")]
+        let scale = (module * DOCX_DPI / 72.0).ceil().clamp(1.0, 64.0) as u32;
+        #[expect(clippy::cast_possible_truncation, clippy::cast_sign_loss, reason = "bars, small")]
+        let bar_height = (height / module).round().max(1.0) as u32;
+        let look = Look {
+            dark: self.color,
+            light: Some(Color::WHITE),
+            quiet_zone: true,
+            bar_height: Some(bar_height),
+        };
+        let png = self.barcode.png(scale, &look)?;
+        let picture = Picture::new(png)?.width(width)?.height(height)?;
+        Ok(match self.align {
+            Some(align) => picture.align(align),
+            None => picture,
+        })
+    }
+
+    fn points_in_range(&self, points: f64) -> Result<f64> {
+        let invalid = || self.barcode.symbology().invalid("a size of 1 to 14 400 points");
+        (1.0..=MAX_POINTS).contains(&points).then_some(points).ok_or_else(invalid)
+    }
+}
+
+impl From<Barcode> for Symbol {
+    fn from(barcode: Barcode) -> Self {
+        Self::new(barcode)
+    }
+}

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

@@ -23,6 +23,7 @@
 
 mod paragraph;
 pub(crate) mod picture;
+mod symbol;
 mod table;
 #[cfg(test)]
 mod tests;
@@ -33,6 +34,7 @@ use std::path::Path;
 
 pub use paragraph::{Paragraph, Run};
 pub use picture::Picture;
+pub use symbol::Symbol;
 pub use table::Table;
 
 use crate::script::Counts;
@@ -96,6 +98,7 @@ pub enum Block {
     Paragraph(Paragraph),
     Table(Table),
     Picture(Picture),
+    Symbol(Symbol),
     PageBreak,
 }
 
@@ -158,6 +161,13 @@ impl Document {
         self
     }
 
+    /// A barcode, in the flow of the text: a [`Barcode`](crate::barcode::Barcode)
+    /// at its usual size, or a [`Symbol`] sized and aligned.
+    pub fn barcode(&mut self, symbol: impl Into<Symbol>) -> &mut Self {
+        self.blocks.push(Block::Symbol(symbol.into()));
+        self
+    }
+
     /// Numbers pages `1 / 3` at the bottom of each one.
     pub const fn set_page_numbers(&mut self, enabled: bool) -> &mut Self {
         self.page_numbers = enabled;
@@ -222,7 +232,7 @@ impl Document {
                     paragraph.runs.iter().for_each(|run| counts.add(&run.text));
                 }
                 Block::Table(table) => table.count(&mut counts),
-                Block::Picture(_) | Block::PageBreak => {}
+                Block::Picture(_) | Block::Symbol(_) | Block::PageBreak => {}
             }
         }
         counts.right_to_left()

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

@@ -6,6 +6,7 @@ mod picture;
 #[cfg(test)]
 mod tests;
 
+use std::borrow::Cow;
 use std::io::Write;
 
 use crate::Result;
@@ -29,11 +30,17 @@ pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
     }
     // Pictures' files follow, their relationships numbered from here.
     let first_media = parts.len() + 1;
-    let pictures: Vec<&Picture> = document
+    // Barcodes go in as pictures.
+    let rendered = document
         .blocks()
         .iter()
-        .filter_map(|block| if let Block::Picture(picture) = block { Some(picture) } else { None })
-        .collect();
+        .filter_map(|block| match block {
+            Block::Picture(picture) => Some(Ok(Cow::Borrowed(picture))),
+            Block::Symbol(symbol) => Some(symbol.picture(room).map(Cow::Owned)),
+            _ => None,
+        })
+        .collect::<Result<Vec<Cow<'_, Picture>>>>()?;
+    let pictures: Vec<&Picture> = rendered.iter().map(|picture| &**picture).collect();
     for (number, picture) in (1..).zip(&pictures) {
         parts.push(("image", picture::file_name(picture, number)));
     }
@@ -41,7 +48,7 @@ pub fn write<W: Write>(document: &Document, out: W) -> Result<W> {
     zip.add("[Content_Types].xml", content_types(footer, &pictures).as_bytes())?;
     let package = opc::relationships(&[("officeDocument", "word/document.xml")]);
     zip.add("_rels/.rels", package.as_bytes())?;
-    zip.add("word/document.xml", body(document, room, first_media).as_bytes())?;
+    zip.add("word/document.xml", body(document, room, first_media, &pictures).as_bytes())?;
     zip.add("word/_rels/document.xml.rels", opc::relationships(&parts).as_bytes())?;
     zip.add("word/styles.xml", styles().as_bytes())?;
     if footer {
@@ -102,7 +109,12 @@ fn page_number_footer() -> String {
     xml.finish()
 }
 
-fn body(document: &Document, room: (f64, f64), first_media: usize) -> String {
+fn body(
+    document: &Document,
+    room: (f64, f64),
+    first_media: usize,
+    pictures: &[&Picture],
+) -> String {
     // What reads in no direction of its own (figures, punctuation) takes the
     // document's.
     let rtl = document.reads_right_to_left();
@@ -116,7 +128,7 @@ fn body(document: &Document, room: (f64, f64), first_media: usize) -> String {
     ];
     xml.open("w:document", &namespaces);
     xml.open("w:body", &[]);
-    let mut pictures = 0;
+    let mut drawn = 0;
     for block in document.blocks() {
         match block {
             Block::Heading { level, text } => {
@@ -125,10 +137,10 @@ fn body(document: &Document, room: (f64, f64), first_media: usize) -> String {
             }
             Block::Paragraph(content) => paragraph(&mut xml, content, rtl),
             Block::Table(content) => table(&mut xml, content, document, rtl),
-            Block::Picture(content) => {
-                pictures += 1;
-                let relationship = format!("rId{}", first_media + pictures - 1);
-                picture::paragraph(&mut xml, content, room, pictures, &relationship);
+            Block::Picture(_) | Block::Symbol(_) => {
+                drawn += 1;
+                let relationship = format!("rId{}", first_media + drawn - 1);
+                picture::paragraph(&mut xml, pictures[drawn - 1], room, drawn, &relationship);
             }
             Block::PageBreak => {
                 xml.open("w:p", &[]);

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

@@ -88,6 +88,12 @@ pub enum Error {
     #[error("a table row needs {0:.0}pt, more than a whole page holds")]
     RowTooTall(f64),
 
+    #[error("invalid {symbology} barcode: {reason}")]
+    InvalidBarcode { symbology: &'static str, reason: String },
+
+    #[error("invalid GS1 element string: {0}")]
+    InvalidElementString(String),
+
     #[error("a workbook needs at least one sheet")]
     EmptyWorkbook,
 

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

@@ -224,6 +224,8 @@ fn unicode_cmap<'a>(cmap: &Cmap<'a>) -> Result<CmapSubtable<'a>> {
     Err(Error::UnsupportedFont("no supported Unicode cmap"))
 }
 
-fn invalid(reason: impl std::fmt::Display) -> Error {
+/// `Malformed`, categorized as TrueType font data: parsing, embedding and PDF
+/// resource errors ([`crate::pdf::truetype`]) all point at the same category.
+pub(crate) fn invalid(reason: impl std::fmt::Display) -> Error {
     Error::malformed("TrueType font", reason.to_string())
 }

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

@@ -3,7 +3,8 @@
 //! (deflate) and `crc32fast`.
 //!
 //! [`xlsx`] writes workbooks; [`doc`] is one document model that renders to
-//! PDF and DOCX.
+//! PDF and DOCX; [`barcode`] draws QR Code, Data Matrix, EAN, UPC and Code
+//! 128 symbols, GS1 ones included.
 //!
 //! ```
 //! use imprimatur::xlsx::{Cell, Workbook};
@@ -20,6 +21,7 @@
 
 #[cfg(feature = "archive")]
 pub mod archive;
+pub mod barcode;
 pub mod doc;
 mod docx;
 mod error;