imprimatur 0.1.0

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

@@ -0,0 +1,161 @@
+//! Greedy line breaking across runs of encoded text.
+
+#[cfg(test)]
+mod tests;
+
+use super::super::font::Face;
+use crate::style::Color;
+
+/// How a piece of text is drawn.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Look {
+    pub face: Face,
+    pub color: Option<Color>,
+    pub underline: bool,
+}
+
+/// Text with one look on one line.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Fragment {
+    pub bytes: Vec<u8>,
+    pub look: Look,
+    pub width: f64,
+}
+
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Line {
+    pub fragments: Vec<Fragment>,
+    pub width: f64,
+}
+
+impl Line {
+    /// Appends text, merging it into the last fragment when the look matches.
+    fn push(&mut self, bytes: &[u8], look: Look, width: f64) {
+        self.width += width;
+        if let Some(last) = self.fragments.last_mut()
+            && last.look == look
+        {
+            last.bytes.extend_from_slice(bytes);
+            last.width += width;
+            return;
+        }
+        self.fragments.push(Fragment { bytes: bytes.to_vec(), look, width });
+    }
+
+    const fn is_empty(&self) -> bool {
+        self.fragments.is_empty()
+    }
+}
+
+/// Spaces a tab stands for.
+const TAB_SPACES: &[u8] = b"    ";
+
+/// Breaks `runs` into lines no wider than `max_width` at `size` points.
+/// Lines break at spaces; `\n` forces a break; a word wider than a line is
+/// split between characters. Spaces where a line wraps are dropped.
+pub fn wrap(runs: &[(Vec<u8>, Look)], size: f64, max_width: f64) -> Vec<Line> {
+    let mut lines = vec![Line::default()];
+    // Whitespace seen since the last word, placed only if a word follows on
+    // the same line.
+    let mut pending: Vec<(Vec<u8>, Look)> = Vec::new();
+    for (bytes, look) in runs {
+        let face = look.face;
+        for token in tokens(bytes) {
+            match token {
+                Token::Newline => {
+                    lines.push(Line::default());
+                    pending.clear();
+                }
+                Token::Space(space) => {
+                    let mut expanded = Vec::with_capacity(space.len());
+                    for &byte in space {
+                        if byte == b'\t' {
+                            expanded.extend_from_slice(TAB_SPACES);
+                        } else {
+                            expanded.push(byte);
+                        }
+                    }
+                    pending.push((expanded, *look));
+                }
+                Token::Word(word) => {
+                    let width = face.width(word, size);
+                    let spaces: f64 =
+                        pending.iter().map(|(space, look)| look.face.width(space, size)).sum();
+                    let line = lines.last_mut().map_or(0.0, |line| line.width);
+                    let started = lines.last().is_some_and(|line| !line.is_empty());
+                    if started && line + spaces + width > max_width {
+                        lines.push(Line::default());
+                        pending.clear();
+                    }
+                    let Some(line) = lines.last_mut() else { continue };
+                    for (space, look) in std::mem::take(&mut pending) {
+                        let width = look.face.width(&space, size);
+                        line.push(&space, look, width);
+                    }
+                    place_word(&mut lines, word, *look, size, max_width);
+                }
+            }
+        }
+    }
+    lines
+}
+
+/// Places a word on the last line, splitting it across lines when it is
+/// wider than a whole line (at least one character per line).
+fn place_word(lines: &mut Vec<Line>, word: &[u8], look: Look, size: f64, max_width: f64) {
+    let mut rest = word;
+    while !rest.is_empty() {
+        let Some(line) = lines.last_mut() else { return };
+        let available = max_width - line.width;
+        let mut fit = 0;
+        let mut width = 0.0;
+        for &byte in rest {
+            let next = look.face.width(&[byte], size);
+            if width + next > available && (fit > 0 || !line.is_empty()) {
+                break;
+            }
+            width += next;
+            fit += 1;
+        }
+        if fit == 0 {
+            lines.push(Line::default());
+            continue;
+        }
+        line.push(&rest[..fit], look, width);
+        rest = &rest[fit..];
+        if !rest.is_empty() {
+            lines.push(Line::default());
+        }
+    }
+}
+
+enum Token<'a> {
+    Word(&'a [u8]),
+    Space(&'a [u8]),
+    Newline,
+}
+
+/// Words, runs of spaces and tabs, and newlines.
+fn tokens(bytes: &[u8]) -> impl Iterator<Item = Token<'_>> {
+    let mut rest = bytes;
+    std::iter::from_fn(move || {
+        let first = *rest.first()?;
+        let kind = |byte: u8| match byte {
+            b'\n' => 0,
+            b' ' | b'\t' => 1,
+            _ => 2,
+        };
+        let length = if first == b'\n' {
+            1
+        } else {
+            rest.iter().position(|&byte| kind(byte) != kind(first)).unwrap_or(rest.len())
+        };
+        let (token, tail) = rest.split_at(length);
+        rest = tail;
+        Some(match kind(first) {
+            0 => Token::Newline,
+            1 => Token::Space(token),
+            _ => Token::Word(token),
+        })
+    })
+}

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

