imprimatur 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72d405b951859304a851be99269f01972fd7817960cb53f01dbfca257f700112
-  data.tar.gz: 5dbc90d5aec863460a9d61134961d0c384aafd073890d52023b9291aa7ba24b4
+  metadata.gz: 4b0c00d27618298889f1419aec02a69a9de179fb9f3caaa5f33e57db05a68a9b
+  data.tar.gz: f8c77e28a3f3ada14611260a7f1ffffc830ba3f6e0ec6d0675b4c8177b391f72
 SHA512:
-  metadata.gz: 1e1ea6bb4b63996aea9b36d1241e34c7133cbf3f2305778542c1267fdea7b62db170a8434d4af174fc8d49930a348a2682f07f0b8bec1d2be80c8696ebd75664
-  data.tar.gz: bc7c2139ba52cf9f33256c7d23972d0b2eaa55a7252e810d0cca1897ed5405bacd64b22b8eacd9636c938c39cf241051af1ae68b4d5a0e81595fffd8d1a61964
+  metadata.gz: 4780e0a1754d6b1df1562910bf63f1cf70b2d7c5750c1d04e6518898408eded1d13ced430564a966f3980fa1b5db0af131aba34db66de50ca0ec19cd4db1c827
+  data.tar.gz: a4a2dde579ad49d425a2e22e39907cf35041061d245b41c8cde6f1abd3c2abdcda1c0e3c28bafcbdfe6a2bf55eab5a5adc7e30750af5fcbb1739216d5c2708d6

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.4.0](https://github.com/seuros/imprimatur/compare/v0.3.0...v0.4.0) (2026-10-18)
+
+
+### Features
+
+* barcodes: QR Code, Data Matrix, EAN-13, EAN-8, UPC-A and Code 128, GS1 forms included, as SVG, PNG and in documents ([ade7b68](https://github.com/seuros/imprimatur/commit/ade7b68f4c5adcab9d2ee0b935288eea7ec2eea6))
+* **pdf:** add embedded TrueType font resources ([c0e3be4](https://github.com/seuros/imprimatur/commit/c0e3be4ef46ede94fcc840840e82d8ccb6679f3e))
+* **pdf:** add embedded TrueType font resources ([313075f](https://github.com/seuros/imprimatur/commit/313075fe8ba1bedc9f4156060aeedcbb0e0a8bef))
+
 ## [0.3.0](https://github.com/seuros/imprimatur/compare/v0.2.0...v0.3.0) (2026-10-17)
 
 

data/Cargo.lock

@@ -28,6 +28,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "arrayvec"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
+
 [[package]]
 name = "autocfg"
 version = "1.5.1"
@@ -168,6 +174,16 @@ dependencies = [
  "hybrid-array",
 ]
 
+[[package]]
+name = "datamatrix"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2d3882a013aca40e2e24f0e454ef7a581a50c603d67eded130013ab641a289d"
+dependencies = [
+ "arrayvec",
+ "flagset",
+]
+
 [[package]]
 name = "digest"
 version = "0.11.3"
@@ -207,6 +223,12 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
 
+[[package]]
+name = "flagset"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe"
+
 [[package]]
 name = "flate2"
 version = "1.1.10"
@@ -274,13 +296,15 @@ dependencies = [
 
 [[package]]
 name = "imprimatur"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "aes",
  "crc32fast",
+ "datamatrix",
  "font-test-data",
  "md-5",
  "miniz_oxide",
+ "qrcode",
  "read-fonts",
  "serde_json",
  "sha2",
@@ -291,7 +315,7 @@ dependencies = [
 
 [[package]]
 name = "imprimatur-cli"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "imprimatur",
  "regex",
@@ -303,7 +327,7 @@ dependencies = [
 
 [[package]]
 name = "imprimatur_native"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "imprimatur",
  "magnus",
@@ -501,6 +525,12 @@ dependencies = [
  "unicase",
 ]
 
+[[package]]
+name = "qrcode"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d68782463e408eb1e668cf6152704bd856c78c5b6417adaee3203d8f4c1fc9ec"
+
 [[package]]
 name = "quote"
 version = "1.0.47"

data/Cargo.toml

@@ -10,7 +10,7 @@ license = "BSD-3-Clause"
 repository = "https://github.com/seuros/imprimatur"
 
 [workspace.dependencies]
-imprimatur = { path = "ext/imprimatur_native/core", version = "0.3.0" }
+imprimatur = { path = "ext/imprimatur_native/core", version = "0.4.0" }
 magnus = { version = "0.9.2", default-features = false }
 # For rb_thread_call_without_gvl2, which magnus does not wrap; magnus's own
 # rb-sys, features and all.

data/README.md

@@ -9,7 +9,8 @@ a 40,000-character cell is refused at the door, not discovered by Excel's
   as `imprimatur` on crates.io; the gem wraps it.
 - **No third-party format stack.** The XML writer and the zip container are
   written here, from ECMA-376 and the zip specification; only deflate
-  (`miniz_oxide`) and CRC-32 (`crc32fast`) come from crates.
+  (`miniz_oxide`) and CRC-32 (`crc32fast`) come from crates, and QR Code and
+  Data Matrix encoding (`qrcode`, `datamatrix`) for barcodes.
 - **Deterministic.** The same document always gives the same bytes.
 - **Native only.** CRuby 4.0+. No pure Ruby fallback, no JRuby, no TruffleRuby.
 
@@ -223,6 +224,45 @@ dashes, the euro sign. Anything else (Arabic, Hebrew, Greek, CJK, emoji) raises
 script. Embedded TrueType fonts, and with them every script and proper RTL in
 PDF, are the next step.
 
+## Barcodes
+
+QR Code, 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):
+
+```ruby
+qr = Imprimatur.barcode(:qr, "https://id.gs1.org/01/09506000134352", level: :m)
+File.write("qr.svg", qr.svg(module_size: 4))
+File.binwrite("qr.png", qr.png(module_size: 8, background: nil)) # transparent
+
+ean = Imprimatur.barcode(:ean13, "950600013435")
+ean.text # => "9506000134352", the check digit added (or checked when given)
+
+label = Imprimatur.barcode(:code128, "(00)106141412345678908", gs1: true)  # GS1-128
+dpp = Imprimatur.barcode(:datamatrix, "(01)09506000134352(21)ABC123", gs1: true)
+
+Imprimatur.pdf("label.pdf", page_size: [300, 200], margin: 10) do |doc|
+  doc.barcode label, width: 280
+  doc.barcode dpp, width: 72, align: :right
+end
+```
+
+- `:qr` (`level:` `:l`, `:m`, `:q` or `:h`), `:datamatrix` (square),
+  `:ean13`, `:ean8`, `:upca` and `:code128`; `gs1: true` for the GS1 forms of
+  `:qr`, `:datamatrix` and `:code128`.
+- GS1 element strings are written as people write them, AIs in parentheses,
+  and checked: AI syntax, GS1's character set, the AIs whose lengths are
+  predefined, and the check digits of SSCCs, GTINs and GLNs. Separators go in
+  only where a variable-length field needs one.
+- `svg` and `png` take `module_size:`, `color:`, `background:` (nil for
+  none), `quiet_zone:` and, for linear codes, `bar_height:` in modules. PNGs
+  are one bit a pixel.
+- In documents, barcodes are vector shapes in a PDF and a 300 dpi picture in
+  DOCX, at `width:` or `height:` points or else at their usual module size
+  (0.33 mm for EAN and UPC, 0.495 mm for GS1-128, 0.7 mm for QR Code and Data
+  Matrix), quiet zone included.
+- `text`, `symbology`, `gs1?`, `width`, `height` (in modules), and `modules`
+  (rows of booleans) for drawing them some other way.
+
 ## Reading: documents as Markdown
 
 The other direction: a PDF, a workbook (XLSX, legacy XLS, ODS) or a DOCX

data/ext/imprimatur_native/cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imprimatur-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "Read PDF, XLSX, XLS, ODS and DOCX documents as Markdown or JSON, search them, extract their images."
 keywords = ["pdf", "xlsx", "docx", "markdown", "cli"]
 categories = ["command-line-utilities", "text-processing"]
@@ -10,6 +10,8 @@ rust-version.workspace = true
 authors.workspace = true
 license.workspace = true
 repository.workspace = true
+# Tests and their fixtures build nothing a published crate needs.
+exclude = ["tests/**", "src/**/tests.rs"]
 
 [[bin]]
 name = "imprimatur"

data/ext/imprimatur_native/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imprimatur"
-version = "0.3.0"
+version = "0.4.0"
 description = "XLSX, PDF and DOCX authoring, and PDF, XLSX, XLS, ODS and DOCX reading, with its own XML, zip and PDF code."
 keywords = ["xlsx", "excel", "pdf", "docx", "spreadsheet"]
 categories = ["encoding", "text-processing"]
@@ -10,7 +10,16 @@ rust-version.workspace = true
 authors.workspace = true
 license.workspace = true
 repository.workspace = true
-include = ["src/**/*.rs", "src/**/*.txt", "src/**/tests/*.pdf", "src/**/tests/*.xml", "src/**/tests/*.rels", "README.md", "LICENSE*"]
+include = [
+  "src/**/*.rs",
+  "src/**/*.txt",
+  "README.md",
+  "LICENSE*",
+  # Tests and their fixtures build nothing a published crate needs.
+  "!src/**/tests.rs",
+  "!src/**/tests/**",
+  "!src/**/test_support.rs",
+]
 
 [lints]
 workspace = true
@@ -18,10 +27,12 @@ workspace = true
 [dependencies]
 aes = "0.9.3"
 crc32fast = "1.5.2"
+datamatrix = "0.3.3"
 md-5 = "0.11.0"
 miniz_oxide = "0.9.1"
+qrcode = { version = "0.14.1", default-features = false }
 read-fonts = { version = "0.45.1", optional = true }
-serde_json = { version = "1.0.154", optional = true }
+serde_json = { workspace = true, optional = true }
 sha2 = "0.11.1"
 thiserror = "2.0.21"
 zip = { version = "9.0.3", default-features = false, features = ["deflate-flate2-zlib-rs"], optional = true }
@@ -39,5 +50,5 @@ fonts = ["dep:read-fonts"]
 
 [dev-dependencies]
 font-test-data = "0.10.0"
-tempfile = "3"
+tempfile.workspace = true
 zip = { version = "9.0.3", default-features = false, features = ["deflate-flate2-zlib-rs"] }

data/ext/imprimatur_native/core/README.md

@@ -50,6 +50,20 @@ sheet.add_validation("A2:A1000".parse()?, short)?;
 # Ok::<(), imprimatur::Error>(())
 ```
 
+```rust
+use imprimatur::barcode::{Barcode, Level, Look};
+use imprimatur::doc::{Document, Symbol};
+
+let qr = Barcode::qr("https://id.gs1.org/01/09506000134352", Level::Medium)?;
+let svg = qr.svg(4.0, &Look::default())?; // or png(scale, &look)
+let label = Barcode::gs1_128("(00)106141412345678908")?; // GS1 element strings, checked
+let mut doc = Document::new();
+doc.barcode(Symbol::new(label).width(250.0)?); // vector shapes in PDF
+doc.barcode(Barcode::ean13("950600013435")?); // the check digit, added
+let pdf = doc.to_pdf()?;
+# Ok::<(), imprimatur::Error>(())
+```
+
 Everything Excel would refuse is an `Error` before a byte is written: invalid
 or duplicate sheet names, positions beyond 1,048,576 rows or 16,384 columns,
 text over 32,767 characters, formulas over 8,192, NaN and infinity, font
@@ -101,12 +115,21 @@ With the `fonts` feature, `font::TrueTypeFont::from_bytes` loads borrowed
 static TrueType data and exposes Unicode glyph IDs, horizontal advances and
 raw `hhea` line metrics in font units. It checks the required tables and
 outline offsets, but is not a full font sanitizer. Collections, WOFF, CFF and
-variable fonts are not supported. This is a Rust font-data API only: document
-font selection, PDF embedding, shaping and bidirectional layout are not
-implemented by it; PDF writing still uses Helvetica.
+variable fonts are not supported. This is a Rust font-data API only. The
+internal PDF writer can serialize TrueType font resources with every glyph
+and Unicode text mappings; document font selection, shaping and bidirectional
+layout still need to connect to them. Document PDF output uses Helvetica.
+
+Barcodes: QR Code and Data Matrix (their GS1 forms too), EAN-13, EAN-8, UPC-A,
+Code 128 and GS1-128, drawn as SVG, as PNG, or into a document (shapes in a
+PDF, a 300 dpi picture in DOCX). GS1 element strings are checked: AI syntax,
+GS1's character set, predefined lengths, and the check digits of SSCCs, GTINs
+and GLNs.
 
 Dependencies: `miniz_oxide`, `crc32fast` and `thiserror`; reading encrypted
-PDFs adds `md-5`, `sha2` and `aes`.
+PDFs adds `md-5`, `sha2` and `aes`; barcodes add `qrcode` and `datamatrix`
+(for their error correction and placement; the linear codes, GS1 and the
+drawing are ours).
 
 Three features add what the core does not need: `json` (`read::json`, the
 schema the command line and the Ruby gem print, through `serde_json`),

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

@@ -0,0 +1,162 @@
+//! Code 128 (ISO/IEC 15417): ASCII in code sets A (controls, upper case)
+//! and B (upper and lower case), and pairs of digits in set C, switching
+//! as Annex E says; FNC1 first makes it GS1-128.
+
+use super::Symbology;
+use super::gs1::Unit;
+use crate::Result;
+
+/// Each symbol's bar and space widths, a bar first: values 0 to 102, then
+/// Start A, B and C (103 to 105).
+const PATTERNS: [&[u8; 6]; 106] = [
+    b"212222", b"222122", b"222221", b"121223", b"121322", b"131222", b"122213", b"122312",
+    b"132212", b"221213", b"221312", b"231212", b"112232", b"122132", b"122231", b"113222",
+    b"123122", b"123221", b"223211", b"221132", b"221231", b"213212", b"223112", b"312131",
+    b"311222", b"321122", b"321221", b"312212", b"322112", b"322211", b"212123", b"212321",
+    b"232121", b"111323", b"131123", b"131321", b"112313", b"132113", b"132311", b"211313",
+    b"231113", b"231311", b"112133", b"112331", b"132131", b"113123", b"113321", b"133121",
+    b"313121", b"211331", b"231131", b"213113", b"213311", b"213131", b"311123", b"311321",
+    b"331121", b"312113", b"312311", b"332111", b"314111", b"221411", b"431111", b"111224",
+    b"111422", b"121124", b"121421", b"141122", b"141221", b"112214", b"112412", b"122114",
+    b"122411", b"142112", b"142211", b"241211", b"221114", b"413111", b"241112", b"134111",
+    b"111242", b"121142", b"121241", b"114212", b"124112", b"124211", b"411212", b"421112",
+    b"421211", b"212141", b"214121", b"412121", b"111143", b"111341", b"131141", b"114113",
+    b"114311", b"411113", b"411311", b"113141", b"114131", b"311141", b"411131", b"211412",
+    b"211214", b"211232",
+];
+const STOP: &[u8; 7] = b"2331112";
+const CODE_C: u8 = 99;
+const CODE_B: u8 = 100;
+const CODE_A: u8 = 101;
+const FNC1: u8 = 102;
+const START_A: u8 = 103;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Set {
+    A,
+    B,
+    C,
+}
+
+/// The modules of `units`: start, data, check symbol, stop.
+pub fn encode(units: &[Unit]) -> Result<Vec<bool>> {
+    if let Some(byte) = units.iter().find_map(|unit| match unit {
+        Unit::Char(byte) if !byte.is_ascii() => Some(*byte),
+        _ => None,
+    }) {
+        let reason = format!("it holds ASCII only, not byte 0x{byte:02X}");
+        return Err(Symbology::Code128.invalid(reason));
+    }
+    let mut set = start(units);
+    let mut values = vec![START_A + set as u8];
+    let mut at = 0;
+    while let Some(&unit) = units.get(at) {
+        match (set, unit) {
+            (_, Unit::Fnc1) => {
+                values.push(FNC1);
+                at += 1;
+            }
+            (Set::C, Unit::Char(_)) => {
+                if let Some(pair) = digit_pair(units, at) {
+                    values.push(pair);
+                    at += 2;
+                } else {
+                    set = text_set(units, at);
+                    values.push(code_symbol(set));
+                }
+            }
+            (Set::A | Set::B, Unit::Char(byte)) => {
+                // Annex E: four digits or more go to set C, the first of an
+                // odd run first.
+                let run = digit_run(units, at);
+                if run >= 4 && run.is_multiple_of(2) {
+                    set = Set::C;
+                    values.push(CODE_C);
+                    continue;
+                }
+                if !encodable(set, byte) {
+                    set = if set == Set::A { Set::B } else { Set::A };
+                    values.push(code_symbol(set));
+                }
+                values.push(value(set, byte));
+                at += 1;
+            }
+        }
+    }
+    let weighted: u32 = values
+        .iter()
+        .zip(0_u32..)
+        .map(|(&value, position)| u32::from(value) * position.max(1))
+        .sum();
+    values.push(u8::try_from(weighted % 103).unwrap_or_default());
+
+    let mut modules = Vec::with_capacity(values.len() * 11 + 13);
+    for value in values {
+        widths(&mut modules, PATTERNS[usize::from(value)]);
+    }
+    widths(&mut modules, STOP);
+    Ok(modules)
+}
+
+/// Set C when the data, past a leading FNC1, opens with four digits or more
+/// (or is an even number of digits); else as [`text_set`].
+fn start(units: &[Unit]) -> Set {
+    let first = units.iter().position(|unit| *unit != Unit::Fnc1).unwrap_or(units.len());
+    let run = digit_run(units, first);
+    let all_digits = first + run == units.len() && run.is_multiple_of(2) && run > 0;
+    if run >= 4 || all_digits { Set::C } else { text_set(units, first) }
+}
+
+/// Set A when a control character comes before any lower case letter, else
+/// set B.
+fn text_set(units: &[Unit], from: usize) -> Set {
+    let first = units[from..].iter().find_map(|unit| match unit {
+        Unit::Char(byte) if *byte < 32 => Some(Set::A),
+        Unit::Char(byte) if *byte >= 96 => Some(Set::B),
+        _ => None,
+    });
+    first.unwrap_or(Set::B)
+}
+
+fn digit_run(units: &[Unit], from: usize) -> usize {
+    let digit = |unit: &&Unit| matches!(unit, Unit::Char(byte) if byte.is_ascii_digit());
+    units.get(from..).map_or(0, |rest| rest.iter().take_while(digit).count())
+}
+
+fn digit_pair(units: &[Unit], at: usize) -> Option<u8> {
+    match units.get(at..at + 2)? {
+        [Unit::Char(tens), Unit::Char(ones)] if tens.is_ascii_digit() && ones.is_ascii_digit() => {
+            Some((tens - b'0') * 10 + (ones - b'0'))
+        }
+        _ => None,
+    }
+}
+
+/// The symbol that switches into set A or B (sets are otherwise only
+/// entered from set C, by [`CODE_C`]).
+const fn code_symbol(set: Set) -> u8 {
+    if matches!(set, Set::A) { CODE_A } else { CODE_B }
+}
+
+const fn encodable(set: Set, byte: u8) -> bool {
+    match set {
+        Set::A => byte < 96,
+        Set::B | Set::C => byte >= 32,
+    }
+}
+
+/// A character's value in set A or B.
+const fn value(set: Set, byte: u8) -> u8 {
+    match set {
+        Set::A if byte < 32 => byte + 64,
+        _ => byte - 32,
+    }
+}
+
+/// Bars and spaces of these widths, a bar first.
+fn widths(modules: &mut Vec<bool>, widths: &[u8]) {
+    for (index, width) in widths.iter().enumerate() {
+        let bar = index % 2 == 0;
+        modules.extend(std::iter::repeat_n(bar, usize::from(width - b'0')));
+    }
+}

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

@@ -0,0 +1,124 @@
+//! A symbol as rectangles in module units, and those as SVG or PNG; PDF
+//! draws the same rectangles.
+
+use std::fmt::Write as _;
+
+use super::{Barcode, Look};
+use crate::read::{PngColor, png_with_transparency};
+
+/// The largest side, in pixels, a PNG may have, as pictures.
+const MAX_PIXELS: usize = 1 << 16;
+
+/// A symbol in module units: its whole width and height, quiet zone
+/// included, and its dark rectangles `[x, y, width, height]` from the top
+/// left. Each row's runs are one rectangle; a linear code's bars span its
+/// height.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Shapes {
+    pub width: usize,
+    pub height: usize,
+    pub rects: Vec<[usize; 4]>,
+}
+
+impl Shapes {
+    /// Its width and height in modules, for scaling.
+    #[expect(clippy::cast_precision_loss, reason = "a symbol is far below 2**52 modules")]
+    pub const fn extent(&self) -> (f64, f64) {
+        (self.width as f64, self.height as f64)
+    }
+}
+
+impl Barcode {
+    pub(crate) fn shapes(&self, quiet_zone: bool, bar_height: Option<u32>) -> Shapes {
+        let (left, right, edge) = if quiet_zone { self.symbology.quiet_zone() } else { (0, 0, 0) };
+        let row_height = if self.symbology.is_linear() {
+            bar_height.map_or_else(|| self.default_bar_height(), |bars| bars.max(1) as usize)
+        } else {
+            1
+        };
+        let mut rects = Vec::new();
+        for (y, row) in self.modules.chunks(self.columns).enumerate() {
+            let mut x = 0;
+            while x < row.len() {
+                let run = row[x..].iter().take_while(|&&dark| dark == row[x]).count();
+                if row[x] {
+                    rects.push([left + x, edge + y * row_height, run, row_height]);
+                }
+                x += run;
+            }
+        }
+        Shapes {
+            width: left + self.columns + right,
+            height: 2 * edge + self.rows * row_height,
+            rects,
+        }
+    }
+}
+
+/// `module` user units a module, the rectangles as one path.
+pub fn svg(shapes: &Shapes, module: f64, look: &Look) -> String {
+    let (width, height) = (shapes.width, shapes.height);
+    let (columns, rows) = shapes.extent();
+    let (pixels_wide, pixels_high) = (number(columns * module), number(rows * module));
+    let mut out = format!(
+        "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"{pixels_wide}\" \
+         height=\"{pixels_high}\" viewBox=\"0 0 {width} {height}\" \
+         shape-rendering=\"crispEdges\">"
+    );
+    if let Some(light) = look.light {
+        let fill = light.hex();
+        // write! into a String cannot fail.
+        let _ = write!(out, "<rect width=\"{width}\" height=\"{height}\" fill=\"{fill}\"/>");
+    }
+    // write! into a String cannot fail.
+    let _ = write!(out, "<path fill=\"{}\" d=\"", look.dark.hex());
+    for [x, y, run, rows] in &shapes.rects {
+        // write! into a String cannot fail.
+        let _ = write!(out, "M{x} {y}h{run}v{rows}h-{run}z");
+    }
+    out.push_str("\"/></svg>");
+    out
+}
+
+/// `scale` pixels a module, one bit a pixel: palette entry 0 the light
+/// color (transparent without one), 1 the dark. `None` past
+/// [`MAX_PIXELS`] or at a scale of 0.
+pub fn png(shapes: &Shapes, scale: u32, look: &Look) -> Option<Vec<u8>> {
+    let (pixels_wide, pixels_high, rows) = bits(shapes, scale)?;
+    let light = look.light.unwrap_or(crate::style::Color::WHITE).bytes();
+    let palette = [light, look.dark.bytes()].concat();
+    let transparency: &[u8] = if look.light.is_none() { &[0] } else { &[] };
+    let (width, height) = (u32::try_from(pixels_wide).ok()?, u32::try_from(pixels_high).ok()?);
+    Some(png_with_transparency(
+        width,
+        height,
+        PngColor::Palette,
+        1,
+        Some(&palette),
+        transparency,
+        &rows,
+    ))
+}
+
+/// The pixels, one bit each, rows starting on a byte: width, height, rows.
+fn bits(shapes: &Shapes, scale: u32) -> Option<(usize, usize, Vec<u8>)> {
+    let scale = usize::try_from(scale).ok().filter(|&scale| scale > 0)?;
+    let (width, height) = (shapes.width * scale, shapes.height * scale);
+    (width <= MAX_PIXELS && height <= MAX_PIXELS).then_some(())?;
+    let stride = width.div_ceil(8);
+    let mut rows = vec![0_u8; stride * height];
+    for &[x, y, run, run_rows] in &shapes.rects {
+        for row in y * scale..(y + run_rows) * scale {
+            for pixel in x * scale..(x + run) * scale {
+                rows[row * stride + pixel / 8] |= 0x80 >> (pixel % 8);
+            }
+        }
+    }
+    Some((width, height, rows))
+}
+
+/// Up to three decimals, without trailing zeros.
+fn number(value: f64) -> String {
+    let text = format!("{value:.3}");
+    text.trim_end_matches('0').trim_end_matches('.').to_owned()
+}

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

@@ -0,0 +1,91 @@
+//! EAN-13, EAN-8 and UPC-A (ISO/IEC 15420): GTINs as retail scanners read
+//! them, digits in seven-module patterns between guard bars.
+
+use super::Symbology;
+use super::gs1::check_digit;
+use crate::Result;
+
+/// The left-hand, odd-parity patterns (set A) of 0 to 9. The right-hand
+/// patterns (set C) are their inverses; the even-parity ones (set B), the
+/// right-hand ones mirrored.
+const SET_A: [u8; 10] = [
+    0b000_1101, 0b001_1001, 0b001_0011, 0b011_1101, 0b010_0011, 0b011_0001, 0b010_1111, 0b011_1011,
+    0b011_0111, 0b000_1011,
+];
+/// Which of EAN-13's left six digits take set B, the first in the high
+/// bit, by its leading digit (the one no pattern draws).
+const PARITY: [u8; 10] = [
+    0b00_0000, 0b00_1011, 0b00_1101, 0b00_1110, 0b01_0011, 0b01_1001, 0b01_1100, 0b01_0101,
+    0b01_0110, 0b01_1010,
+];
+const GUARD: [bool; 3] = [true, false, true];
+const CENTER: [bool; 5] = [false, true, false, true, false];
+
+/// `input` as digits: one short of `length` gets its check digit, `length`
+/// must end with the right one.
+pub fn digits(symbology: Symbology, input: &str, length: usize) -> Result<Vec<u8>> {
+    input
+        .bytes()
+        .all(|byte| byte.is_ascii_digit())
+        .ok_or_else(|| symbology.invalid(format!("{input:?} is not all digits")))?;
+    (input.len() == length - 1 || input.len() == length).ok_or_else(|| {
+        let (short, given) = (length - 1, input.len());
+        symbology.invalid(format!(
+            "it takes {short} digits, or {length} with the check digit, not {given}"
+        ))
+    })?;
+    let check = check_digit(&input[..length - 1]).unwrap_or_default();
+    let mut digits: Vec<u8> = input.bytes().map(|byte| byte - b'0').collect();
+    match digits.get(length - 1) {
+        None => digits.push(check),
+        Some(&last) if last != check => {
+            return Err(symbology.invalid(format!("{input} has check digit {last}, not {check}")));
+        }
+        Some(_) => {}
+    }
+    Ok(digits)
+}
+
+pub fn text(digits: &[u8]) -> String {
+    digits.iter().map(|digit| char::from(b'0' + digit)).collect()
+}
+
+/// 95 modules: guard, six left digits by the first's parity, center, six
+/// right digits, guard.
+pub fn ean13(digits: &[u8]) -> Vec<bool> {
+    let parity = PARITY[usize::from(digits[0])];
+    let mut modules = Vec::with_capacity(95);
+    modules.extend(GUARD);
+    for (index, &digit) in digits[1..7].iter().enumerate() {
+        let even = (parity >> (5 - index)) & 1 == 1;
+        push(&mut modules, if even { set_b(digit) } else { SET_A[usize::from(digit)] });
+    }
+    modules.extend(CENTER);
+    digits[7..].iter().for_each(|&digit| push(&mut modules, set_c(digit)));
+    modules.extend(GUARD);
+    modules
+}
+
+/// 67 modules: guard, four digits in set A, center, four in set C, guard.
+pub fn ean8(digits: &[u8]) -> Vec<bool> {
+    let mut modules = Vec::with_capacity(67);
+    modules.extend(GUARD);
+    digits[..4].iter().for_each(|&digit| push(&mut modules, SET_A[usize::from(digit)]));
+    modules.extend(CENTER);
+    digits[4..].iter().for_each(|&digit| push(&mut modules, set_c(digit)));
+    modules.extend(GUARD);
+    modules
+}
+
+const fn set_c(digit: u8) -> u8 {
+    !SET_A[digit as usize] & 0x7F
+}
+
+const fn set_b(digit: u8) -> u8 {
+    set_c(digit).reverse_bits() >> 1
+}
+
+/// A seven-module pattern, its high bit first.
+fn push(modules: &mut Vec<bool>, pattern: u8) {
+    modules.extend((0..7).rev().map(|bit| (pattern >> bit) & 1 == 1));
+}