From 52131ba093e5714457dd7d7078877163dec5a52b Mon Sep 17 00:00:00 2001 From: mtlcl410 Date: Thu, 5 Nov 2026 11:16:00 +0800 Subject: [PATCH] M11: 6.2.10 reads blend modes only from graphics states, wants a device-independent /CS and a profiled intent, rereads shallower Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Pq7HyDBXygTf7jcqdsjcfn --- crates/preflight/src/lib.rs | 36 ++-- crates/preflight/src/tests.rs | 64 ++++++- crates/preflight/src/transparency.rs | 262 +++++++++++++++------------ 3 files changed, 232 insertions(+), 130 deletions(-) diff --git a/crates/preflight/src/lib.rs b/crates/preflight/src/lib.rs index 6667360fc2..5a71e86a9a 100644 --- a/crates/preflight/src/lib.rs +++ b/crates/preflight/src/lib.rs @@ -117,7 +117,7 @@ pub const WORDINGS: &[&str] = &[ // The document as a whole. "The document is encrypted", "Device colour is used, but there is no PDF/A output intent", - "Page {} has transparency but no blending colour space or PDF/A output intent", + "Page {} has transparency but no device-independent blending colour space or PDF/A output intent", "A graphics state uses the blend mode {}, which ISO 32000-1 doesn't define", "DeviceCMYK is used: it needs a CMYK output intent (not added automatically)", "DeviceCMYK is used, but the PDF/A output intent isn't a CMYK profile", @@ -213,6 +213,19 @@ fn dict_of(o: &Object) -> Option<&Dict> { } } +/// Whether the document has a PDF/A output intent whose `/DestOutputProfile` is a stream: one with +/// a null or missing profile describes no colour, so it doesn't stand in for a blending colour +/// space (6.2.10). +fn pdfa_intent_has_profile(doc: &Document) -> bool { + let cat = catalog(doc); + let list = cat.get(b"OutputIntents").map(|o| doc.resolve(o)).and_then(|o| o.as_array().cloned()).unwrap_or_default(); + list.iter().any(|oi| { + let oi = doc.resolve(oi); + let Some(d) = oi.as_dict() else { return false }; + d.name(b"S") == Some(b"GTS_PDFA1") && d.get(b"DestOutputProfile").is_some_and(|p| matches!(&*doc.resolve(p), Object::Stream(_))) + }) +} + fn has_pdfa_intent(doc: &Document) -> bool { pdfa_intent_profile(doc).is_some() } @@ -517,20 +530,17 @@ pub fn verify(doc: &Document, level: Level) -> Vec { issue("6.5.2", "Page {} has additional actions", Some((i + 1).to_string()), Some(i), true); } } - // 6.2.10: blend modes are those ISO 32000-1 defines. - for (_, o) in &objs { - for name in transparency::unknown_blend_modes(doc, o) { + // 6.2.10: blend modes are those ISO 32000-1 defines, and without a PDF/A output intent (one with + // a profile) a page with transparency names a blending colour space. + let intent = pdfa_intent_has_profile(doc); + for (i, p) in pages.iter().enumerate() { + let painting = transparency::page_painting(doc, &p.dict); + for name in painting.unknown_blend_modes { issue("6.2.10", "A graphics state uses the blend mode {}, which ISO 32000-1 doesn't define", Some(name), None, false); } - } - // 6.2.10: without a PDF/A output intent, a page with transparency names its blending colour - // space. - if !has_pdfa_intent(doc) { - for (i, p) in pages.iter().enumerate() { - if transparency::page_has_transparency(doc, &p.dict) && !transparency::page_names_blending_space(doc, &p.dict) { - let n = Some((i + 1).to_string()); - issue("6.2.10", "Page {} has transparency but no blending colour space or PDF/A output intent", n, Some(i), false); - } + if painting.transparency && !intent && !transparency::page_names_blending_space(doc, &p.dict) { + let n = Some((i + 1).to_string()); + issue("6.2.10", "Page {} has transparency but no device-independent blending colour space or PDF/A output intent", n, Some(i), false); } } check_objects(doc, level, &objs, &page_of, &mut issue); diff --git a/crates/preflight/src/tests.rs b/crates/preflight/src/tests.rs index c16aec14e9..07237c169e 100644 --- a/crates/preflight/src/tests.rs +++ b/crates/preflight/src/tests.rs @@ -513,7 +513,7 @@ endstream", } verify(&build(&objs, ""), Level::A2b).into_iter().filter(|i| i.clause == "6.2.10").map(|i| i.message).collect() }; - let said = ["Page 1 has transparency but no blending colour space or PDF/A output intent"]; + let said = ["Page 1 has transparency but no device-independent blending colour space or PDF/A output intent"]; let form = |dict: &str| format!("<< /Type /XObject /Subtype /Form /BBox [0 0 10 10] {dict} /Length 0 >>\nstream\n\nendstream"); let gs = |entries: &str| format!("/ExtGState << /G << {entries} >> >>"); for (what, resources, extra) in [ @@ -552,7 +552,11 @@ endstream", let extra: Vec<&str> = extra.iter().map(String::as_str).collect(); assert_eq!(blending(false, "", &resources, &extra), said, "{what}"); // A page group with a blending colour space, or a PDF/A output intent, satisfies the rule. - assert!(blending(false, "/Group << /S /Transparency /CS /DeviceRGB >>", &resources, &extra).is_empty(), "{what}: page /CS"); + assert!( + blending(false, "/Group << /S /Transparency /CS [/CalRGB << /WhitePoint [0.9505 1 1.089] >>] >>", &resources, &extra).is_empty(), + "{what}: page /CS" + ); + assert_eq!(blending(false, "/Group << /S /Transparency >>", &resources, &extra), said, "{what}: page group without /CS"); assert!(blending(true, "", &resources, &extra).is_empty(), "{what}: output intent"); } // Annotation appearances, as one stream or a dictionary of streams by state. @@ -595,7 +599,9 @@ endstream", #[test] fn blend_modes_are_the_ones_iso_32000_1_defines() { let modes = |resources: &str, extra: &[&str]| -> Vec { - let page = format!("<< /Type /Page /Parent 2 0 R /Group << /S /Transparency /CS /DeviceRGB >> /Resources << {resources} >> >>"); + let page = format!( + "<< /Type /Page /Parent 2 0 R /Group << /S /Transparency /CS [/CalRGB << /WhitePoint [0.9505 1 1.089] >>] >> /Resources << {resources} >> >>" + ); let mut objs: Vec<&str> = vec!["<< /Type /Catalog /Pages 2 0 R >>", "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 200 200] >>", &page]; objs.extend_from_slice(extra); @@ -608,3 +614,55 @@ fn blend_modes_are_the_ones_iso_32000_1_defines() { let all = "/Normal /Compatible /Multiply /Screen /Overlay /Darken /Lighten /ColorDodge /ColorBurn /HardLight /SoftLight /Difference /Exclusion /Hue /Saturation /Color /Luminosity"; assert!(modes(&format!("/ExtGState << /G << /BM [{all}] >> >>"), &[]).is_empty()); } + +/// 6.2.10's blending colour space is one PDF/A accepts without an output intent: not null, and +/// not a device space unless the page gives it a default (6.2.4.3). An output intent stands in +/// for it only with a profile. +#[test] +fn a_blending_space_is_device_independent_and_an_intent_has_a_profile() { + let page_said = ["Page 1 has transparency but no device-independent blending colour space or PDF/A output intent"]; + let check = |catalog_extra: &str, page_extra: &str, extra: &[&str]| -> Vec { + let catalog = format!("<< /Type /Catalog /Pages 2 0 R {catalog_extra} >>"); + let page = format!("<< /Type /Page /Parent 2 0 R {page_extra} >>"); + let mut objs: Vec<&str> = vec![&catalog, "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 200 200] >>", &page]; + objs.extend_from_slice(extra); + verify(&build(&objs, ""), Level::A2b).into_iter().filter(|i| i.clause == "6.2.10").map(|i| i.message).collect() + }; + let alpha = "/ExtGState << /G << /ca 0.5 >> >>"; + let page = |group: &str, colour_spaces: &str| format!("/Group << /S /Transparency {group} >> /Resources << {alpha} {colour_spaces} >>"); + assert_eq!(check("", &page("/CS null", ""), &[]), page_said, "a null /CS"); + assert_eq!(check("", &page("/CS 9 0 R", ""), &[]), page_said, "a /CS naming no object"); + for (device, default) in [("DeviceGray", "DefaultGray"), ("DeviceRGB", "DefaultRGB"), ("DeviceCMYK", "DefaultCMYK")] { + assert_eq!(check("", &page(&format!("/CS /{device}"), ""), &[]), page_said, "{device}"); + let defaults = format!("/ColorSpace << /{default} [/CalRGB << /WhitePoint [0.9505 1 1.089] >>] >>"); + assert!(check("", &page(&format!("/CS /{device}"), &defaults), &[]).is_empty(), "{device} with {default}"); + } + let intent = |profile: &str| format!("/OutputIntents [<< /Type /OutputIntent /S /GTS_PDFA1 /OutputConditionIdentifier (sRGB) {profile} >>]"); + let opaque_group = format!("/Resources << {alpha} >>"); + assert_eq!(check(&intent("/DestOutputProfile null"), &opaque_group, &[]), page_said, "a null profile"); + assert_eq!(check(&intent(""), &opaque_group, &[]), page_said, "no profile"); + assert!(check(&intent("/DestOutputProfile 4 0 R"), &opaque_group, &["<< /N 3 /Length 0 >>\nstream\n\nendstream"]).is_empty(), "a profile"); + // Private data is no graphics state: a /BM there is not a blend mode. + assert!(check("/PieceInfo << /App << /Private << /BM /Bookkeeping >> >> >>", "", &[]).is_empty(), "/PieceInfo"); +} + +/// A form XObject first reached at the depth limit, where its resources go unread, is read again +/// when a shallower place names it, so what it holds is not missed. +#[test] +fn transparency_reached_first_too_deep_is_found_from_a_shallower_place() { + let form = |dict: &str| format!("<< /Type /XObject /Subtype /Form /BBox [0 0 10 10] {dict} /Length 0 >>\nstream\n\nendstream"); + // A chain of 32 forms, objects 4 to 35, the last naming form 36, which holds a translucent + // graphics state; the page names the chain first and form 36 after it. + let mut objs: Vec = vec![ + "<< /Type /Catalog /Pages 2 0 R >>".to_owned(), + "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 200 200] >>".to_owned(), + "<< /Type /Page /Parent 2 0 R /Resources << /XObject << /A 4 0 R /B 36 0 R >> >> >>".to_owned(), + ]; + for n in 4..=35 { + objs.push(form(&format!("/Resources << /XObject << /X {} 0 R >> >>", n + 1))); + } + objs.push(form("/Resources << /ExtGState << /G << /ca 0.5 >> >> >>")); + let objs: Vec<&str> = objs.iter().map(String::as_str).collect(); + let said: Vec = verify(&build(&objs, ""), Level::A2b).into_iter().filter(|i| i.clause == "6.2.10").map(|i| i.message).collect(); + assert_eq!(said, ["Page 1 has transparency but no device-independent blending colour space or PDF/A output intent"]); +} diff --git a/crates/preflight/src/transparency.rs b/crates/preflight/src/transparency.rs index a906396fb4..7b3e83784c 100644 --- a/crates/preflight/src/transparency.rs +++ b/crates/preflight/src/transparency.rs @@ -1,6 +1,7 @@ //! PDF/A-2 6.2.10: a graphics state's blend mode is one ISO 32000-1 defines, and a page that //! contains transparency, in a file without a PDF/A output intent, names its blending colour -//! space: its `/Group` dictionary has a `/CS` entry. +//! space: its `/Group` dictionary has a `/CS` entry, which as any colour space in such a file is +//! not a device space without a default (6.2.4.3). //! //! A page contains transparency when something its resources reach can paint transparently (ISO //! 32000-1 11.6.4.4 to 11.6.6): a graphics state with a constant alpha (`/CA`, `/ca`) below 1, @@ -8,9 +9,10 @@ //! (`/SMask`, or `/SMaskInData` above 0); or a transparency group XObject. The resources looked //! through are the page's own, those of the form XObjects, tiling patterns and Type 3 fonts they //! hold, and those of the appearance streams of the page's annotations. Whether the content uses -//! a resource is not asked: a resource a page holds is one it may paint with. +//! a resource is not asked: a resource a page holds is one it may paint with. Blend modes are read +//! from the same graphics states, so private data (`/PieceInfo`) is never taken for one. -use std::collections::HashSet; +use std::collections::HashMap; use pdfcraft_cos::{Dict, Document, ObjRef, Object}; @@ -19,132 +21,197 @@ use pdfcraft_cos::{Dict, Document, ObjRef, Object}; const MAX_VISITS: usize = 4096; /// How deep resources nest (a form XObject in a form XObject, ...). const MAX_DEPTH: usize = 32; +/// The resource categories that hold what a page paints with, read in this order. +const CATEGORIES: [&[u8]; 4] = [b"ExtGState", b"XObject", b"Pattern", b"Font"]; -/// Whether the page `page` contains transparency. -pub(crate) fn page_has_transparency(doc: &Document, page: &Dict) -> bool { - let mut walk = Walk { doc, seen: HashSet::new(), visits: 0 }; - if page.get(b"Resources").is_some_and(|r| walk.resources(r, 0)) { - return true; - } - let Some(annots) = page.get(b"Annots").map(|a| doc.resolve(a)) else { return false }; - let Some(annots) = annots.as_array() else { return false }; - annots.iter().any(|a| { - let a = doc.resolve(a); - let Some(ap) = a.as_dict().and_then(|a| a.get(b"AP")).map(|ap| doc.resolve(ap)) else { return false }; - let Some(ap) = ap.as_dict() else { return false }; - // Each appearance (normal, rollover, down) is a stream, or a dictionary of streams by state. - ap.iter().any(|(_, v)| match &*doc.resolve(v) { - Object::Stream(_) => walk.xobject(v, 0), - Object::Dict(states) => states.iter().any(|(_, s)| walk.xobject(s, 0)), - _ => false, - }) - }) +/// What the graphics a page's resources reach paint with. +#[derive(Debug, Default)] +pub(crate) struct Painting { + /// Something paints transparently. + pub(crate) transparency: bool, + /// The blend modes graphics states name that ISO 32000-1 doesn't define. + pub(crate) unknown_blend_modes: Vec, } -/// Whether `page` names its blending colour space: a `/Group` dictionary with a `/CS` entry. +/// What the page `page` paints with: its resources, and the appearance streams of its +/// annotations. +pub(crate) fn page_painting(doc: &Document, page: &Dict) -> Painting { + let mut walk = Walk { doc, seen: HashMap::new(), visits: 0, found: Painting::default() }; + if let Some(r) = page.get(b"Resources") { + walk.resources(r, 0); + } + let annots = page.get(b"Annots").map(|a| doc.resolve(a)); + for a in annots.as_deref().and_then(Object::as_array).into_iter().flatten() { + let a = doc.resolve(a); + let Some(ap) = a.as_dict().and_then(|a| a.get(b"AP")).map(|ap| doc.resolve(ap)) else { continue }; + let Some(ap) = ap.as_dict() else { continue }; + // Each appearance (normal, rollover, down) is a stream, or a dictionary of streams by state. + for (_, v) in ap.iter() { + match &*doc.resolve(v) { + Object::Stream(_) => walk.xobject(v, 0), + Object::Dict(states) => { + for (_, s) in states.iter() { + walk.xobject(s, 0); + } + } + _ => {} + } + } + } + walk.found +} + +/// Whether `page` names a blending colour space PDF/A accepts without an output intent: its +/// `/Group` has a `/CS` that is not null and not a device colour space, unless the page's +/// resources give that device space a default (`DefaultGray`, `DefaultRGB`, `DefaultCMYK`), as +/// PDF/A-2 6.2.4.3 asks of any device colour. pub(crate) fn page_names_blending_space(doc: &Document, page: &Dict) -> bool { - page.get(b"Group").map(|g| doc.resolve(g)).is_some_and(|g| g.as_dict().is_some_and(|g| g.get(b"CS").is_some())) + let group = page.get(b"Group").map(|g| doc.resolve(g)); + let Some(cs) = group.as_deref().and_then(Object::as_dict).and_then(|g| g.get(b"CS")).map(|c| doc.resolve(c)) else { return false }; + let default: &[u8] = match &*cs { + Object::Null => return false, + Object::Name(n) if n == b"DeviceGray" => b"DefaultGray", + Object::Name(n) if n == b"DeviceRGB" => b"DefaultRGB", + Object::Name(n) if n == b"DeviceCMYK" => b"DefaultCMYK", + _ => return true, + }; + let resources = page.get(b"Resources").map(|r| doc.resolve(r)); + let spaces = resources.as_deref().and_then(Object::as_dict).and_then(|r| r.get(b"ColorSpace")).map(|c| doc.resolve(c)); + spaces.as_deref().and_then(Object::as_dict).is_some_and(|s| s.get(default).is_some()) } struct Walk<'a> { doc: &'a Document, - /// The indirect objects already read: each is looked at once, and a cycle ends there. - seen: HashSet, + /// The indirect objects already read, each with the shallowest depth it was read at: an + /// object is read again only from a shallower place, so a cycle ends and a deep first visit + /// doesn't hide what a shallower one would read. + seen: HashMap, visits: usize, + found: Painting, } impl Walk<'_> { - /// Whether `o` may be read: within the budget, and an indirect object not read before. - fn enter(&mut self, o: &Object) -> bool { - if self.visits >= MAX_VISITS { + /// Whether `o`, reached `depth` levels down, may be read: within the budget and the depth, and + /// an indirect object not read before from as shallow a place. + fn enter(&mut self, o: &Object, depth: usize) -> bool { + if self.visits >= MAX_VISITS || depth > MAX_DEPTH { return false; } + if let Object::Ref(r) = o { + if self.seen.get(r).is_some_and(|&d| d <= depth) { + return false; + } + self.seen.insert(*r, depth); + } self.visits += 1; - match o { - Object::Ref(r) => self.seen.insert(*r), - _ => true, + true + } + + fn resources(&mut self, r: &Object, depth: usize) { + if !self.enter(r, depth) { + return; + } + let doc = self.doc; + let Some(res) = doc.resolve(r).as_dict().cloned() else { return }; + for category in CATEGORIES { + // Once the budget is spent nothing more is read, so nothing more is gathered either. + if self.visits >= MAX_VISITS { + return; + } + let entries: Vec = res + .get(category) + .map(|d| doc.resolve(d)) + .and_then(|d| d.as_dict().map(|d| d.iter().map(|(_, v)| v.clone()).collect())) + .unwrap_or_default(); + for v in &entries { + match category { + b"ExtGState" => self.ext_gstate(v, depth), + b"XObject" => self.xobject(v, depth), + b"Pattern" => self.pattern(v, depth), + _ => self.type3(v, depth), + } + } } } - fn resources(&mut self, r: &Object, depth: usize) -> bool { - if depth > MAX_DEPTH || !self.enter(r) { - return false; + /// A graphics state (ISO 32000-1 Table 58): whether it paints transparently, and the blend + /// modes it names that ISO 32000-1 doesn't define. + fn ext_gstate(&mut self, g: &Object, depth: usize) { + if !self.enter(g, depth) { + return; } let doc = self.doc; - let Some(res) = doc.resolve(r).as_dict().cloned() else { return false }; - let entries = |key: &[u8]| -> Vec { - res.get(key).map(|d| doc.resolve(d)).and_then(|d| d.as_dict().map(|d| d.iter().map(|(_, v)| v.clone()).collect())).unwrap_or_default() - }; - entries(b"ExtGState").iter().any(|g| self.ext_gstate(g)) - || entries(b"XObject").iter().any(|x| self.xobject(x, depth)) - || entries(b"Pattern").iter().any(|p| self.pattern(p, depth)) - || entries(b"Font").iter().any(|f| self.type3(f, depth)) - } - - /// A graphics state that paints transparently (ISO 32000-1 Table 58). - fn ext_gstate(&mut self, g: &Object) -> bool { - if !self.enter(g) { - return false; - } - let g = self.doc.resolve(g); - let Some(g) = g.as_dict() else { return false }; - let doc = self.doc; + let g = doc.resolve(g); + let Some(g) = g.as_dict() else { return }; let below_one = |key: &[u8]| g.get(key).and_then(|v| doc.resolve(v).as_f64()).is_some_and(|a| a < 1.0); - let blend = g.get(b"BM").map(|b| doc.resolve(b)).is_some_and(|b| blends(doc, &b)); + let bm = g.get(b"BM").map(|b| doc.resolve(b)); + let blend = bm.as_deref().is_some_and(|b| blends(doc, b)); let mask = g.get(b"SMask").map(|m| doc.resolve(m)).is_some_and(|m| !matches!(&*m, Object::Name(n) if n == b"None")); - below_one(b"CA") || below_one(b"ca") || blend || mask + self.found.transparency |= below_one(b"CA") || below_one(b"ca") || blend || mask; + for name in bm.as_deref().map(|b| unknown_blend_modes(doc, b)).unwrap_or_default() { + if !self.found.unknown_blend_modes.contains(&name) { + self.found.unknown_blend_modes.push(name); + } + } } /// An image with a soft mask, or a form XObject that is a transparency group or holds /// transparency in its resources. - fn xobject(&mut self, x: &Object, depth: usize) -> bool { - if !self.enter(x) { - return false; + fn xobject(&mut self, x: &Object, depth: usize) { + if !self.enter(x, depth) { + return; } let doc = self.doc; let x = doc.resolve(x); - let Object::Stream(s) = &*x else { return false }; + let Object::Stream(s) = &*x else { return }; let d = &s.dict; if d.name(b"Subtype") == Some(b"Image") { let soft_mask = d.get(b"SMask").is_some_and(|m| matches!(&*doc.resolve(m), Object::Stream(_))); let in_data = d.get(b"SMaskInData").and_then(|v| doc.resolve(v).as_int()).is_some_and(|v| v > 0); - return soft_mask || in_data; + self.found.transparency |= soft_mask || in_data; + return; } let group = d.get(b"Group").map(|g| doc.resolve(g)).is_some_and(|g| g.as_dict().is_some_and(|g| g.name(b"S") == Some(b"Transparency"))); - group || d.get(b"Resources").is_some_and(|r| self.resources(r, depth + 1)) + self.found.transparency |= group; + if let Some(r) = d.get(b"Resources") { + self.resources(r, depth + 1); + } } /// A tiling pattern's resources, or a shading pattern's graphics state. - fn pattern(&mut self, p: &Object, depth: usize) -> bool { - if !self.enter(p) { - return false; + fn pattern(&mut self, p: &Object, depth: usize) { + if !self.enter(p, depth) { + return; } - let doc = self.doc; - let p = doc.resolve(p); + let p = self.doc.resolve(p); let Some(d) = (match &*p { Object::Stream(s) => Some(&s.dict), Object::Dict(d) => Some(d), _ => None, }) else { - return false; + return; }; - let state = d.get(b"ExtGState").cloned(); - let resources = d.get(b"Resources").cloned(); - state.is_some_and(|g| self.ext_gstate(&g)) || resources.is_some_and(|r| self.resources(&r, depth + 1)) + if let Some(g) = d.get(b"ExtGState") { + self.ext_gstate(g, depth + 1); + } + if let Some(r) = d.get(b"Resources") { + self.resources(r, depth + 1); + } } /// A Type 3 font's resources, which its glyph procedures paint with. - fn type3(&mut self, f: &Object, depth: usize) -> bool { - if !self.enter(f) { - return false; + fn type3(&mut self, f: &Object, depth: usize) { + if !self.enter(f, depth) { + return; } let f = self.doc.resolve(f); - let Some(d) = f.as_dict() else { return false }; + let Some(d) = f.as_dict() else { return }; if d.name(b"Subtype") != Some(b"Type3") { - return false; + return; + } + if let Some(r) = d.get(b"Resources") { + self.resources(r, depth + 1); } - let resources = d.get(b"Resources").cloned(); - resources.is_some_and(|r| self.resources(&r, depth + 1)) } } @@ -169,43 +236,10 @@ const BLEND_MODES: &[&[u8]] = &[ b"Luminosity", ]; -/// The blend modes ISO 32000-1 doesn't define that the object `o` names in a `/BM` entry: its own, -/// or one of a dictionary written inside it (a page's resources hold their graphics states -/// directly), within [`MAX_DEPTH`]. -pub(crate) fn unknown_blend_modes(doc: &Document, o: &Object) -> Vec { - let mut out = Vec::new(); - blend_modes_within(doc, o, 0, &mut out); - out -} - -fn blend_modes_within(doc: &Document, o: &Object, depth: usize, out: &mut Vec) { - if depth > MAX_DEPTH { - return; - } - let d = match o { - Object::Dict(d) => d, - Object::Stream(s) => &s.dict, - Object::Array(a) => { - for v in a { - blend_modes_within(doc, v, depth + 1, out); - } - return; - } - _ => return, - }; - out.extend(unknown_in(doc, d)); - for (k, v) in d.iter() { - if k != b"BM" { - blend_modes_within(doc, v, depth + 1, out); - } - } -} - -/// The names in a graphics state's `/BM` (a name, or an array of them) that are not blend modes -/// ISO 32000-1 defines. -fn unknown_in(doc: &Document, gs: &Dict) -> Vec { - let Some(bm) = gs.get(b"BM").map(|b| doc.resolve(b)) else { return Vec::new() }; - let names: Vec> = match &*bm { +/// The names in a `/BM` value (a name, or an array of them) that are not blend modes ISO 32000-1 +/// defines. +fn unknown_blend_modes(doc: &Document, bm: &Object) -> Vec { + let names: Vec> = match bm { Object::Name(n) => vec![n.clone()], Object::Array(a) => a.iter().filter_map(|m| doc.resolve(m).as_name().map(<[u8]>::to_vec)).collect(), _ => Vec::new(),