Skip to main content

pdf2_render/
walk.rs

1//! The content-stream walker: graphics state, path construction, painting
2//! operators, clipping and dash handling.
3//!
4//! The walker reuses [`pdf2::Parser`] (the same tokenizer the object parser
5//! uses) and maps operators to draw calls. Operators it does not implement —
6//! text and images, until the next round — are counted and reported, never
7//! fatal: a page with text still paints its paths.
8
9use std::collections::BTreeMap;
10use std::fmt;
11
12use pdf2::lexer::{is_delimiter, is_whitespace};
13use pdf2::{Dictionary, Document, Encoding, Object, Page, Parser, Token};
14
15use crate::canvas::{Canvas, ClipMask, Color};
16use crate::font::Font;
17use crate::geom::{Matrix, Point};
18use crate::image::{resolve, Image};
19use crate::path::{dash_polyline, stroke_outline, Cap, Dash, Join, Path};
20use crate::raster::{clip_mask, fill_polygons};
21
22/// What a page render should look like.
23#[derive(Debug, Clone, PartialEq)]
24pub struct RenderOptions {
25    /// Device pixels per PDF point: `1.0` is 72 dpi.
26    pub scale: f64,
27    /// Canvas background.
28    pub background: Color,
29}
30
31impl Default for RenderOptions {
32    fn default() -> Self {
33        Self {
34            scale: 1.0,
35            background: Color::WHITE,
36        }
37    }
38}
39
40/// What happened while rendering, beyond the pixels.
41#[derive(Debug, Clone, Default, PartialEq)]
42pub struct Report {
43    /// Operators that were recognised but not drawn, with how often each
44    /// appeared. Text and image operators land here until they are implemented.
45    pub unsupported: BTreeMap<String, usize>,
46}
47
48impl Report {
49    /// Total unsupported operators.
50    pub fn unsupported_total(&self) -> usize {
51        self.unsupported.values().sum()
52    }
53
54    fn note(&mut self, operator: &[u8]) {
55        let name = String::from_utf8_lossy(operator).into_owned();
56        *self.unsupported.entry(name).or_insert(0) += 1;
57    }
58}
59
60impl fmt::Display for Report {
61    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
62        if self.unsupported.is_empty() {
63            return write!(formatter, "all operators supported");
64        }
65        let mut first = true;
66        for (name, count) in &self.unsupported {
67            if !first {
68                write!(formatter, ", ")?;
69            }
70            first = false;
71            write!(formatter, "{name}×{count}")?;
72        }
73        Ok(())
74    }
75}
76
77/// A rendered page.
78#[derive(Debug, Clone)]
79pub struct RenderedPage {
80    /// The raster.
81    pub canvas: Canvas,
82    /// What was skipped.
83    pub report: Report,
84}
85
86/// A document, page number (zero based) and rasterisation scale in one call.
87pub fn render_page_number(
88    document: &Document,
89    page_index: usize,
90    options: &RenderOptions,
91) -> crate::Result<RenderedPage> {
92    let page = document.page(page_index)?;
93    render_page(document, &page, options)
94}
95
96/// Rasterise one page.
97pub fn render_page(
98    document: &Document,
99    page: &Page,
100    options: &RenderOptions,
101) -> crate::Result<RenderedPage> {
102    let scale = if options.scale.is_finite() && options.scale > 0.0 {
103        options.scale
104    } else {
105        1.0
106    };
107    let media = page
108        .media_box
109        .unwrap_or(pdf2::Rect::new(0.0, 0.0, 612.0, 792.0));
110    // `/Rotate` turns the page clockwise for display, so a quarter turn swaps
111    // the canvas dimensions.
112    let rotate = page.rotate.rem_euclid(360);
113    let landscape = rotate == 90 || rotate == 270;
114    let (width_points, height_points) = if landscape {
115        (media.height(), media.width())
116    } else {
117        (media.width(), media.height())
118    };
119    let width = ((width_points * scale).round().max(1.0)) as u32;
120    let height = ((height_points * scale).round().max(1.0)) as u32;
121    let mut canvas = Canvas::new(width, height, options.background);
122    let mut report = Report::default();
123
124    // PDF user space to device space. Every case shifts the media box origin to
125    // (0, 0); the y axis grows downwards in the raster, and `/Rotate` composes
126    // a clockwise quarter turn (or two) on top of that flip.
127    let base = match rotate {
128        90 => Matrix::new(0.0, scale, scale, 0.0, -media.y0 * scale, -media.x0 * scale),
129        180 => Matrix::new(-scale, 0.0, 0.0, scale, media.x1 * scale, -media.y0 * scale),
130        270 => Matrix::new(0.0, scale, -scale, 0.0, media.y1 * scale, -media.x0 * scale),
131        _ => Matrix::new(scale, 0.0, 0.0, -scale, -media.x0 * scale, media.y1 * scale),
132    };
133
134    let content = document.page_content(page)?;
135    let mut walker = Walker {
136        canvas: &mut canvas,
137        report: &mut report,
138        document,
139        resources: page.resources.clone(),
140        state: State::new(base),
141        stack: Vec::new(),
142        path: Path::new(),
143        pending_clip: None,
144        mask: ClipMask::all(width, height),
145    };
146    walker.run(&content)?;
147    Ok(RenderedPage { canvas, report })
148}
149
150/// The part of the graphics state that painting depends on.
151#[derive(Debug, Clone)]
152struct State {
153    ctm: Matrix,
154    line_width: f64,
155    cap: Cap,
156    join: Join,
157    dash: Dash,
158    fill: Color,
159    stroke: Color,
160    font: Option<Font>,
161    font_size: f64,
162    miter_limit: f64,
163    char_spacing: f64,
164    word_spacing: f64,
165    horizontal_scale: f64,
166    leading: f64,
167    rise: f64,
168    text_matrix: Matrix,
169    line_matrix: Matrix,
170}
171
172impl State {
173    fn new(ctm: Matrix) -> Self {
174        Self {
175            ctm,
176            line_width: 1.0,
177            cap: Cap::Butt,
178            join: Join::Miter,
179            dash: Dash::solid(),
180            fill: Color::BLACK,
181            stroke: Color::BLACK,
182            font: None,
183            font_size: 0.0,
184            miter_limit: 10.0,
185            char_spacing: 0.0,
186            word_spacing: 0.0,
187            horizontal_scale: 1.0,
188            leading: 0.0,
189            rise: 0.0,
190            text_matrix: Matrix::IDENTITY,
191            line_matrix: Matrix::IDENTITY,
192        }
193    }
194}
195
196struct Walker<'a> {
197    canvas: &'a mut Canvas,
198    report: &'a mut Report,
199    document: &'a Document,
200    resources: Option<Dictionary>,
201    state: State,
202    stack: Vec<(State, ClipMask)>,
203    path: Path,
204    pending_clip: Option<bool>,
205    mask: ClipMask,
206}
207
208impl Walker<'_> {
209    fn run(&mut self, content: &[u8]) -> crate::Result<()> {
210        let mut parser = Parser::new(content);
211        let mut operands: Vec<Object> = Vec::new();
212        loop {
213            match parser.peek_token()? {
214                Token::Eof => break,
215                Token::Keyword(_) => {
216                    let operator = match parser.next_token()? {
217                        Token::Keyword(operator) => operator,
218                        _ => return Err(crate::Error::malformed("content-stream operator")),
219                    };
220                    self.execute(&operator, &mut operands, &mut parser)?;
221                    operands.clear();
222                }
223                _ => {
224                    operands.push(parser.parse_object()?);
225                }
226            }
227        }
228        Ok(())
229    }
230
231    fn execute(
232        &mut self,
233        operator: &[u8],
234        operands: &mut [Object],
235        parser: &mut Parser<'_>,
236    ) -> crate::Result<()> {
237        match operator {
238            b"q" => {
239                self.stack.push((self.state.clone(), self.mask.clone()));
240            }
241            b"Q" => {
242                if let Some((state, mask)) = self.stack.pop() {
243                    self.state = state;
244                    self.mask = mask;
245                }
246            }
247            b"cm" => {
248                if let Some(matrix) = matrix_operand(operands) {
249                    self.state.ctm = matrix.multiply(self.state.ctm);
250                }
251            }
252            b"w" => self.state.line_width = number(operands, 0),
253            b"J" => {
254                self.state.cap = match integer(operands, 0) {
255                    1 => Cap::Round,
256                    2 => Cap::Square,
257                    _ => Cap::Butt,
258                }
259            }
260            b"j" => {
261                self.state.join = match integer(operands, 0) {
262                    1 => Join::Round,
263                    2 => Join::Bevel,
264                    _ => Join::Miter,
265                }
266            }
267            b"M" => self.state.miter_limit = number(operands, 0).max(1.0),
268            b"d" => self.state.dash = dash_operand(operands),
269            b"m" => {
270                if let Some(point) = point_operand(operands, 0) {
271                    self.path.move_to(point);
272                }
273            }
274            b"l" => {
275                if let Some(point) = point_operand(operands, 0) {
276                    self.path.line_to(point);
277                }
278            }
279            b"c" => {
280                if let (Some(c1), Some(c2), Some(to)) = (
281                    point_operand(operands, 0),
282                    point_operand(operands, 1),
283                    point_operand(operands, 2),
284                ) {
285                    self.path.curve_to(c1, c2, to);
286                }
287            }
288            b"v" | b"y" => {
289                // `v` and `y` are shorthand curves; draw them as a straight
290                // line to the end point, which keeps the path closed.
291                if let Some(to) = point_operand(operands, 1) {
292                    self.path.line_to(to);
293                }
294            }
295            b"h" => self.path.close(),
296            b"re" => {
297                let x = number(operands, 0);
298                let y = number(operands, 1);
299                let width = number(operands, 2);
300                let height = number(operands, 3);
301                self.path.add_rect(x, y, width, height);
302            }
303            b"S" => self.paint(Paint::Stroke, false)?,
304            b"s" => {
305                self.path.close();
306                self.paint(Paint::Stroke, false)?;
307            }
308            b"f" | b"F" => self.paint(Paint::Fill, false)?,
309            b"f*" => self.paint(Paint::Fill, true)?,
310            b"B" => self.paint(Paint::Both, false)?,
311            b"B*" => self.paint(Paint::Both, true)?,
312            b"b" => {
313                self.path.close();
314                self.paint(Paint::Both, false)?;
315            }
316            b"b*" => {
317                self.path.close();
318                self.paint(Paint::Both, true)?;
319            }
320            b"W" => self.pending_clip = Some(false),
321            b"W*" => self.pending_clip = Some(true),
322            b"n" => {
323                self.apply_pending_clip();
324                self.path = Path::new();
325            }
326            b"g" => {
327                self.state.fill = Color::rgb(
328                    number(operands, 0),
329                    number(operands, 0),
330                    number(operands, 0),
331                )
332            }
333            b"G" => {
334                self.state.stroke = Color::rgb(
335                    number(operands, 0),
336                    number(operands, 0),
337                    number(operands, 0),
338                )
339            }
340            b"rg" => {
341                self.state.fill = Color::rgb(
342                    number(operands, 0),
343                    number(operands, 1),
344                    number(operands, 2),
345                );
346            }
347            b"RG" => {
348                self.state.stroke = Color::rgb(
349                    number(operands, 0),
350                    number(operands, 1),
351                    number(operands, 2),
352                );
353            }
354            b"k" => {
355                self.state.fill = Color::from_cmyk(
356                    number(operands, 0),
357                    number(operands, 1),
358                    number(operands, 2),
359                    number(operands, 3),
360                );
361            }
362            b"K" => {
363                self.state.stroke = Color::from_cmyk(
364                    number(operands, 0),
365                    number(operands, 1),
366                    number(operands, 2),
367                    number(operands, 3),
368                );
369            }
370            b"BT" => {
371                self.state.text_matrix = Matrix::IDENTITY;
372                self.state.line_matrix = Matrix::IDENTITY;
373            }
374            b"ET" => {}
375            b"Tf" => {
376                let name = match operands.first() {
377                    Some(Object::Name(name)) => name.clone(),
378                    _ => return Err(crate::Error::malformed("/Tf needs a font name")),
379                };
380                self.state.font_size = number(operands, 1);
381                self.state.font = self.load_font(&name);
382            }
383            b"Td" | b"TD" => {
384                let tx = number(operands, 0);
385                let ty = number(operands, 1);
386                self.state.line_matrix =
387                    Matrix::new(1.0, 0.0, 0.0, 1.0, tx, ty).multiply(self.state.line_matrix);
388                self.state.text_matrix = self.state.line_matrix;
389                if operator == b"TD" {
390                    self.state.leading = -ty;
391                }
392            }
393            b"T*" => {
394                self.state.line_matrix = Matrix::new(1.0, 0.0, 0.0, 1.0, 0.0, -self.state.leading)
395                    .multiply(self.state.line_matrix);
396                self.state.text_matrix = self.state.line_matrix;
397            }
398            b"Tm" => {
399                if let Some(matrix) = matrix_operand(operands) {
400                    self.state.line_matrix = matrix;
401                    self.state.text_matrix = matrix;
402                }
403            }
404            b"TL" => self.state.leading = number(operands, 0),
405            b"Tc" => self.state.char_spacing = number(operands, 0),
406            b"Tw" => self.state.word_spacing = number(operands, 0),
407            b"Tz" => self.state.horizontal_scale = number(operands, 0) / 100.0,
408            b"Ts" => self.state.rise = number(operands, 0),
409            b"Tj" => {
410                if let Some(Object::String(string)) = operands.first() {
411                    let bytes = string.as_bytes().to_vec();
412                    self.show_text(&bytes)?;
413                }
414            }
415            b"'" => {
416                self.state.line_matrix = Matrix::new(1.0, 0.0, 0.0, 1.0, 0.0, -self.state.leading)
417                    .multiply(self.state.line_matrix);
418                self.state.text_matrix = self.state.line_matrix;
419                if let Some(Object::String(string)) = operands.first() {
420                    let bytes = string.as_bytes().to_vec();
421                    self.show_text(&bytes)?;
422                }
423            }
424            b"\"" => {
425                self.state.word_spacing = number(operands, 0);
426                self.state.char_spacing = number(operands, 1);
427                self.state.line_matrix = Matrix::new(1.0, 0.0, 0.0, 1.0, 0.0, -self.state.leading)
428                    .multiply(self.state.line_matrix);
429                self.state.text_matrix = self.state.line_matrix;
430                if let Some(Object::String(string)) = operands.get(2) {
431                    let bytes = string.as_bytes().to_vec();
432                    self.show_text(&bytes)?;
433                }
434            }
435            b"TJ" => {
436                if let Some(Object::Array(items)) = operands.first() {
437                    for item in items {
438                        match item {
439                            Object::String(string) => {
440                                let bytes = string.as_bytes().to_vec();
441                                self.show_text(&bytes)?;
442                            }
443                            Object::Integer(adjustment) => {
444                                self.adjust_text(*adjustment as f64);
445                            }
446                            Object::Real(adjustment) => self.adjust_text(*adjustment),
447                            _ => {}
448                        }
449                    }
450                }
451            }
452            b"Do" => {
453                if let Some(Object::Name(name)) = operands.first() {
454                    let name = name.clone();
455                    self.draw_image(&name)?;
456                }
457            }
458            b"BI" => {
459                skip_inline_image(parser)?;
460                self.report.note(operator);
461            }
462            _ => self.report.note(operator),
463        }
464        Ok(())
465    }
466
467    fn paint(&mut self, what: Paint, even_odd: bool) -> crate::Result<()> {
468        self.apply_pending_clip();
469        let ctm = self.state.ctm;
470        let scale = determinant_scale(ctm);
471        let polylines = self.path.flatten(ctm);
472        let painted = match what {
473            Paint::Fill | Paint::Both => true,
474            Paint::Stroke => false,
475        };
476        if painted && !polylines.is_empty() {
477            fill_polygons(
478                self.canvas,
479                &self.mask,
480                &polylines,
481                self.state.fill,
482                even_odd,
483                1.0,
484            );
485        }
486        if matches!(what, Paint::Stroke | Paint::Both) {
487            let mut stroked: Vec<Vec<Point>> = Vec::new();
488            for polyline in &polylines {
489                stroked.extend(dash_polyline(polyline, &self.state.dash, scale));
490            }
491            let outline = stroke_outline(
492                &stroked,
493                self.state.line_width * scale,
494                self.state.cap,
495                self.state.join,
496                self.state.miter_limit,
497            );
498            if !outline.is_empty() {
499                fill_polygons(
500                    self.canvas,
501                    &self.mask,
502                    &outline,
503                    self.state.stroke,
504                    false,
505                    1.0,
506                );
507            }
508        }
509        self.path = Path::new();
510        Ok(())
511    }
512
513    fn adjust_text(&mut self, adjustment: f64) {
514        let tx = -adjustment / 1000.0 * self.state.font_size * self.state.horizontal_scale;
515        self.state.text_matrix =
516            Matrix::new(1.0, 0.0, 0.0, 1.0, tx, 0.0).multiply(self.state.text_matrix);
517    }
518
519    fn show_text(&mut self, bytes: &[u8]) -> crate::Result<()> {
520        let Some(font) = self.state.font.clone() else {
521            return Ok(());
522        };
523        for &code in bytes {
524            if let Some(glyph) = font.glyph(code) {
525                if !glyph.contours.is_empty() {
526                    let scale = Matrix::new(
527                        self.state.font_size * self.state.horizontal_scale,
528                        0.0,
529                        0.0,
530                        self.state.font_size,
531                        0.0,
532                        self.state.rise,
533                    );
534                    let transform = scale
535                        .multiply(self.state.text_matrix)
536                        .multiply(self.state.ctm);
537                    let polygons: Vec<Vec<Point>> = glyph
538                        .contours
539                        .iter()
540                        .map(|contour| {
541                            contour
542                                .iter()
543                                .map(|point| transform.apply(*point))
544                                .collect()
545                        })
546                        .collect();
547                    fill_polygons(
548                        self.canvas,
549                        &self.mask,
550                        &polygons,
551                        self.state.fill,
552                        false,
553                        1.0,
554                    );
555                }
556            }
557            let mut advance = font.advance(code) * self.state.font_size + self.state.char_spacing;
558            if code == b' ' {
559                advance += self.state.word_spacing;
560            }
561            advance *= self.state.horizontal_scale;
562            self.state.text_matrix =
563                Matrix::new(1.0, 0.0, 0.0, 1.0, advance, 0.0).multiply(self.state.text_matrix);
564        }
565        Ok(())
566    }
567
568    fn draw_image(&mut self, name: &[u8]) -> crate::Result<()> {
569        let Some(resources) = self.resources.clone() else {
570            self.report.note(b"Do");
571            return Ok(());
572        };
573        let xobjects = match resolve(self.document, resources.get(b"XObject")) {
574            Ok(Object::Dictionary(xobjects)) => xobjects,
575            _ => {
576                self.report.note(b"Do");
577                return Ok(());
578            }
579        };
580        let entry = match xobjects.get(name) {
581            Some(entry) => entry.clone(),
582            None => {
583                self.report.note(b"Do");
584                return Ok(());
585            }
586        };
587        let object = resolve(self.document, Some(&entry))?;
588        let Object::Stream(stream) = object else {
589            self.report.note(b"Do");
590            return Ok(());
591        };
592        if !matches!(stream.dict().get(b"Subtype"), Some(Object::Name(name)) if name == b"Image") {
593            self.report.note(b"Do");
594            return Ok(());
595        }
596        match Image::from_stream(self.document, &stream) {
597            Ok(image) => {
598                image.paint(self.canvas, &self.mask, self.state.ctm);
599            }
600            // An image we cannot decode is reported, not fatal: the rest of the
601            // page still renders.
602            Err(_) => self.report.note(b"Do"),
603        }
604        Ok(())
605    }
606
607    fn load_font(&mut self, name: &[u8]) -> Option<Font> {
608        let resources = self.resources.clone()?;
609        let fonts = match resolve(self.document, resources.get(b"Font")) {
610            Ok(Object::Dictionary(fonts)) => fonts,
611            _ => return None,
612        };
613        let entry = fonts.get(name)?.clone();
614        let font_object = resolve(self.document, Some(&entry)).ok()?;
615        let Object::Dictionary(font) = font_object else {
616            return None;
617        };
618        let encoding = self.encoding_for(&font);
619        if let Some(descriptor) = font.get(b"FontDescriptor") {
620            let descriptor = resolve(self.document, Some(descriptor)).ok()?;
621            if let Object::Dictionary(descriptor) = descriptor {
622                if let Some(font_file) = descriptor.get(b"FontFile2") {
623                    let data = match font_file {
624                        Object::Reference(id) => self.document.stream_data(*id).ok(),
625                        _ => None,
626                    };
627                    if let Some(data) = data {
628                        if let Some(font) = Font::true_type(encoding.clone(), data) {
629                            return Some(font);
630                        }
631                    }
632                }
633            }
634        }
635        Some(Font::builtin(encoding))
636    }
637
638    fn encoding_for(&self, font: &Dictionary) -> Encoding {
639        let Some(encoding_object) = font.get(b"Encoding") else {
640            return Encoding::standard();
641        };
642        let Ok(encoding_object) = resolve(self.document, Some(encoding_object)) else {
643            return Encoding::standard();
644        };
645        let mut encoding = Encoding::from_object(Some(&encoding_object)).unwrap_or_default();
646        if let Object::Dictionary(dict) = &encoding_object {
647            if let Some(differences) = dict.get(b"Differences") {
648                if let Ok(Object::Array(items)) = resolve(self.document, Some(differences)) {
649                    let _ = encoding.apply_differences(&items);
650                }
651            }
652        }
653        encoding
654    }
655
656    fn apply_pending_clip(&mut self) {
657        let Some(even_odd) = self.pending_clip.take() else {
658            return;
659        };
660        let polylines = self.path.flatten(self.state.ctm);
661        let mask = clip_mask(
662            self.canvas.width(),
663            self.canvas.height(),
664            &polylines,
665            even_odd,
666        );
667        self.mask.intersect(&mask);
668    }
669}
670
671#[derive(Debug, Clone, Copy, PartialEq, Eq)]
672enum Paint {
673    Fill,
674    Stroke,
675    Both,
676}
677
678fn determinant_scale(ctm: Matrix) -> f64 {
679    let determinant = ctm.a * ctm.d - ctm.b * ctm.c;
680    determinant.abs().sqrt()
681}
682
683fn number(operands: &[Object], index: usize) -> f64 {
684    operands.get(index).and_then(Object::as_real).unwrap_or(0.0)
685}
686
687fn integer(operands: &[Object], index: usize) -> i64 {
688    operands
689        .get(index)
690        .and_then(Object::as_integer)
691        .unwrap_or(0)
692}
693
694fn matrix_operand(operands: &[Object]) -> Option<Matrix> {
695    if operands.len() < 6 {
696        return None;
697    }
698    Some(Matrix::new(
699        number(operands, 0),
700        number(operands, 1),
701        number(operands, 2),
702        number(operands, 3),
703        number(operands, 4),
704        number(operands, 5),
705    ))
706}
707
708/// The `pair`th point in the operands, if all of its numbers are there.
709///
710/// Callers name a *point*, not a number: `c` takes three of them at slots 0, 1
711/// and 2, which are the numbers `(0, 1)`, `(2, 3)` and `(4, 5)`. Reading the
712/// slot as a number index silently turned every curve's last control point into
713/// its end point, which is what a wrong index looks like on the page.
714fn point_operand(operands: &[Object], pair: usize) -> Option<Point> {
715    let start = pair * 2;
716    if operands.len() < start + 2 {
717        return None;
718    }
719    Some(Point::new(
720        number(operands, start),
721        number(operands, start + 1),
722    ))
723}
724
725fn dash_operand(operands: &[Object]) -> Dash {
726    let pattern = match operands.first() {
727        Some(Object::Array(items)) => items
728            .iter()
729            .filter_map(Object::as_real)
730            .collect::<Vec<f64>>(),
731        _ => Vec::new(),
732    };
733    let phase = number(operands, 1);
734    Dash { pattern, phase }
735}
736
737/// Skip inline image data (`BI` … `EI`), which cannot be tokenised.
738fn skip_inline_image(parser: &mut Parser<'_>) -> crate::Result<()> {
739    let start = parser.raw_position();
740    let content = parser.content();
741    let found = content
742        .get(start..)
743        .and_then(|rest| find_operator(rest, b"EI"))
744        .ok_or_else(|| crate::Error::malformed("inline image without a closing EI"))?;
745    parser.seek(start + found + 2);
746    Ok(())
747}
748
749fn find_operator(haystack: &[u8], needle: &[u8]) -> Option<usize> {
750    let mut index = 0;
751    while index + needle.len() <= haystack.len() {
752        if &haystack[index..index + needle.len()] == needle {
753            let delimiter = |byte: u8| is_whitespace(byte) || is_delimiter(byte);
754            let before_ok = index == 0 || delimiter(haystack[index - 1]);
755            let after = index + needle.len();
756            let after_ok = after >= haystack.len() || delimiter(haystack[after]);
757            if before_ok && after_ok {
758                return Some(index);
759            }
760        }
761        index += 1;
762    }
763    None
764}
765
766#[cfg(test)]
767mod tests {
768    use super::{dash_operand, Report};
769    use pdf2::Object;
770
771    #[test]
772    fn reports_collect_operator_counts_in_order() {
773        let mut report = Report::default();
774        report.note(b"Tj");
775        report.note(b"Tj");
776        report.note(b"Do");
777        assert_eq!(report.unsupported_total(), 3);
778        assert_eq!(report.unsupported.get("Tj"), Some(&2));
779        assert_eq!(report.to_string(), "Do×1, Tj×2");
780    }
781
782    #[test]
783    fn dash_operands_default_to_solid() {
784        assert!(dash_operand(&[]).is_solid());
785        let dash = dash_operand(&[
786            Object::array([Object::Integer(4), Object::Integer(2)]),
787            Object::Integer(1),
788        ]);
789        assert_eq!(dash.pattern, vec![4.0, 2.0]);
790        assert_eq!(dash.phase, 1.0);
791    }
792}