imprimatur 0.2.0 → 0.4.0

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

@@ -32,6 +32,7 @@ use ::zip::result::ZipError;
 use ::zip::write::FullFileOptions;
 use ::zip::{CompressionMethod, DateTime, ZipArchive, ZipWriter};
 
+use crate::xlsx::civil_from_days;
 use crate::{Error, Result};
 
 /// An archive being written; [`finish`](Self::finish) writes its directory.
@@ -129,9 +130,10 @@ fn dos_time(time: Option<SystemTime>) -> DateTime {
         return DateTime::default();
     };
     let days = i64::try_from(seconds / 86_400).unwrap_or(i64::MAX);
-    let (year, month, day) = civil(days);
+    let (year, month, day) = civil_from_days(days);
     let clock = seconds % 86_400;
     let part = |value: u64| u8::try_from(value).unwrap_or(0);
+    let (month, day) = (u8::try_from(month).unwrap_or(1), u8::try_from(day).unwrap_or(1));
     u16::try_from(year)
         .ok()
         .and_then(|year| {
@@ -148,21 +150,6 @@ fn dos_time(time: Option<SystemTime>) -> DateTime {
         .unwrap_or_default()
 }
 
-/// Days since 1970-01-01 as a proleptic Gregorian date (Howard Hinnant's
-/// `civil_from_days`).
-fn civil(days: i64) -> (i64, u8, u8) {
-    let days = days + 719_468;
-    let era = days.div_euclid(146_097);
-    let of_era = days.rem_euclid(146_097);
-    let year_of_era = (of_era - of_era / 1460 + of_era / 36_524 - of_era / 146_096) / 365;
-    let of_year = of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
-    let shifted = (5 * of_year + 2) / 153;
-    let day = u8::try_from(of_year - (153 * shifted + 2) / 5 + 1).unwrap_or(1);
-    let month = u8::try_from(if shifted < 10 { shifted + 3 } else { shifted - 9 }).unwrap_or(1);
-    let year = year_of_era + era * 400 + i64::from(month <= 2);
-    (year, month, day)
-}
-
 /// What the archive's directory says of an entry.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Entry {

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));
+}

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

