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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Pq7HyDBXygTf7jcqdsjcfn
This commit is contained in:
mtlcl410andClaude Opus 5.5 committed 2026-11-05 11:16:00 +08:00
1 parent 0b2c452bb1
commit 52131ba093
3 files changed
+232 -130

No files matched your search

+23 -13
View File
@@ -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> {
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);
+61 -3
View File
@@ -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<String> {
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<String> {
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<String> = 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<String> = 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"]);
}
+148 -114
View File
@@ -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<String>,
}
/// 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<ObjRef>,
/// 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<ObjRef, usize>,
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<Object> = 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<Object> {
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<String> {
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<String>) {
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<String> {
let Some(bm) = gs.get(b"BM").map(|b| doc.resolve(b)) else { return Vec::new() };
let names: Vec<Vec<u8>> = 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<String> {
let names: Vec<Vec<u8>> = 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(),