imprimatur 0.3.0 → 0.4.0

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;

data/ext/imprimatur_native/core/src/pdf/layout.rs

@@ -8,7 +8,7 @@ use std::fmt::{self, Arguments, Write as _};
 
 use super::font::Face;
 use super::objects::{Num, push_string};
-use crate::doc::{Document, Paragraph, Picture, Table};
+use crate::doc::{Document, Paragraph, Picture, Symbol, Table};
 use crate::style::{Align, Color};
 use crate::{Error, Result};
 use wrap::{Line, Look, wrap};
@@ -129,20 +129,30 @@ impl Layout {
     /// Draws picture `index` (`/Im{index}`), on a new page when it does not
     /// fit, as its alignment says.
     pub fn picture(&mut self, picture: &Picture, index: usize) {
-        let room = (self.content_width(), (-2.0f64).mul_add(self.margin, self.height));
-        let (width, height) = picture.size(room);
-        self.ensure_room(height);
-        let x = self.margin
-            + match picture.align.unwrap_or(Align::Left) {
-                Align::Left => 0.0,
-                Align::Center => (room.0 - width) / 2.0,
-                Align::Right => room.0 - width,
-            };
-        self.y -= height;
-        let (width, height, x, y) = (Num(width), Num(height), Num(x), Num(self.y));
+        let (width, height) = picture.size(self.room());
+        let (x, y) = self.place((width, height), picture.align);
+        let (width, height, x, y) = (Num(width), Num(height), Num(x), Num(y));
         emit(self.current(), format_args!("q {width} 0 0 {height} {x} {y} cm /Im{index} Do Q\n"));
-        self.y -= PARAGRAPH_GAP;
-        self.blank = false;
+        self.end_figure();
+    }
+
+    /// Draws a barcode as filled rectangles, one module a unit, the
+    /// coordinates flipped to run down from its top left corner.
+    pub fn symbol(&mut self, symbol: &Symbol) {
+        let (shapes, (width, height)) = symbol.placed(self.room());
+        let (x, y) = self.place((width, height), symbol.align);
+        let (columns, rows) = shapes.extent();
+        let (across, down) = (width / columns, height / rows);
+        let (fill, top, x) = (Fill(symbol.color), Num(y + height), Num(x));
+        let page = self.current();
+        // Four decimals: a module's size in hundredths of a point would be
+        // off by up to half a percent across the symbol.
+        emit(page, format_args!("q {fill} {across:.4} 0 0 {:.4} {x} {top} cm\n", -down));
+        for [x, y, run, rows] in &shapes.rects {
+            emit(page, format_args!("{x} {y} {run} {rows} re\n"));
+        }
+        page.extend_from_slice(b"f Q\n");
+        self.end_figure();
     }
 
     pub fn page_break(&mut self) {
@@ -166,6 +176,30 @@ impl Layout {
         self.pages
     }
 
+    /// The width and height between the margins.
+    const fn room(&self) -> (f64, f64) {
+        (self.content_width(), (-2.0f64).mul_add(self.margin, self.height))
+    }
+
+    /// Makes room for a figure of `size`, on a new page when it does not
+    /// fit, and returns its bottom left corner as `align` places it.
+    fn place(&mut self, (width, height): (f64, f64), align: Option<Align>) -> (f64, f64) {
+        self.ensure_room(height);
+        let x = self.margin
+            + match align.unwrap_or(Align::Left) {
+                Align::Left => 0.0,
+                Align::Center => (self.content_width() - width) / 2.0,
+                Align::Right => self.content_width() - width,
+            };
+        self.y -= height;
+        (x, self.y)
+    }
+
+    fn end_figure(&mut self) {
+        self.y -= PARAGRAPH_GAP;
+        self.blank = false;
+    }
+
     /// Starts a new page unless `needed` points fit above the bottom margin
     /// (or the page is still blank, where nothing would fit better).
     /// Returns whether it did.

data/ext/imprimatur_native/core/src/pdf/truetype/descriptor.rs

@@ -0,0 +1,129 @@
+//! TrueType metadata needed by a PDF `FontDescriptor`, in 1000-unit glyph space.
+
+#[cfg(test)]
+mod tests;
+
+use std::io::Write;
+
+use read_fonts::{
+    FontRead, FontRef, TableProvider,
+    tables::{head::MacStyle, os2::Os2, post::Post},
+    types::{NameId, Tag},
+};
+
+use crate::font::{TrueTypeFont, invalid};
+use crate::pdf::objects::{Num, PdfWriter};
+use crate::{Error, Result};
+
+pub struct Descriptor {
+    /// PostScript name, escaped as a PDF name (without its leading slash).
+    pub name: String,
+    bounds: [Num; 4],
+    ascent: Num,
+    descent: Num,
+    cap_height: Num,
+    italic_angle: Num,
+    flags: u32,
+    stem: Num,
+}
+
+impl Descriptor {
+    pub fn read(font: &TrueTypeFont<'_>) -> Result<Self> {
+        let tables = FontRef::new(font.as_bytes()).map_err(invalid)?;
+        let head = tables.head().map_err(invalid)?;
+        let post =
+            tables.table_data(Tag::new(b"post")).map(Post::read).transpose().map_err(invalid)?;
+        let os2 =
+            tables.table_data(Tag::new(b"OS/2")).map(Os2::read).transpose().map_err(invalid)?;
+        if let Some(os2) = &os2 {
+            let rights = os2.fs_type();
+            // Older fonts can set several rights bits; the least restrictive wins.
+            (rights & 0x0002 == 0 || rights & 0x000C != 0)
+                .ok_or(Error::UnsupportedFont("restricted font embedding"))?;
+            (rights & 0x0200 == 0).ok_or(Error::UnsupportedFont("bitmap-only font embedding"))?;
+            // The no-subsetting bit is compatible with embedding the complete font.
+        }
+        (head.x_min() <= head.x_max() && head.y_min() <= head.y_max())
+            .ok_or_else(|| invalid("inverted font bounding box"))?;
+        let metrics = font.metrics();
+        let scale = 1000.0 / f64::from(metrics.units_per_em);
+        let cap_height = os2
+            .as_ref()
+            .and_then(Os2::s_cap_height)
+            .filter(|height| *height > 0)
+            .unwrap_or(metrics.ascender);
+        let angle = post.as_ref().map_or(0.0, |post| post.italic_angle().to_f64());
+        // Symbolic: Identity-H is a CID encoding, not the standard Latin encoding.
+        let mut flags = 4;
+        if post.as_ref().is_some_and(|post| post.is_fixed_pitch() != 0) {
+            flags |= 1;
+        }
+        if angle != 0.0 || head.mac_style().contains(MacStyle::ITALIC) {
+            flags |= 64;
+        }
+        let family = os2.as_ref().map_or(0, |os2| os2.s_family_class() >> 8);
+        if (1..=7).contains(&family) {
+            flags |= 2;
+        } else if family == 10 {
+            flags |= 8;
+        }
+        let weight = os2.as_ref().map_or(400, |os2| os2.us_weight_class().clamp(1, 1000));
+        let stem_weight = f64::from(weight) / 65.0;
+        Ok(Self {
+            name: postscript_name(&tables)?,
+            bounds: [head.x_min(), head.y_min(), head.x_max(), head.y_max()]
+                .map(|value| Num(f64::from(value) * scale)),
+            ascent: Num(f64::from(metrics.ascender) * scale),
+            descent: Num(f64::from(metrics.descender) * scale),
+            // Older OS/2 tables lack cap height; the ascender is an approximation.
+            cap_height: Num(f64::from(cap_height) * scale),
+            italic_angle: Num(angle),
+            flags,
+            // TrueType has no stem-width field: estimate it from the weight class.
+            stem: Num(stem_weight.mul_add(stem_weight, 50.0)),
+        })
+    }
+
+    pub fn write<W: Write>(&self, pdf: &mut PdfWriter<W>, id: usize, file: usize) -> Result<()> {
+        let Self { name, bounds, ascent, descent, cap_height, italic_angle, flags, stem } = self;
+        let [left, bottom, right, top] = bounds;
+        pdf.object(
+            id,
+            format_args!(
+                "<< /Type /FontDescriptor /FontName /{name} /Flags {flags} \
+                 /FontBBox [{left} {bottom} {right} {top}] /ItalicAngle {italic_angle} \
+                 /Ascent {ascent} /Descent {descent} /CapHeight {cap_height} \
+                 /StemV {stem} /FontFile2 {file} 0 R >>"
+            ),
+        )
+    }
+}
+
+fn postscript_name(font: &FontRef<'_>) -> Result<String> {
+    let names = font.name().map_err(invalid)?;
+    for platform in [3, 0, 1] {
+        for record in names.name_record() {
+            if record.name_id() != NameId::POSTSCRIPT_NAME || record.platform_id() != platform {
+                continue;
+            }
+            if !(record.is_unicode() || platform == 1 && record.encoding_id() == 0) {
+                continue;
+            }
+            if record.is_unicode() && !record.length().is_multiple_of(2) {
+                return Err(invalid("odd UTF-16 PostScript name length"));
+            }
+            let name = record.string(names.string_data()).map_err(invalid)?.to_string();
+            // OpenType name ID 6: 1..63 printable ASCII characters, excluding
+            // PostScript delimiters. '#' is legal there but needs escaping in PDF.
+            if !name.is_empty()
+                && name.len() <= 63
+                && name
+                    .bytes()
+                    .all(|byte| (33..=126).contains(&byte) && !b"[](){}<>/%".contains(&byte))
+            {
+                return Ok(name.replace('#', "#23"));
+            }
+        }
+    }
+    Err(Error::UnsupportedFont("no usable PostScript font name"))
+}

data/ext/imprimatur_native/core/src/pdf/truetype/program.rs

@@ -0,0 +1,70 @@
+//! A `CIDFont`'s TrueType program retains every glyph but omits the cmap table
+//! (ISO 32000-1, 9.9). Rebuild the sfnt directory, padding and checksums; glyph
+//! outlines, IDs, metrics and hinting tables are unchanged.
+
+#[cfg(test)]
+mod tests;
+
+use read_fonts::{FontRef, TableRecord, types::Tag};
+
+use crate::Result;
+use crate::font::{TrueTypeFont, invalid};
+
+pub fn for_pdf(font: &TrueTypeFont<'_>) -> Result<Vec<u8>> {
+    let source = FontRef::new(font.as_bytes()).map_err(invalid)?;
+    let mut tags: Vec<_> = source
+        .table_directory()
+        .table_records()
+        .iter()
+        .map(TableRecord::tag)
+        // Rewriting the directory also invalidates any digital signature.
+        .filter(|tag| *tag != Tag::new(b"cmap") && *tag != Tag::new(b"DSIG"))
+        .collect();
+    tags.sort_unstable();
+    (!tags.windows(2).any(|pair| pair[0] == pair[1]))
+        .ok_or_else(|| invalid("duplicate sfnt tables"))?;
+    let count = u16::try_from(tags.len()).map_err(invalid)?;
+    // searchRange and rangeShift are byte counts in 16-bit fields.
+    (count > 0 && count <= 4095).ok_or_else(|| invalid("sfnt table count out of range"))?;
+    let selector = u16::try_from(count.ilog2()).map_err(invalid)?;
+    let range = (1_u16 << selector) * 16;
+    let mut data = Vec::with_capacity(font.as_bytes().len());
+    data.extend_from_slice(&font.as_bytes()[..4]);
+    for value in [count, range, selector, count * 16 - range] {
+        data.extend_from_slice(&value.to_be_bytes());
+    }
+    data.resize(12 + 16 * tags.len(), 0);
+    let mut head = None;
+    for (index, tag) in tags.into_iter().enumerate() {
+        let table = source.table_data(tag).ok_or_else(|| invalid("missing sfnt table"))?;
+        let start = data.len();
+        let offset = u32::try_from(start).map_err(invalid)?;
+        let length = u32::try_from(table.len()).map_err(invalid)?;
+        data.extend_from_slice(table.as_bytes());
+        if tag == Tag::new(b"head") {
+            // head's own checksum is calculated with checkSumAdjustment zero.
+            data[start + 8..start + 12].fill(0);
+            head = Some(start);
+        }
+        let sum = checksum(&data[start..]);
+        data.resize(data.len().next_multiple_of(4), 0);
+        let record = 12 + 16 * index;
+        data[record..record + 4].copy_from_slice(&tag.to_be_bytes());
+        for (field, value) in [sum, offset, length].into_iter().enumerate() {
+            let field = record + 4 * (field + 1);
+            data[field..field + 4].copy_from_slice(&value.to_be_bytes());
+        }
+    }
+    let head = head.ok_or_else(|| invalid("missing head table"))?;
+    let adjustment = 0xB1B0_AFBA_u32.wrapping_sub(checksum(&data));
+    data[head + 8..head + 12].copy_from_slice(&adjustment.to_be_bytes());
+    Ok(data)
+}
+
+fn checksum(data: &[u8]) -> u32 {
+    data.chunks(4).fold(0_u32, |sum, bytes| {
+        let mut word = [0; 4];
+        word[..bytes.len()].copy_from_slice(bytes);
+        sum.wrapping_add(u32::from_be_bytes(word))
+    })
+}