@@ -0,0 +1,188 @@
+//! GS1 element strings as people write them, `(01)09506000134352(10)AB12`:
+//! Application Identifiers in parentheses, each followed by its value.
+
+#[cfg(test)]
+mod tests;
+
+use crate::{Error, Result};
+
+/// What a symbol carries: characters, and FNC1, which ends every
+/// variable-length field but the last.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Unit {
+    Char(u8),
+    Fnc1,
+}
+
+/// One Application Identifier and its value.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Field<'a> {
+    pub ai: &'a str,
+    pub value: &'a str,
+}
+
+/// Element strings whose length, AI included, the AI's first two digits
+/// fix (GS1 General Specifications, figure 7.8.5-2). All are numeric; the
+/// rest end with FNC1 unless last.
+const PREDEFINED: [(&str, usize); 22] = [
+    ("00", 20),
+    ("01", 16),
+    ("02", 16),
+    ("03", 16),
+    ("04", 18),
+    ("11", 8),
+    ("12", 8),
+    ("13", 8),
+    ("14", 8),
+    ("15", 8),
+    ("16", 8),
+    ("17", 8),
+    ("18", 8),
+    ("19", 8),
+    ("20", 4),
+    ("31", 10),
+    ("32", 10),
+    ("33", 10),
+    ("34", 10),
+    ("35", 10),
+    ("36", 10),
+    ("41", 16),
+];
+
+/// The longest value any AI takes.
+const MAX_VALUE: usize = 90;
+
+/// The GS1 check digit (modulo 10, weights 3 and 1 from the right) of
+/// `digits`, as GTINs, SSCCs and GLNs end with; `None` unless all are
+/// digits.
+///
+/// ```
+/// assert_eq!(imprimatur::barcode::check_digit("950600013435"), Some(2));
+/// ```
+#[must_use]
+pub fn check_digit(digits: &str) -> Option<u8> {
+    let mut sum = 0_u32;
+    for (index, byte) in digits.bytes().rev().enumerate() {
+        byte.is_ascii_digit().then_some(())?;
+        let weight = if index % 2 == 0 { 3 } else { 1 };
+        sum += weight * u32::from(byte - b'0');
+    }
+    u8::try_from((10 - sum % 10) % 10).ok()
+}
+
+/// Reads an element string into its fields.
+///
+/// # Errors
+/// [`Error::InvalidElementString`] for anything but AIs of 2 to 4 digits in
+/// parentheses, each with a value in GS1's character set, of the length
+/// and check digit its AI takes.
+pub fn parse(input: &str) -> Result<Vec<Field<'_>>> {
+    let invalid = |reason: String| Error::InvalidElementString(reason);
+    let bytes = input.as_bytes();
+    (!bytes.is_empty()).ok_or_else(|| invalid("it is empty".to_owned()))?;
+    let mut fields = Vec::new();
+    let mut at = 0;
+    while at < bytes.len() {
+        let length = ai_at(bytes, at).ok_or_else(|| {
+            invalid(format!("expected an AI such as (01) at character {}", at + 1))
+        })?;
+        let start = at + length + 2;
+        let end = (start..bytes.len()).find(|&next| ai_at(bytes, next).is_some());
+        let end = end.unwrap_or(bytes.len());
+        let field = Field { ai: &input[at + 1..at + 1 + length], value: &input[start..end] };
+        validate(field)?;
+        fields.push(field);
+        at = end;
+    }
+    Ok(fields)
+}
+
+/// `element_string`, parsed and run together as [`units`] does: what every
+/// encoder needs before laying its symbol out.
+///
+/// # Errors
+/// [`Error::InvalidElementString`], as [`parse`].
+pub fn element_units(element_string: &str) -> Result<Vec<Unit>> {
+    Ok(units(&parse(element_string)?))
+}
+
+/// The fields run together: no parentheses, FNC1 after each field of
+/// variable length but the last.
+pub fn units(fields: &[Field<'_>]) -> Vec<Unit> {
+    let mut units = Vec::new();
+    for (index, field) in fields.iter().enumerate() {
+        units.extend(field.ai.bytes().chain(field.value.bytes()).map(Unit::Char));
+        if predefined(field.ai).is_none() && index + 1 < fields.len() {
+            units.push(Unit::Fnc1);
+        }
+    }
+    units
+}
+
+/// The length of the AI in parentheses at `at`: 2 to 4 digits.
+fn ai_at(bytes: &[u8], at: usize) -> Option<usize> {
+    (bytes.get(at) == Some(&b'(')).then_some(())?;
+    let digits = bytes[at + 1..].iter().take_while(|byte| byte.is_ascii_digit()).count();
+    ((2..=4).contains(&digits) && bytes.get(at + 1 + digits) == Some(&b')')).then_some(digits)
+}
+
+/// The length of the element string, AI included, when the AI fixes it.
+fn predefined(ai: &str) -> Option<usize> {
+    PREDEFINED.iter().find(|(prefix, _)| ai.starts_with(prefix)).map(|&(_, length)| length)
+}
+
+fn validate(field: Field<'_>) -> Result<()> {
+    let Field { ai, value } = field;
+    let invalid = |reason: String| Err(Error::InvalidElementString(format!("({ai}) {reason}")));
+    if value.is_empty() {
+        return invalid("has no value".to_owned());
+    }
+    let outside = |character: char| !u8::try_from(character).is_ok_and(in_character_set);
+    if let Some(character) = value.chars().find(|&character| outside(character)) {
+        return invalid(format!("holds {character:?}, outside GS1's character set"));
+    }
+    if value.len() > MAX_VALUE {
+        return invalid(format!("holds {} characters, more than {MAX_VALUE}", value.len()));
+    }
+    let Some(length) = predefined(ai) else { return Ok(()) };
+    let digits = length - ai.len();
+    if value.len() != digits || !value.bytes().all(|byte| byte.is_ascii_digit()) {
+        return invalid(format!("takes {digits} digits, not {value:?}"));
+    }
+    // SSCC, GTINs and GLNs end with a check digit.
+    let checked = matches!(ai, "00" | "01" | "02") || ai.starts_with("41");
+    let (body, last) = value.split_at(value.len() - 1);
+    let expected = check_digit(body).unwrap_or(0);
+    if checked && last.as_bytes()[0] - b'0' != expected {
+        return invalid(format!("{value} has check digit {last}, not {expected}"));
+    }
+    Ok(())
+}
+
+/// GS1 AI encodable character set 82: letters, digits and
+/// ``!"%&'()*+,-./:;<=>?_``.
+const fn in_character_set(byte: u8) -> bool {
+    byte.is_ascii_alphanumeric()
+        || matches!(
+            byte,
+            b'!' | b'"'
+                | b'%'
+                | b'&'
+                | b'\''
+                | b'('
+                | b')'
+                | b'*'
+                | b'+'
+                | b','
+                | b'-'
+                | b'.'
+                | b'/'
+                | b':'
+                | b';'
+                | b'<'
+                | b'='
+                | b'>'
+                | b'?'
+                | b'_'
+        )
+}