@@ -0,0 +1,280 @@
+//! Places the document on pages: one content stream per page.
+
+#[cfg(test)]
+mod tests;
+mod wrap;
+
+use std::fmt::{self, Arguments, Write as _};
+
+use super::font::Face;
+use super::objects::{Num, push_string};
+use crate::doc::{PageSize, Paragraph, Table};
+use crate::style::{Align, Color};
+use crate::{Error, Result};
+use wrap::{Line, Look, wrap};
+
+/// One inch on every side.
+const MARGIN: f64 = 72.0;
+const BODY_SIZE: f64 = 11.0;
+const TABLE_SIZE: f64 = 10.0;
+/// Line height as a multiple of the font size.
+const LEADING: f64 = 1.25;
+const PARAGRAPH_GAP: f64 = 6.0;
+const CELL_PADDING: f64 = 4.0;
+const HEADING_COLOR: Color = Color::rgb(0x001F_3864);
+const HEADER_FILL: Color = Color::rgb(0x00D9_E2F3);
+const FOOTER_SIZE: f64 = 9.0;
+const FOOTER_COLOR: Color = Color::rgb(0x0066_6666);
+/// Size, space before, color of headings 1 to 3.
+const HEADINGS: [(f64, f64, Option<Color>); 3] =
+    [(20.0, 14.0, Some(HEADING_COLOR)), (15.0, 10.0, Some(HEADING_COLOR)), (12.5, 8.0, None)];
+
+pub struct Layout {
+    width: f64,
+    height: f64,
+    pages: Vec<Vec<u8>>,
+    /// The top of the free space on the current page, from the bottom edge.
+    y: f64,
+    blank: bool,
+}
+
+impl Layout {
+    pub fn new(size: PageSize) -> Self {
+        let (width, height) = size.points();
+        Self { width, height, pages: vec![Vec::new()], y: height - MARGIN, blank: true }
+    }
+
+    pub const fn page_size(&self) -> (f64, f64) {
+        (self.width, self.height)
+    }
+
+    const fn content_width(&self) -> f64 {
+        (-2.0f64).mul_add(MARGIN, self.width)
+    }
+
+    pub fn heading(&mut self, level: u8, text: &str) -> Result<()> {
+        let index = usize::from(level.clamp(1, 3) - 1);
+        let (size, before, color) = HEADINGS[index];
+        let look = Look { face: Face::Bold, color, underline: false };
+        let lines = wrap(&[(Face::Bold.encode(text)?, look)], size, self.content_width());
+        // Keep the heading with at least two lines of what follows.
+        let body_lines = 2.0 * BODY_SIZE * LEADING;
+        let needed = (line_count(&lines) * size).mul_add(LEADING, before) + body_lines;
+        self.ensure_room(needed);
+        if !self.blank {
+            self.y -= before;
+        }
+        self.lines(&lines, size, Align::Left);
+        self.y -= PARAGRAPH_GAP;
+        Ok(())
+    }
+
+    pub fn paragraph(&mut self, paragraph: &Paragraph) -> Result<()> {
+        let mut runs = Vec::with_capacity(paragraph.runs().len());
+        for run in paragraph.runs() {
+            let face = Face::new(run.bold, run.italic);
+            runs.push((
+                face.encode(&run.text)?,
+                Look { face, color: run.color, underline: run.underline },
+            ));
+        }
+        let lines = wrap(&runs, BODY_SIZE, self.content_width());
+        self.lines(&lines, BODY_SIZE, paragraph.effective_align());
+        self.y -= PARAGRAPH_GAP;
+        Ok(())
+    }
+
+    pub fn table(&mut self, table: &Table) -> Result<()> {
+        let columns = table.columns();
+        #[expect(clippy::cast_precision_loss, reason = "a column count is small")]
+        let column_width = self.content_width() / columns as f64;
+        let mut rows = Vec::with_capacity(table.rows().len());
+        for (index, row) in table.rows().iter().enumerate() {
+            let header = index == 0 && table.has_header();
+            let face = if header { Face::Bold } else { Face::Regular };
+            let look = Look { face, color: None, underline: false };
+            let mut cells = Vec::with_capacity(columns);
+            for column in 0..columns {
+                let text = row.get(column).map_or("", String::as_str);
+                let runs = [(face.encode(text)?, look)];
+                cells.push(wrap(&runs, TABLE_SIZE, (-2.0f64).mul_add(CELL_PADDING, column_width)));
+            }
+            let tallest = cells.iter().map(|lines| line_count(lines)).fold(1.0, f64::max);
+            let height = (tallest * TABLE_SIZE).mul_add(LEADING, 2.0 * CELL_PADDING);
+            rows.push((cells, height, header));
+        }
+
+        let header_height = rows.first().filter(|row| row.2).map_or(0.0, |row| row.1);
+        let room = (-2.0f64).mul_add(MARGIN, self.height) - header_height;
+        for (index, (cells, height, header)) in rows.iter().enumerate() {
+            (*height <= room || *header).ok_or(Error::RowTooTall(*height))?;
+            // A header needs the first body row beside it.
+            let needed =
+                if *header { height + rows.get(1).map_or(0.0, |row| row.1) } else { *height };
+            if self.ensure_room(needed) && table.has_header() && index > 0 {
+                let (cells, height, _) = &rows[0];
+                self.row(cells, *height, column_width, true);
+            }
+            self.row(cells, *height, column_width, *header);
+        }
+        self.y -= PARAGRAPH_GAP;
+        Ok(())
+    }
+
+    pub fn page_break(&mut self) {
+        self.new_page();
+    }
+
+    /// The finished pages, numbered `1 / N` at the bottom when asked.
+    pub fn finish(mut self, page_numbers: bool) -> Vec<Vec<u8>> {
+        if page_numbers {
+            let total = self.pages.len();
+            let center = self.width / 2.0;
+            for (index, page) in self.pages.iter_mut().enumerate() {
+                let bytes = format!("{} / {total}", index + 1).into_bytes();
+                let width = Face::Regular.width(&bytes, FOOTER_SIZE);
+                let look =
+                    Look { face: Face::Regular, color: Some(FOOTER_COLOR), underline: false };
+                let label = wrap::Fragment { bytes, look, width };
+                draw_fragment(page, &label, FOOTER_SIZE, center - width / 2.0, MARGIN / 2.0);
+            }
+        }
+        self.pages
+    }
+
+    /// 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.
+    fn ensure_room(&mut self, needed: f64) -> bool {
+        let full = !self.blank && self.y - needed < MARGIN;
+        if full {
+            self.new_page();
+        }
+        full
+    }
+
+    fn new_page(&mut self) {
+        self.pages.push(Vec::new());
+        self.y = self.height - MARGIN;
+        self.blank = true;
+    }
+
+    fn current(&mut self) -> &mut Vec<u8> {
+        if self.pages.is_empty() {
+            self.pages.push(Vec::new());
+        }
+        let last = self.pages.len() - 1;
+        &mut self.pages[last]
+    }
+
+    /// Draws lines from the cursor down, starting new pages as needed.
+    fn lines(&mut self, lines: &[Line], size: f64, align: Align) {
+        let leading = size * LEADING;
+        for line in lines {
+            self.ensure_room(leading);
+            let baseline = self.y - baseline_offset(size);
+            let slack = self.content_width() - line.width;
+            let x = MARGIN
+                + match align {
+                    Align::Left => 0.0,
+                    Align::Center => slack / 2.0,
+                    Align::Right => slack,
+                };
+            draw_line(self.current(), line, size, x, baseline);
+            self.y -= leading;
+            self.blank = false;
+        }
+    }
+
+    /// One table row from the cursor down: fill, borders, then text.
+    fn row(&mut self, cells: &[Vec<Line>], height: f64, column_width: f64, header: bool) {
+        let top = self.y;
+        let page = self.current();
+        let mut x = MARGIN;
+        for lines in cells {
+            let rect = format_args!(
+                "{} {} {} {} re",
+                Num(x),
+                Num(top - height),
+                Num(column_width),
+                Num(height)
+            );
+            if header {
+                emit(page, format_args!("{} {rect} f\n", Fill(HEADER_FILL)));
+            }
+            emit(page, format_args!("0.5 w 0 0 0 RG {rect} S\n"));
+            let mut y = top - CELL_PADDING;
+            for line in lines {
+                let baseline = y - baseline_offset(TABLE_SIZE);
+                draw_line(page, line, TABLE_SIZE, x + CELL_PADDING, baseline);
+                y = TABLE_SIZE.mul_add(-LEADING, y);
+            }
+            x += column_width;
+        }
+        self.y -= height;
+        self.blank = false;
+    }
+}
+
+#[expect(clippy::cast_precision_loss, reason = "a paragraph has far fewer than 2**53 lines")]
+const fn line_count(lines: &[Line]) -> f64 {
+    lines.len() as f64
+}
+
+/// From the top of a line to its baseline: half the leading the glyphs do
+/// not fill, then the ascender.
+fn baseline_offset(size: f64) -> f64 {
+    let (ascent, descent) = (Face::Regular.ascent(size), Face::Regular.descent(size));
+    size.mul_add(LEADING, -ascent - descent).mul_add(0.5, ascent)
+}
+
+/// Draws a line's fragments left to right from `x`.
+fn draw_line(page: &mut Vec<u8>, line: &Line, size: f64, mut x: f64, baseline: f64) {
+    for fragment in &line.fragments {
+        draw_fragment(page, fragment, size, x, baseline);
+        x += fragment.width;
+    }
+}
+
+fn draw_fragment(page: &mut Vec<u8>, fragment: &wrap::Fragment, size: f64, x: f64, baseline: f64) {
+    let look = fragment.look;
+    let color = Fill(look.color.unwrap_or(Color::BLACK));
+    let (face, size_num) = (look.face.resource(), Num(size));
+    emit(page, format_args!("BT /{face} {size_num} Tf {color} {} {} Td ", Num(x), Num(baseline)));
+    push_string(page, &fragment.bytes);
+    page.extend_from_slice(b" Tj ET\n");
+    if look.underline && fragment.width > 0.0 {
+        // Helvetica's underline: 100 below the baseline, 50 thick.
+        let (y, thickness) = ((-0.125f64).mul_add(size, baseline), 0.05 * size);
+        let (x, y, width, thickness) = (Num(x), Num(y), Num(fragment.width), Num(thickness));
+        emit(page, format_args!("{color} {x} {y} {width} {thickness} re f\n"));
+    }
+}
+
+/// `r g b rg`, the fill color operator.
+#[derive(Clone, Copy)]
+struct Fill(Color);
+
+impl fmt::Display for Fill {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let [r, g, b] = self.0.components();
+        write!(f, "{} {} {} rg", Num(r), Num(g), Num(b))
+    }
+}
+
+/// Appends operators to a content stream, formatted in place.
+fn emit(page: &mut Vec<u8>, ops: Arguments<'_>) {
+    // `Ops` never fails and every value formatted here is a number, a name
+    // or a `Fill`, so formatting cannot fail either.
+    let _ = Ops(page).write_fmt(ops);
+}
+
+/// `fmt::Write` over a content stream.
+struct Ops<'a>(&'a mut Vec<u8>);
+
+impl fmt::Write for Ops<'_> {
+    fn write_str(&mut self, text: &str) -> fmt::Result {
+        self.0.extend_from_slice(text.as_bytes());
+        Ok(())
+    }
+}

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

