imprimatur 0.3.0 → 0.5.0

data/ext/imprimatur_native/ffi/src/document.rs

@@ -2,10 +2,11 @@
 
 use std::cell::RefCell;
 
-use imprimatur::doc::{Document, PageSize, Paragraph, Picture, Run, Table};
+use imprimatur::doc::{Document, PageSize, Paragraph, Picture, Run, Symbol, Table};
 use imprimatur::style::Color;
 use magnus::{Error, RModule, RString, Ruby, function, method, prelude::*};
 
+use crate::barcode::Barcode;
 use crate::{ALIGNS, DIRECTIONS, OrRaise, RubyBytes, borrow, keyword};
 
 /// `[text, bold, italic, underline, color]`, as `Imprimatur::Paragraph` collects it.
@@ -88,6 +89,32 @@ impl NativeDocument {
         Ok(())
     }
 
+    /// A barcode, `width` and `height` in points, in a `color` "#RRGGBB".
+    fn barcode(
+        ruby: &Ruby,
+        rb_self: &Self,
+        barcode: &Barcode,
+        (width, height): (Option<f64>, Option<f64>),
+        align: Option<String>,
+        color: Option<String>,
+    ) -> Result<(), Error> {
+        let mut symbol = Symbol::new(barcode.0.clone());
+        if let Some(width) = width {
+            symbol = symbol.width(width).or_raise(ruby)?;
+        }
+        if let Some(height) = height {
+            symbol = symbol.height(height).or_raise(ruby)?;
+        }
+        if let Some(align) = align {
+            symbol = symbol.align(keyword(ruby, "align", &align, &ALIGNS)?);
+        }
+        if let Some(color) = color {
+            symbol = symbol.color(Color::from_hex(&color).or_raise(ruby)?);
+        }
+        borrow(ruby, &rb_self.0, "document")?.barcode(symbol);
+        Ok(())
+    }
+
     fn heading(ruby: &Ruby, rb_self: &Self, level: u8, text: String) -> Result<(), Error> {
         borrow(ruby, &rb_self.0, "document")?.heading(level, text).or_raise(ruby)?;
         Ok(())
@@ -175,6 +202,7 @@ pub fn define(ruby: &Ruby, native: RModule) -> Result<(), Error> {
     class.define_method("set_page_points", method!(NativeDocument::set_page_points, 3))?;
     class.define_method("set_margin", method!(NativeDocument::set_margin, 1))?;
     class.define_method("picture", method!(NativeDocument::picture, 4))?;
+    class.define_method("barcode", method!(NativeDocument::barcode, 4))?;
     class.define_method("heading", method!(NativeDocument::heading, 2))?;
     class.define_method("paragraph", method!(NativeDocument::paragraph, 3))?;
     class.define_method("table", method!(NativeDocument::table, 2))?;

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

@@ -4,6 +4,7 @@
 //! drives them; sheets cross as indices.
 
 mod archive;
+mod barcode;
 mod blocking;
 mod convert;
 mod document;
@@ -202,16 +203,16 @@ impl std::io::Write for RubyBytes {
     }
 }
 
-/// Mutable access to a wrapped value; Ruby code that calls back into the
-/// same object mid-call gets a `RuntimeError`, not a panic.
 /// A Ruby String's bytes, copied out.
 fn bytes(string: RString) -> Vec<u8> {
+    #[allow(unsafe_code)]
     // SAFETY: the bytes are copied out at once, while the GVL is held and
     // before any Ruby code can run and move or free the string.
-    #[allow(unsafe_code)]
     unsafe { string.as_slice() }.to_vec()
 }
 
+/// Mutable access to a wrapped value; Ruby code that calls back into the
+/// same object mid-call gets a `RuntimeError`, not a panic.
 fn borrow<'a, T>(ruby: &Ruby, cell: &'a RefCell<T>, what: &str) -> Result<RefMut<'a, T>, Error> {
     cell.try_borrow_mut().map_err(|_| {
         Error::new(
@@ -315,6 +316,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     style.define_singleton_method("__build", function!(Style::build, 13))?;
     let validation = imprimatur.define_class("Validation", ruby.class_object())?;
     validation.define_singleton_method("__build", function!(Validation::build, 8))?;
+    barcode::define(ruby, imprimatur)?;
 
     let native = imprimatur.define_module("Native")?;
     native.define_singleton_method("markdown", function!(read::markdown_native, 4))?;

data/lib/imprimatur/barcode.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Imprimatur
+  # A barcode: QR Code, Data Matrix, EAN-13, EAN-8, UPC-A or Code 128, and the
+  # GS1 forms of QR Code, Data Matrix and Code 128 (GS1-128). Built with
+  # {Imprimatur.barcode}; draw it with {#svg} or {#png}, or place it in a
+  # {Document} with {Document#barcode}. The class itself is native.
+  #
+  #   qr = Imprimatur.barcode(:qr, 'https://id.gs1.org/01/09506000134352')
+  #   File.write('qr.svg', qr.svg(module_size: 4))
+  #
+  #   label = Imprimatur.barcode(:code128, '(00)106141412345678908', gs1: true)
+  #   File.binwrite('label.png', label.png(module_size: 3))
+  #
+  #   Imprimatur.barcode(:ean13, '950600013435').text # => "9506000134352"
+  class Barcode
+    SYMBOLOGIES = %i[qr datamatrix ean13 ean8 upca code128].freeze
+
+    # @param symbology [:qr, :datamatrix, :ean13, :ean8, :upca, :code128]
+    # @param data [String] text; a GTIN's digits for EAN and UPC, the check
+    #   digit added when left out; with +gs1: true+, a GS1 element string
+    #   such as "(01)09506000134352(17)251231(10)AB12"
+    # @param gs1 [Boolean] a GS1 QR Code, GS1 DataMatrix or GS1-128
+    # @param level [:l, :m, :q, :h, nil] a QR Code's error correction, :m unless set
+    # @return [Barcode]
+    # @raise [Imprimatur::Error] data the symbology cannot hold, an invalid
+    #   element string, or a wrong check digit
+    # @raise [ArgumentError] an unknown symbology or level, or one that does not apply
+    def self.encode(symbology, data, gs1: false, level: nil)
+      __encode(symbology.to_s, String(data), gs1 ? true : false, level&.to_s)
+    end
+
+    private_class_method :__encode
+
+    # @param module_size [Numeric] user units (pixels) a module, 0.01 to 1000
+    # @param color [String] the bars, "#RRGGBB"
+    # @param background [String, nil] "#RRGGBB", or nil for none
+    # @param quiet_zone [Boolean] keep the blank margin scanners need
+    # @param bar_height [Integer, nil] a linear code's bar height in modules;
+    #   the symbology's nominal height unless set
+    # @return [String] SVG markup
+    # @raise [Imprimatur::Error] a module size or color out of range
+    def svg(module_size: 4, color: '#000000', background: '#FFFFFF', quiet_zone: true, bar_height: nil)
+      __svg(Float(module_size), look(color, background, quiet_zone, bar_height))
+    end
+
+    # @param module_size [Integer] pixels a module
+    # @param (see #svg)
+    # @return [String] the PNG bytes (binary): one bit a pixel, the background
+    #   transparent when nil
+    # @raise [Imprimatur::Error] a size of 0, an image above 65 536 pixels a side,
+    #   or an invalid color
+    def png(module_size: 4, color: '#000000', background: '#FFFFFF', quiet_zone: true, bar_height: nil)
+      __png(Integer(module_size), look(color, background, quiet_zone, bar_height))
+    end
+
+    # @!method symbology
+    #   @return [Symbol] one of {SYMBOLOGIES}
+    # @!method text
+    #   @return [String] what it encodes: the data given, or a GTIN with its check digit
+    # @!method gs1?
+    #   @return [Boolean] whether it carries a GS1 element string
+    # @!method width
+    #   @return [Integer] modules across, without the quiet zone
+    # @!method height
+    #   @return [Integer] modules down; 1 for a linear code
+    # @!method modules
+    #   @return [Array<Array<Boolean>>] rows of modules, true for dark
+
+    def inspect = "#<#{self.class} #{symbology}#{' gs1' if gs1?} #{text.inspect}>"
+
+    private
+
+    def look(color, background, quiet_zone, bar_height)
+      [color.to_s, background&.to_s, quiet_zone ? true : false, bar_height && Integer(bar_height)]
+    end
+  end
+end

data/lib/imprimatur/document.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Imprimatur
-  # A flowing document (headings, paragraphs, tables, pictures, page breaks)
+  # A flowing document (headings, paragraphs, tables, pictures, barcodes, page breaks)
   # that renders to PDF and DOCX from the same content.
   #
   #   doc = Imprimatur::Document.new(page_numbers: true)
@@ -49,6 +49,22 @@ module Imprimatur
       self
     end
 
+    # A barcode in the flow: vector shapes in a PDF, a 300 dpi picture in DOCX.
+    # Drawn at +width+ or +height+ 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.
+    #
+    # @param barcode [Barcode] from {Imprimatur.barcode}
+    # @param align [:left, :center, :right, nil]
+    # @param color [String, nil] the bars, "#RRGGBB"; black unless set
+    # @return [self]
+    # @raise [Imprimatur::Error] a size out of range, or an invalid color
+    def barcode(barcode, width: nil, height: nil, align: nil, color: nil)
+      @native.barcode(barcode, [width && Float(width), height && Float(height)], align&.to_s, color&.to_s)
+      self
+    end
+
     # @param text [String]
     # @param level [Integer] 1 (the title) to 3
     # @return [self]

data/lib/imprimatur/reader.rb

@@ -12,22 +12,29 @@ module Imprimatur
   # Documents in: Markdown, their structure, their images. See
   # {Imprimatur.markdown}, {Imprimatur.content} and {Imprimatur.images}.
   module Reader
-    # File signatures a document's bytes start with; a String that starts
-    # with neither is taken for a path.
+    # File signatures a document's bytes start with; a String that is not
+    # binary and starts with neither is taken for a path.
     SIGNATURES = ["%PDF-".b, "PK\x03\x04".b, "PK\x05\x06".b, "\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1".b].freeze
     private_constant :SIGNATURES
 
+    # The largest document read in unless told, as the native core's own limit.
+    MAX_BYTES = 512 * 1024 * 1024
+    private_constant :MAX_BYTES
+
     # @see Imprimatur.markdown
-    def self.markdown(document, **) = Native.markdown(read(document), *limits(**))
+    def self.markdown(document, max_bytes: nil, **)
+      Native.markdown(read(document, max_bytes), *limits(max_bytes:, **))
+    end
 
     # @see Imprimatur.content
-    def self.content(document, styles: false, **)
-      JSON.parse(Native.content(read(document), *limits(**), styles ? true : false), symbolize_names: true)
+    def self.content(document, styles: false, max_bytes: nil, **)
+      bytes = read(document, max_bytes)
+      JSON.parse(Native.content(bytes, *limits(max_bytes:, **), styles ? true : false), symbolize_names: true)
     end
 
     # @see Imprimatur.images
-    def self.images(document, **)
-      Native.images(read(document), *limits(**)).map do |data, description|
+    def self.images(document, max_bytes: nil, **)
+      Native.images(read(document, max_bytes), *limits(max_bytes:, **)).map do |data, description|
         found = JSON.parse(description, symbolize_names: true)
         Image.new(data:, **Image.members.drop(1).to_h { [it, found[it]] })
       end
@@ -38,22 +45,52 @@ module Imprimatur
       [max_bytes, max_inflated, timeout && Float(timeout)]
     end
 
+    # A path or an IO is read no further than +max_bytes+ (one byte past it
+    # tells it is passed): an endless stream or a huge file stops there.
+    #
     # @api private
-    def self.read(document)
+    def self.read(document, max_bytes = nil)
+      limit = max_bytes.is_a?(Integer) && max_bytes >= 0 ? max_bytes : MAX_BYTES
       case document
-      when Pathname then File.binread(document)
-      when String then bytes?(document) ? document : File.binread(document)
+      when Pathname then file(document, limit)
+      when String then bytes?(document) ? document : file(document, limit)
       else
         raise TypeError, "expected a path, bytes or an IO, not #{document.class}" unless document.respond_to?(:read)
 
-        document.read.to_s.b
+        within(document.read(limit + 1).to_s.b, limit)
       end
     end
 
+    # A binary String (what +File.binread+, a binary IO or a download give)
+    # is bytes, whatever it holds: uploaded bytes never name a file to read.
+    #
     # @api private
     def self.bytes?(string)
+      return true if string.encoding == Encoding::BINARY
+
       head = string.byteslice(0, 1024).b
       SIGNATURES.any? { head.start_with?(it) } || head.include?("%PDF-") || head.include?("\0")
     end
+
+    # A regular file's bytes. Opened without blocking and checked through
+    # the open file, so a pipe cannot hang the read, a device such as
+    # +/dev/zero+ is refused, and the file cannot be swapped in between.
+    #
+    # @api private
+    def self.file(path, limit)
+      File.open(path, File::RDONLY | File::NONBLOCK | File::BINARY) do |io|
+        stat = io.stat
+        raise UnsupportedDocument, "cannot read this document: #{path} is not a regular file" unless stat.file?
+
+        within(stat.size > limit ? '' : io.read(limit + 1).to_s, limit, stat.size)
+      end
+    end
+
+    # @api private
+    def self.within(bytes, limit, size = bytes.bytesize)
+      raise LimitExceeded, 'the document exceeds the input size limit' if [size, bytes.bytesize].max > limit
+
+      bytes
+    end
   end
 end

data/lib/imprimatur/spreadsheet.rb

@@ -123,7 +123,7 @@ module Imprimatur
     # @raise [UnsupportedDocument] a PDF, a Word document or another format
     # @raise [Imprimatur::Error] a damaged workbook, or past a limit
     def self.open(document, styles: false, **limits)
-      new(Native.sheets(Reader.read(document), *Reader.limits(**limits), styles ? true : false))
+      new(Native.sheets(Reader.read(document, limits[:max_bytes]), *Reader.limits(**limits), styles ? true : false))
     end
 
     # @return [Array<Sheet>] in the workbook's order, hidden ones included

data/lib/imprimatur/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Imprimatur
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end

data/lib/imprimatur.rb

@@ -6,6 +6,7 @@ require_relative 'imprimatur/formula'
 require_relative 'imprimatur/native'
 require_relative 'imprimatur/style'
 require_relative 'imprimatur/validation'
+require_relative 'imprimatur/barcode'
 require_relative 'imprimatur/xlsx'
 require_relative 'imprimatur/document'
 require_relative 'imprimatur/reader'
@@ -38,6 +39,9 @@ module Imprimatur
     # @see Validation.build
     def validation(**) = Validation.build(**)
 
+    # @see Barcode.encode
+    def barcode(symbology, data, **) = Barcode.encode(symbology, data, **)
+
     # Builds a {Document} and renders it as PDF. With a path, saves it there
     # and returns the path; without, returns the bytes.
     #
@@ -62,7 +66,8 @@ module Imprimatur
     #   Imprimatur.markdown(File.open('sales.xlsx'))
     #
     # @param document [String, Pathname, #read] a path, the document's bytes
-    #   (told apart by their signature), or an IO
+    #   (a binary String always is; another String only with a document's
+    #   signature), or an IO. A path must name a regular file.
     # @param timeout [Numeric, nil] seconds the read may take (60), +nil+ for none
     # @param max_bytes [Integer, nil] the largest document accepted (512 MiB)
     # @param max_inflated [Integer, nil] decompressed bytes allowed in all (1 GiB)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: imprimatur
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -52,9 +52,16 @@ files:
 - ext/imprimatur_native/core/LICENSE
 - ext/imprimatur_native/core/README.md
 - ext/imprimatur_native/core/src/archive.rs
+- ext/imprimatur_native/core/src/barcode.rs
+- ext/imprimatur_native/core/src/barcode/code128.rs
+- ext/imprimatur_native/core/src/barcode/draw.rs
+- ext/imprimatur_native/core/src/barcode/ean.rs
+- ext/imprimatur_native/core/src/barcode/gs1.rs
+- ext/imprimatur_native/core/src/barcode/matrix.rs
 - ext/imprimatur_native/core/src/doc.rs
 - ext/imprimatur_native/core/src/doc/paragraph.rs
 - ext/imprimatur_native/core/src/doc/picture.rs
+- ext/imprimatur_native/core/src/doc/symbol.rs
 - ext/imprimatur_native/core/src/doc/table.rs
 - ext/imprimatur_native/core/src/docx.rs
 - ext/imprimatur_native/core/src/docx/picture.rs
@@ -69,6 +76,9 @@ files:
 - ext/imprimatur_native/core/src/pdf/metrics.rs
 - ext/imprimatur_native/core/src/pdf/objects.rs
 - ext/imprimatur_native/core/src/pdf/picture.rs
+- ext/imprimatur_native/core/src/pdf/truetype.rs
+- ext/imprimatur_native/core/src/pdf/truetype/descriptor.rs
+- ext/imprimatur_native/core/src/pdf/truetype/program.rs
 - ext/imprimatur_native/core/src/read.rs
 - ext/imprimatur_native/core/src/read/budget.rs
 - ext/imprimatur_native/core/src/read/content.rs
@@ -108,7 +118,6 @@ files:
 - ext/imprimatur_native/core/src/read/xlsx/formats.rs
 - ext/imprimatur_native/core/src/script.rs
 - ext/imprimatur_native/core/src/style.rs
-- ext/imprimatur_native/core/src/test_support.rs
 - ext/imprimatur_native/core/src/xlsx.rs
 - ext/imprimatur_native/core/src/xlsx/autofit.rs
 - ext/imprimatur_native/core/src/xlsx/cell.rs
@@ -128,6 +137,7 @@ files:
 - ext/imprimatur_native/extconf.rb
 - ext/imprimatur_native/ffi/Cargo.toml
 - ext/imprimatur_native/ffi/src/archive.rs
+- ext/imprimatur_native/ffi/src/barcode.rs
 - ext/imprimatur_native/ffi/src/blocking.rs
 - ext/imprimatur_native/ffi/src/convert.rs
 - ext/imprimatur_native/ffi/src/document.rs
@@ -137,6 +147,7 @@ files:
 - ext/imprimatur_native/ffi/src/style.rs
 - ext/imprimatur_native/ffi/src/validation.rs
 - lib/imprimatur.rb
+- lib/imprimatur/barcode.rb
 - lib/imprimatur/document.rb
 - lib/imprimatur/error.rb
 - lib/imprimatur/formula.rb

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

@@ -1,251 +0,0 @@
-//! Helpers shared by the unit tests.
-
-use std::io::{Cursor, Read};
-
-/// Every entry of a zip archive as `(name, bytes)`, read with the `zip`
-/// crate: an implementation independent of ours, which verifies each CRC.
-pub fn read_zip(bytes: Vec<u8>) -> Vec<(String, Vec<u8>)> {
-    let mut archive = ::zip::ZipArchive::new(Cursor::new(bytes)).unwrap();
-    (0..archive.len())
-        .map(|index| {
-            let mut file = archive.by_index(index).unwrap();
-            let mut data = Vec::new();
-            file.read_to_end(&mut data).unwrap();
-            (file.name().unwrap().into_owned(), data)
-        })
-        .collect()
-}
-
-/// Every entry of a zip archive as text, by name, read as [`read_zip`] does;
-/// media come out garbled, for their names.
-pub fn text_parts(bytes: Vec<u8>) -> Vec<(String, String)> {
-    read_zip(bytes)
-        .into_iter()
-        .map(|(name, data)| (name, String::from_utf8_lossy(&data).into_owned()))
-        .collect()
-}
-
-/// The text of the part `name` among `parts`.
-pub fn part<'a>(parts: &'a [(String, String)], name: &str) -> &'a str {
-    parts
-        .iter()
-        .find(|(part, _)| part == name)
-        .map_or_else(|| panic!("no part {name}"), |(_, xml)| xml)
-}
-
-/// A zip of `(name, text)` parts, written with our own writer.
-pub fn zip_of(parts: &[(&str, &str)]) -> Vec<u8> {
-    let mut zip = crate::zip::ZipWriter::new(Vec::new());
-    for (name, text) in parts {
-        zip.add(name, text.as_bytes()).unwrap();
-    }
-    zip.finish().unwrap()
-}
-
-/// A PDF of `objects`, numbered from 1 (the first is the catalog), with a
-/// classic cross-reference table.
-pub fn pdf_of(objects: &[Vec<u8>]) -> Vec<u8> {
-    use std::io::Write as _;
-    let mut out = b"%PDF-1.7\n%\xE2\xE3\xCF\xD3\n".to_vec();
-    let mut offsets = Vec::new();
-    for (number, body) in (1..).zip(objects) {
-        offsets.push(out.len());
-        writeln!(out, "{number} 0 obj").unwrap();
-        out.extend_from_slice(body);
-        out.extend_from_slice(b"\nendobj\n");
-    }
-    let xref = out.len();
-    write!(out, "xref\n0 {}\n0000000000 65535 f \n", objects.len() + 1).unwrap();
-    for offset in offsets {
-        writeln!(out, "{offset:010} 00000 n ").unwrap();
-    }
-    write!(
-        out,
-        "trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n",
-        objects.len() + 1
-    )
-    .unwrap();
-    out
-}
-
-/// A stream object: `dict` holds the entries besides `/Length`.
-pub fn stream_object(dict: &str, data: &[u8]) -> Vec<u8> {
-    let mut out = format!("<< /Length {} {dict} >>\nstream\n", data.len()).into_bytes();
-    out.extend_from_slice(data);
-    out.extend_from_slice(b"\nendstream");
-    out
-}
-
-/// One page of `content` with Helvetica as `/F1` and a 612 by 792 page.
-pub fn page_pdf(content: &str, page_extra: &str) -> Vec<u8> {
-    pdf_of(&[
-        b"<< /Type /Catalog /Pages 2 0 R >>".to_vec(),
-        b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_vec(),
-        format!(
-            "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
-             /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R {page_extra} >>"
-        )
-        .into_bytes(),
-        b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>"
-            .to_vec(),
-        stream_object("", content.as_bytes()),
-    ])
-}
-
-/// A PNG as `read::image::png` writes it, read back.
-#[derive(Debug)]
-pub struct Png {
-    pub width: u32,
-    pub height: u32,
-    pub bits: u8,
-    pub color: u8,
-    pub palette: Option<Vec<u8>>,
-    /// The rows, their filter bytes (always 0, none) taken out.
-    pub rows: Vec<u8>,
-}
-
-/// Reads a PNG, checking each chunk's CRC and that every row is unfiltered.
-pub fn png_of(data: &[u8]) -> Png {
-    let be = |at: usize| u32::from_be_bytes(data[at..at + 4].try_into().unwrap());
-    assert!(data.starts_with(b"\x89PNG\r\n\x1a\n"), "{data:?}");
-    let (mut header, mut palette, mut compressed) = (Vec::new(), None, Vec::new());
-    let mut at = 8;
-    while at < data.len() {
-        let length = be(at) as usize;
-        let (kind, body) = (&data[at + 4..at + 8], &data[at + 8..at + 8 + length]);
-        assert_eq!(
-            be(at + 8 + length),
-            crc32fast::hash(&data[at + 4..at + 8 + length]),
-            "{kind:?}"
-        );
-        match kind {
-            b"IHDR" => header = body.to_vec(),
-            b"PLTE" => palette = Some(body.to_vec()),
-            b"IDAT" => compressed.extend_from_slice(body),
-            _ => {}
-        }
-        at += 12 + length;
-    }
-    let (width, height) = (be(16), be(20));
-    let (bits, color) = (header[8], header[9]);
-    let channels = match color {
-        0 | 3 => 1,
-        4 => 2,
-        2 => 3,
-        _ => 4,
-    };
-    let stride = (width as usize * channels * usize::from(bits)).div_ceil(8);
-    let filtered = miniz_oxide::inflate::decompress_to_vec_zlib(&compressed).unwrap();
-    assert_eq!(filtered.len(), (stride + 1) * height as usize);
-    let mut rows = Vec::new();
-    for row in filtered.chunks(stride + 1) {
-        assert_eq!(row[0], 0, "filter type");
-        rows.extend_from_slice(&row[1..]);
-    }
-    Png { width, height, bits, color, palette, rows }
-}
-
-/// A one-strip little-endian TIFF's tags, by number, and its strip.
-pub fn tiff_of(data: &[u8]) -> (std::collections::BTreeMap<u16, u32>, &[u8]) {
-    let le16 = |at: usize| u16::from_le_bytes(data[at..at + 2].try_into().unwrap());
-    let le32 = |at: usize| u32::from_le_bytes(data[at..at + 4].try_into().unwrap());
-    assert!(data.starts_with(b"II*\0"));
-    let directory = le32(4) as usize;
-    let tags: std::collections::BTreeMap<u16, u32> = (0..usize::from(le16(directory)))
-        .map(|index| {
-            let entry = directory + 2 + index * 12;
-            let value =
-                if le16(entry + 2) == 3 { u32::from(le16(entry + 8)) } else { le32(entry + 8) };
-            (le16(entry), value)
-        })
-        .collect();
-    let (offset, length) = (tags[&273] as usize, tags[&279] as usize);
-    (tags, &data[offset..offset + length])
-}
-
-/// A compound file (MS-CFB, version 3) holding one stream named `name` in
-/// its root storage; a stream under 4096 bytes goes to the mini stream, as
-/// writers put it.
-pub fn ole_of(name: &str, stream: &[u8]) -> Vec<u8> {
-    const SECTOR: usize = 512;
-    const END: u32 = 0xFFFF_FFFE;
-    let small = stream.len() < 4096;
-    let pad = |data: &[u8], size: usize| {
-        let mut data = data.to_vec();
-        data.resize(data.len().div_ceil(size).max(1) * size, 0);
-        data
-    };
-    // Sectors: FAT, directory, mini FAT (when small), then the data: the
-    // stream itself, or the mini stream holding it.
-    let data = if small { pad(stream, 64) } else { stream.to_vec() };
-    let data_sectors = data.len().div_ceil(SECTOR).max(1);
-    let first_data = if small { 3 } else { 2 };
-    let mut fat = vec![0xFFFF_FFFD_u32, END];
-    if small {
-        fat.push(END);
-    }
-    fat.extend((0..data_sectors).map(|index| {
-        if index + 1 == data_sectors { END } else { u32::try_from(first_data + index + 1).unwrap() }
-    }));
-    fat.resize(SECTOR / 4, 0xFFFF_FFFF);
-    let mut header = vec![0_u8; SECTOR];
-    header[..8].copy_from_slice(&[0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1]);
-    let put = |bytes: &mut Vec<u8>, at: usize, value: u32| {
-        bytes[at..at + 4].copy_from_slice(&value.to_le_bytes());
-    };
-    header[0x18..0x1A].copy_from_slice(&0x3E_u16.to_le_bytes());
-    header[0x1A..0x1C].copy_from_slice(&3_u16.to_le_bytes());
-    header[0x1C..0x1E].copy_from_slice(&0xFFFE_u16.to_le_bytes());
-    header[0x1E..0x20].copy_from_slice(&9_u16.to_le_bytes());
-    header[0x20..0x22].copy_from_slice(&6_u16.to_le_bytes());
-    put(&mut header, 0x2C, 1);
-    put(&mut header, 0x30, 1);
-    put(&mut header, 0x38, 4096);
-    put(&mut header, 0x3C, if small { 2 } else { END });
-    put(&mut header, 0x40, u32::from(small));
-    put(&mut header, 0x44, END);
-    put(&mut header, 0x4C, 0);
-    for index in 1..109 {
-        put(&mut header, 0x4C + index * 4, 0xFFFF_FFFF);
-    }
-    let entry = |name: &str, kind: u8, child: u32, start: u32, size: usize| {
-        let mut bytes = vec![0_u8; 128];
-        let units: Vec<u16> = name.encode_utf16().collect();
-        for (index, unit) in units.iter().enumerate() {
-            bytes[index * 2..index * 2 + 2].copy_from_slice(&unit.to_le_bytes());
-        }
-        bytes[0x40..0x42]
-            .copy_from_slice(&u16::try_from(units.len() * 2 + 2).unwrap().to_le_bytes());
-        bytes[0x42] = kind;
-        for at in [0x44, 0x48, 0x4C] {
-            put(&mut bytes, at, 0xFFFF_FFFF);
-        }
-        put(&mut bytes, 0x4C, child);
-        put(&mut bytes, 0x74, start);
-        put(&mut bytes, 0x78, u32::try_from(size).unwrap());
-        bytes
-    };
-    let first = u32::try_from(first_data).unwrap();
-    let mut directory = if small {
-        let mut directory = entry("Root Entry", 5, 1, first, data.len());
-        directory.extend(entry(name, 2, 0xFFFF_FFFF, 0, stream.len()));
-        directory
-    } else {
-        let mut directory = entry("Root Entry", 5, 1, END, 0);
-        directory.extend(entry(name, 2, 0xFFFF_FFFF, first, stream.len()));
-        directory
-    };
-    directory.resize(SECTOR, 0);
-    let mut file = header;
-    file.extend(fat.iter().flat_map(|word| word.to_le_bytes()));
-    file.extend(directory);
-    if small {
-        let mut mini_fat: Vec<u32> =
-            (1..data.len() / 64).map(|next| u32::try_from(next).unwrap()).collect();
-        mini_fat.push(END);
-        mini_fat.resize(SECTOR / 4, 0xFFFF_FFFF);
-        file.extend(mini_fat.iter().flat_map(|word| word.to_le_bytes()));
-    }
-    file.extend(pad(&data, SECTOR));
-    file
-}