@@ -0,0 +1,139 @@
+//! Advance widths and vertical metrics of the PDF standard fonts, in
+//! thousandths of the font size, indexed by `WinAnsiEncoding` code.
+//!
+//! Generated by `tools/generate_pdf_metrics.rb`; do not edit. Derived
+//! (modified: reduced to widths and vertical metrics) from Adobe's Core 14
+//! AFM files, which carry these notices:
+//!
+//! Copyright (c) 1985, 1987, 1989, 1990, 1997 Adobe Systems Incorporated. All
+//! Rights Reserved.
+//!
+//! This file and the 14 PostScript(R) AFM files it accompanies may be used,
+//! copied, and distributed for any purpose and without charge, with or without
+//! modification, provided that all copyright notices are retained; that the AFM
+//! files are not distributed without this file; that all modifications to this
+//! file or any of the AFM files are prominently noted in the modified file(s);
+//! and that this paragraph is not modified. Adobe Systems has no responsibility
+//! or obligation to support the use of the AFM files.
+
+/// Metrics of one standard font.
+pub struct FontMetrics {
+    pub name: &'static str,
+    pub ascender: i16,
+    pub descender: i16,
+    /// 0 where `WinAnsiEncoding` has no glyph.
+    pub widths: [u16; 256],
+}
+
+/// The Unicode character Windows-1252 assigns to bytes 0x80..=0x9F.
+pub const WIN_ANSI_HIGH: [Option<char>; 32] = [
+    Some('\u{20ac}'), None, Some('\u{201a}'), Some('\u{192}'),
+    Some('\u{201e}'), Some('\u{2026}'), Some('\u{2020}'), Some('\u{2021}'),
+    Some('\u{2c6}'), Some('\u{2030}'), Some('\u{160}'), Some('\u{2039}'),
+    Some('\u{152}'), None, Some('\u{17d}'), None,
+    None, Some('\u{2018}'), Some('\u{2019}'), Some('\u{201c}'),
+    Some('\u{201d}'), Some('\u{2022}'), Some('\u{2013}'), Some('\u{2014}'),
+    Some('\u{2dc}'), Some('\u{2122}'), Some('\u{161}'), Some('\u{203a}'),
+    Some('\u{153}'), None, Some('\u{17e}'), Some('\u{178}'),
+];
+
+pub const HELVETICA: FontMetrics = FontMetrics {
+    name: "Helvetica",
+    ascender: 718,
+    descender: -207,
+    #[rustfmt::skip]
+    widths: [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        278, 278, 355, 556, 556, 889, 667, 191, 333, 333, 389, 584, 278, 333, 278, 278,
+        556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 278, 278, 584, 584, 584, 556,
+        1015, 667, 667, 722, 722, 667, 611, 778, 722, 278, 500, 667, 556, 833, 722, 778,
+        667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 278, 278, 278, 469, 556,
+        333, 556, 556, 500, 556, 556, 278, 556, 556, 222, 222, 500, 222, 833, 556, 556,
+        556, 556, 333, 500, 278, 556, 500, 722, 500, 500, 500, 334, 260, 334, 584, 350,
+        556, 350, 222, 556, 333, 1000, 556, 556, 333, 1000, 667, 333, 1000, 350, 611, 350,
+        350, 222, 222, 333, 333, 350, 556, 1000, 333, 1000, 500, 333, 944, 350, 500, 667,
+        278, 333, 556, 556, 556, 556, 260, 556, 333, 737, 370, 556, 584, 333, 737, 333,
+        400, 584, 333, 333, 333, 556, 537, 278, 333, 333, 365, 556, 834, 834, 834, 611,
+        667, 667, 667, 667, 667, 667, 1000, 722, 667, 667, 667, 667, 278, 278, 278, 278,
+        722, 722, 778, 778, 778, 778, 778, 584, 778, 722, 722, 722, 722, 667, 667, 611,
+        556, 556, 556, 556, 556, 556, 889, 500, 556, 556, 556, 556, 278, 278, 278, 278,
+        556, 556, 556, 556, 556, 556, 556, 584, 611, 556, 556, 556, 556, 500, 556, 500,
+    ],
+};
+
+pub const HELVETICA_BOLD: FontMetrics = FontMetrics {
+    name: "Helvetica-Bold",
+    ascender: 718,
+    descender: -207,
+    #[rustfmt::skip]
+    widths: [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        278, 333, 474, 556, 556, 889, 722, 238, 333, 333, 389, 584, 278, 333, 278, 278,
+        556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 333, 333, 584, 584, 584, 611,
+        975, 722, 722, 722, 722, 667, 611, 778, 722, 278, 556, 722, 611, 833, 722, 778,
+        667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 333, 278, 333, 584, 556,
+        333, 556, 611, 556, 611, 556, 333, 611, 611, 278, 278, 556, 278, 889, 611, 611,
+        611, 611, 389, 556, 333, 611, 556, 778, 556, 556, 500, 389, 280, 389, 584, 350,
+        556, 350, 278, 556, 500, 1000, 556, 556, 333, 1000, 667, 333, 1000, 350, 611, 350,
+        350, 278, 278, 500, 500, 350, 556, 1000, 333, 1000, 556, 333, 944, 350, 500, 667,
+        278, 333, 556, 556, 556, 556, 280, 556, 333, 737, 370, 556, 584, 333, 737, 333,
+        400, 584, 333, 333, 333, 611, 556, 278, 333, 333, 365, 556, 834, 834, 834, 611,
+        722, 722, 722, 722, 722, 722, 1000, 722, 667, 667, 667, 667, 278, 278, 278, 278,
+        722, 722, 778, 778, 778, 778, 778, 584, 778, 722, 722, 722, 722, 667, 667, 611,
+        556, 556, 556, 556, 556, 556, 889, 556, 556, 556, 556, 556, 278, 278, 278, 278,
+        611, 611, 611, 611, 611, 611, 611, 584, 611, 611, 611, 611, 611, 556, 611, 556,
+    ],
+};
+
+pub const HELVETICA_OBLIQUE: FontMetrics = FontMetrics {
+    name: "Helvetica-Oblique",
+    ascender: 718,
+    descender: -207,
+    #[rustfmt::skip]
+    widths: [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        278, 278, 355, 556, 556, 889, 667, 191, 333, 333, 389, 584, 278, 333, 278, 278,
+        556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 278, 278, 584, 584, 584, 556,
+        1015, 667, 667, 722, 722, 667, 611, 778, 722, 278, 500, 667, 556, 833, 722, 778,
+        667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 278, 278, 278, 469, 556,
+        333, 556, 556, 500, 556, 556, 278, 556, 556, 222, 222, 500, 222, 833, 556, 556,
+        556, 556, 333, 500, 278, 556, 500, 722, 500, 500, 500, 334, 260, 334, 584, 350,
+        556, 350, 222, 556, 333, 1000, 556, 556, 333, 1000, 667, 333, 1000, 350, 611, 350,
+        350, 222, 222, 333, 333, 350, 556, 1000, 333, 1000, 500, 333, 944, 350, 500, 667,
+        278, 333, 556, 556, 556, 556, 260, 556, 333, 737, 370, 556, 584, 333, 737, 333,
+        400, 584, 333, 333, 333, 556, 537, 278, 333, 333, 365, 556, 834, 834, 834, 611,
+        667, 667, 667, 667, 667, 667, 1000, 722, 667, 667, 667, 667, 278, 278, 278, 278,
+        722, 722, 778, 778, 778, 778, 778, 584, 778, 722, 722, 722, 722, 667, 667, 611,
+        556, 556, 556, 556, 556, 556, 889, 500, 556, 556, 556, 556, 278, 278, 278, 278,
+        556, 556, 556, 556, 556, 556, 556, 584, 611, 556, 556, 556, 556, 500, 556, 500,
+    ],
+};
+
+pub const HELVETICA_BOLDOBLIQUE: FontMetrics = FontMetrics {
+    name: "Helvetica-BoldOblique",
+    ascender: 718,
+    descender: -207,
+    #[rustfmt::skip]
+    widths: [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        278, 333, 474, 556, 556, 889, 722, 238, 333, 333, 389, 584, 278, 333, 278, 278,
+        556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 333, 333, 584, 584, 584, 611,
+        975, 722, 722, 722, 722, 667, 611, 778, 722, 278, 556, 722, 611, 833, 722, 778,
+        667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 333, 278, 333, 584, 556,
+        333, 556, 611, 556, 611, 556, 333, 611, 611, 278, 278, 556, 278, 889, 611, 611,
+        611, 611, 389, 556, 333, 611, 556, 778, 556, 556, 500, 389, 280, 389, 584, 350,
+        556, 350, 278, 556, 500, 1000, 556, 556, 333, 1000, 667, 333, 1000, 350, 611, 350,
+        350, 278, 278, 500, 500, 350, 556, 1000, 333, 1000, 556, 333, 944, 350, 500, 667,
+        278, 333, 556, 556, 556, 556, 280, 556, 333, 737, 370, 556, 584, 333, 737, 333,
+        400, 584, 333, 333, 333, 611, 556, 278, 333, 333, 365, 556, 834, 834, 834, 611,
+        722, 722, 722, 722, 722, 722, 1000, 722, 667, 667, 667, 667, 278, 278, 278, 278,
+        722, 722, 778, 778, 778, 778, 778, 584, 778, 722, 722, 722, 722, 667, 667, 611,
+        556, 556, 556, 556, 556, 556, 889, 556, 556, 556, 556, 556, 278, 278, 278, 278,
+        611, 611, 611, 611, 611, 611, 611, 584, 611, 611, 611, 611, 611, 556, 611, 556,
+    ],
+};
+