use super::*; /// A part's relationships with full type URIs. `Ok(vec![])` when it has none; an error when the /// rels part is damaged or too large (its part then can't be kept faithfully). fn raw_rels(cx: &mut Ctx<'_>, part: &str) -> Result, String> { let name = rels_part_name(part); let bytes = match cx.pkg.read_limited(&name, MAX_META) { Ok(Some(b)) => b, Ok(None) => return Ok(vec![]), Err(e) => return Err(e.to_string()), }; let root = xml::parse(&bytes).map_err(|e| format!("{name}: {e}"))?; let (dir, _) = package::split_dir(part); let mut out = vec![]; for r in root.kids("Relationship") { if out.len() >= MAX_RELS { return Err(format!("{name}: too many relationships")); } let (Some(id), Some(target)) = (r.attr("Id"), r.attr("Target")) else { continue }; let external = r.attr("TargetMode").is_some_and(|m| m.eq_ignore_ascii_case("External")); out.push(PreservedRel { id: id.to_string(), rel_type: r.attr("Type").unwrap_or("").to_string(), target: if external { target.to_string() } else { package::resolve(dir, target) }, external, }); } Ok(out) } // ---------------------------------------------------------------- reading /// The `` entries of the workbook that are chart sheets, each with the number of worksheets /// (model sheets) before it. fn chart_sheet_entries<'a>(wb_xml: &'a xml::El, wb_rels: &[PreservedRel], file_to_model: &[Option]) -> Vec<(usize, &'a xml::El)> { let mut out = vec![]; let mut worksheets = 0usize; for (i, se) in wb_xml.child("sheets").into_iter().flat_map(|s| s.kids("sheet")).enumerate() { if file_to_model.get(i).copied().flatten().is_some() { worksheets += 1; } else if se.attr("id").and_then(|id| wb_rels.iter().find(|r| r.id == id)).is_some_and(|r| is_kind(r, &["chartsheet"])) { out.push((worksheets, se)); } } out } /// Collects kept content while a package is read. pub struct KeptReader { on: bool, strict: bool, defaults: HashMap, overrides: HashMap, budget: usize, parts_left: usize, } impl KeptReader { pub fn new(cx: &mut Ctx<'_>) -> KeptReader { let mut k = KeptReader { on: true, strict: false, defaults: HashMap::new(), overrides: HashMap::new(), budget: kept_total(), parts_left: MAX_KEPT_PARTS, }; if let Ok(root) = raw_rels(cx, "") && root.iter().any(|r| r.rel_type.starts_with("http://purl.oclc.org/")) { k.on = false; k.strict = true; } match cx.pkg.read_limited("[Content_Types].xml", MAX_META).ok().flatten().and_then(|b| xml::parse(&b).ok()) { Some(types) => { for d in types.kids("Default") { if let (Some(e), Some(t)) = (d.attr("Extension"), d.attr("ContentType")) { k.defaults.insert(e.to_ascii_lowercase(), t.to_string()); } } for o in types.kids("Override") { if let (Some(p), Some(t)) = (o.attr("PartName"), o.attr("ContentType")) { k.overrides.insert(normalize(p), t.to_string()); } } } None => k.on = false, } k } fn content_type(&self, part: &str) -> Option { let key = normalize(part); if let Some(t) = self.overrides.get(&key) { return Some(t.clone()); } let (_, file) = package::split_dir(&key); let ext = file.rsplit_once('.').map(|(_, e)| e)?; self.defaults.get(ext).cloned() } /// The parts reachable from `root` that aren't in `seen` yet. Fails (and keeps nothing) when the /// graph reaches rewritten content, a missing or damaged part, or a size limit. fn closure(&mut self, cx: &mut Ctx<'_>, root: &PreservedRel, seen: &HashSet, through: &[&str]) -> Result, String> { if root.external { return Ok(vec![]); } let blocked = |r: &PreservedRel| rewritten(r) && !through.iter().any(|k| k.eq_ignore_ascii_case(kind(&r.rel_type))); if blocked(root) { return Err(format!("it refers to {}", kind(&root.rel_type))); } let mut parts = vec![]; let mut bytes = 0usize; let mut local: HashSet = HashSet::new(); let mut queue = VecDeque::from([(root.target.clone(), 0usize)]); while let Some((name, depth)) = queue.pop_front() { let key = normalize(&name); if seen.contains(&key) || !local.insert(key) { continue; } if depth > MAX_CHAIN { return Err("its relationships are nested too deeply".into()); } if parts.len() >= self.parts_left { return Err("it has too many parts".into()); } let content_type = self.content_type(&name).ok_or_else(|| format!("{name} has no content type"))?; let data = match cx.pkg.read_limited(&name, MAX_KEPT_PART) { Ok(Some(d)) => d, Ok(None) => return Err(format!("{name} is missing")), Err(e) => return Err(e.to_string()), }; bytes = bytes.saturating_add(data.len()); if bytes > self.budget { return Err("it is too large".into()); } let rels = raw_rels(cx, &name)?; for r in rels.iter().filter(|r| !r.external) { if blocked(r) { return Err(format!("it refers to {}", kind(&r.rel_type))); } queue.push_back((r.target.clone(), depth + 1)); } parts.push(PreservedPart { name, content_type, data: Arc::from(data), rels }); } self.budget = self.budget.saturating_sub(bytes); self.parts_left = self.parts_left.saturating_sub(parts.len()); Ok(parts) } /// Keeps a set of relationships (all or nothing) and the parts behind them. fn keep(&mut self, cx: &mut Ctx<'_>, p: &mut Preserved, roots: &[PreservedRel], seen: &mut HashSet) -> Result<(), String> { self.keep_through(cx, p, roots, seen, &[]) } /// [`Self::keep`] for roots whose graph may reach the rewritten kinds in `through`. fn keep_through( &mut self, cx: &mut Ctx<'_>, p: &mut Preserved, roots: &[PreservedRel], seen: &mut HashSet, through: &[&str], ) -> Result<(), String> { let mut new_parts: Vec = vec![]; let mut scratch = seen.clone(); for r in roots { let parts = self.closure(cx, r, &scratch, through)?; scratch.extend(parts.iter().map(|q| normalize(&q.name))); new_parts.extend(parts); } *seen = scratch; p.parts.extend(new_parts); for r in roots { if !p.rels.iter().any(|x| x.id == r.id) { p.rels.push(r.clone()); } } Ok(()) } /// Package-root and workbook-level content. pub fn workbook(&mut self, cx: &mut Ctx<'_>, wb_part: &str, wb_xml: &xml::El, file_to_model: &[Option]) -> Option> { if !self.on { let wb_rels = raw_rels(cx, wb_part).unwrap_or_default(); for (_, se) in chart_sheet_entries(wb_xml, &wb_rels, file_to_model) { cx.warn(format!("chart sheet \"{}\" was skipped and is not kept on save", se.attr("name").unwrap_or(""))); } if self.strict { cx.warn("unmodelled content of a Strict Open XML workbook (custom XML, links, controls…) is not kept on save"); } return None; } let mut p = Preserved::default(); let mut seen = HashSet::new(); // Package root: custom document properties, ribbon customisation, task panes. if let Ok(root) = raw_rels(cx, "") { for r in root.iter().filter(|r| is_kind(r, PACKAGE_ROOTS)) { let mut q = Preserved::default(); match self.keep(cx, &mut q, std::slice::from_ref(r), &mut seen) { Ok(()) => { p.parts.extend(q.parts); p.package_rels.extend(q.rels); } Err(why) => cx.warn(format!("{} was dropped: {why}", kind(&r.rel_type))), } } } let wb_rels = raw_rels(cx, wb_part).unwrap_or_default(); for r in wb_rels.iter().filter(|r| is_kind(r, WORKBOOK_ROOTS)) { if let Err(why) = self.keep(cx, &mut p, std::slice::from_ref(r), &mut seen) { cx.warn(format!("{} part {} was dropped: {why}", kind(&r.rel_type), r.target)); } } // Chart sheets: the sheet entry (name, state, position) plus the chart sheet part and the // drawing, chart, style and colour parts behind it. for (worksheets, se) in chart_sheet_entries(wb_xml, &wb_rels, file_to_model) { let name = se.attr("name").unwrap_or("").to_string(); let Some(r) = se.attr("id").and_then(|id| wb_rels.iter().find(|r| r.id == id)) else { continue }; match self.keep_through(cx, &mut p, std::slice::from_ref(r), &mut seen, CHART_SHEET_GRAPH) { Ok(()) => p.sheets.push(PreservedSheet { name, visibility: match se.attr("state") { Some("hidden") => Visibility::Hidden, Some("veryHidden") => Visibility::VeryHidden, _ => Visibility::Visible, }, rel_id: r.id.clone(), before: worksheets, sheet_id: se.attr_u32("sheetId").unwrap_or(0), }), Err(why) => cx.warn(format!("chart sheet \"{name}\" was dropped: {why}")), } } // Links to external workbooks: `[1]` in formulas is the position in , // so they are kept all together or not at all. let ids: Vec<&str> = wb_xml.child("externalReferences").map(|e| e.kids("externalReference").filter_map(|x| x.attr("id")).collect()).unwrap_or_default(); if !ids.is_empty() { let roots: Option> = ids.iter().map(|id| wb_rels.iter().find(|r| r.id == *id && is_kind(r, &["externalLink"])).cloned()).collect(); let kept = match roots { Some(roots) => self.keep(cx, &mut p, &roots, &mut seen), None => Err("a link has no part".into()), }; match kept { Ok(()) => { let mut x = format!(""); for id in &ids { let _ = write!(x, "", esc_attr(id)); } x.push_str(""); p.elements.push(PreservedXml { slot: "externalReferences".into(), xml: x }); cx.warn("links to external workbooks were kept; they are not followed or refreshed"); } Err(why) => cx.warn(format!("links to external workbooks were dropped: {why}")), } } // Excel trusts the saved cell values only when both are present; without them it // recalculates everything on open, and links into closed workbooks come back as errors. if let Some(v) = wb_xml.child("fileVersion") { let mut x = String::from(""); p.elements.push(PreservedXml { slot: "fileVersion".into(), xml: x }); } let calc_features = wb_xml .child("extLst") .and_then(|l| l.kids("ext").find(|e| e.attr("uri").is_some_and(|u| u.eq_ignore_ascii_case(CALC_FEATURES_URI)))) .and_then(|e| e.child("calcFeatures")); if let Some(c) = calc_features { let mut x = format!(""); for name in c.kids("feature").filter_map(|f| f.attr("name")) { let _ = write!(x, "", esc_attr(name)); } x.push_str(""); p.elements.push(PreservedXml { slot: "ext".into(), xml: x }); } (!p.is_empty()).then(|| Arc::new(p)) } /// Sheet-level content of the sheet part `part`. `controls` says which form controls the /// sheet reader modelled (their VML shapes are left out of the kept content) and whether the /// VML drawing holds others that only it lists. pub fn sheet(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str, controls: &crate::controls::ReadControls) -> Option> { if !self.on { return None; } let rels = match raw_rels(cx, part) { Ok(r) => r, Err(e) => { cx.warn(format!("sheet \"{name}\": relationships could not be read ({e}); unmodelled content was dropped")); return None; } }; let mut p = Preserved::default(); let mut seen = HashSet::new(); for r in rels.iter().filter(|r| is_kind(r, SHEET_ROOTS)) { if let Err(why) = self.keep(cx, &mut p, std::slice::from_ref(r), &mut seen) { cx.warn(format!("sheet \"{name}\": {} was dropped: {why}", kind(&r.rel_type))); } } // Notes have one VML drawing per sheet; another one holds the header and footer pictures. let vml_drawings = rels.iter().filter(|r| is_kind(r, &["vmlDrawing"])).count(); let notes = rels.iter().filter(|r| is_kind(r, &["comments"])).count(); if rels.iter().any(|r| is_kind(r, SHEET_ELEMENT_KINDS)) || vml_drawings > notes || controls.vml_only_unmodelled { self.sheet_elements(cx, part, name, &rels, &mut p, &mut seen, controls); } (!p.is_empty()).then(|| Arc::new(p)) } /// Keeps, in `p`, the parts sheet `name`'s XML points at that the model doesn't read: printer /// settings, the header/footer picture drawing, and the controls and embedded objects not in /// `controls.modelled`. What can't be kept is dropped with a warning. #[allow(clippy::too_many_arguments)] fn sheet_elements( &mut self, cx: &mut Ctx<'_>, part: &str, name: &str, rels: &[PreservedRel], p: &mut Preserved, seen: &mut HashSet, controls: &crate::controls::ReadControls, ) { let read_controls = &controls.modelled; let scan = match cx.pkg.read(part) { Ok(Some(bytes)) => scan_sheet(&bytes), _ => None, }; let Some(scan) = scan else { cx.warn(format!("sheet \"{name}\": controls and embedded objects could not be read and were dropped")); return; }; // Printer settings (a binary part per sheet) hang off . if let Some(id) = scan.page_setup.as_deref() && let Some(r) = rels.iter().find(|r| r.id == id && is_kind(r, &["printerSettings"])) { match self.keep(cx, p, std::slice::from_ref(r), seen) { Ok(()) => p.elements.push(PreservedXml { slot: "pageSetup".into(), xml: r.id.clone() }), Err(why) => cx.warn(format!("sheet \"{name}\": printer settings were dropped: {why}")), } } // Header and footer pictures (`&G`): a VML drawing of their own and the images it shows. // Kept here, then moved into the sheet's print settings (`hf_pictures::take_from_kept`); // a drawing that can't be modelled stays kept, byte for byte. if let Some(id) = scan.legacy_drawing_hf.as_deref() && scan.legacy_drawing.as_deref() != Some(id) && let Some(r) = rels.iter().find(|r| r.id == id && is_kind(r, &["vmlDrawing"])) { match self.keep_through(cx, p, std::slice::from_ref(r), seen, &["vmlDrawing"]) { Ok(()) => { let xml = format!("", esc_attr(&r.id)); p.elements.push(PreservedXml { slot: "legacyDrawingHF".into(), xml }); } Err(why) => cx.warn(format!("sheet \"{name}\": header and footer pictures were dropped: {why}")), } } // Form controls the sheet reader modelled are written from the model; the others stay. let mut frags: Vec<(String, String)> = scan .fragments .into_iter() .filter_map(|(slot, x)| if slot == "controls" { without_controls(&x, read_controls).map(|x| (slot, x)) } else { Some((slot, x)) }) .collect(); // Controls and OLE objects are drawn from shapes in the legacy VML drawing. Controls only // the drawing lists need it too, whether or not a `` element is left. if frags.iter().any(|(slot, _)| slot != "picture") || controls.vml_only_unmodelled { match self.vml(cx, rels, scan.legacy_drawing.as_deref(), seen, read_controls) { Ok((vml, parts)) => { p.parts.extend(parts); p.vml = Some(vml); } Err(why) => { cx.warn(format!("sheet \"{name}\": controls and embedded objects were dropped: {why}")); frags.retain(|(slot, _)| slot == "picture"); } } } for (slot, x) in frags { let mut ids = vec![]; let ok = map_rel_ids(&x, &mut |id| { ids.push(id.to_string()); Some(id.to_string()) }) .is_some(); let roots: Option> = ids.iter().map(|id| rels.iter().find(|r| r.id == *id).cloned()).collect(); let kept = match (ok, roots) { (true, Some(roots)) => self.keep(cx, p, &roots, seen), (false, _) => Err("its XML is damaged".into()), (_, None) => Err("it refers to a missing relationship".into()), }; match kept { Ok(()) => p.elements.push(PreservedXml { slot, xml: x }), Err(why) => cx.warn(format!("sheet \"{name}\": {slot} were dropped: {why}")), } } if p.elements.iter().any(|e| e.slot == "oleObjects" || e.slot == "controls") || (controls.vml_only_unmodelled && p.vml.is_some()) { cx.warn(format!("sheet \"{name}\": embedded objects and form controls are not shown; they are kept for saving")); } else { p.vml = None; } } /// The sheet's VML drawing without its notes and the form controls read into the model /// (GridCraft writes those), and the parts its shapes refer to (preview images). fn vml( &mut self, cx: &mut Ctx<'_>, rels: &[PreservedRel], rid: Option<&str>, seen: &mut HashSet, read_controls: &HashSet, ) -> Result<(PreservedPart, Vec), String> { let rel = rid.and_then(|id| rels.iter().find(|r| r.id == id && !r.external)).ok_or("the sheet has no VML drawing")?; // Charged to the kept total like any other part: many sheets can point at one highly // compressed VML drawing, and each keeps its own copy. if self.budget == 0 { return Err("it is too large".into()); } let limit = MAX_META.min(u64::try_from(self.budget).unwrap_or(u64::MAX)); let data = match cx.pkg.read_limited(&rel.target, limit) { Ok(Some(d)) => d, Ok(None) => return Err(format!("{} is missing", rel.target)), Err(IoError::TooLarge(_)) => return Err("it is too large".into()), Err(e) => return Err(e.to_string()), }; self.budget = self.budget.saturating_sub(data.len()); let text = String::from_utf8(data).map_err(|_| "the VML drawing is not UTF-8".to_string())?; let text = strip_shapes(&text, read_controls); let vrels = raw_rels(cx, &rel.target)?; let mut q = Preserved::default(); let roots: Vec = vrels.iter().filter(|r| !r.external).cloned().collect(); self.keep(cx, &mut q, &roots, seen)?; let vml = PreservedPart { name: rel.target.clone(), content_type: CT_VML.into(), data: Arc::from(text.into_bytes()), rels: vrels }; Ok((vml, q.parts)) } } /// What a sheet part holds for pass-through. struct SheetScan { /// (slot, XML with the namespace declarations it needs). fragments: Vec<(String, String)>, legacy_drawing: Option, /// The relationship id on `` (header and footer pictures). legacy_drawing_hf: Option, /// The relationship id on `` (printer settings). page_setup: Option, } /// Finds the sheet's ``, ``, `` (also inside /// ``) and the `` and `` ids. `None` when the XML is damaged. fn scan_sheet(bytes: &[u8]) -> Option { let data = xml::to_utf8(bytes); let text = std::str::from_utf8(&data).ok()?; let mut reader = Reader::from_str(text); let mut decls: Vec<(String, String)> = vec![]; let mut out = SheetScan { fragments: vec![], legacy_drawing: None, legacy_drawing_hf: None, page_setup: None }; let mut in_root = false; loop { let start = usize::try_from(reader.buffer_position()).ok()?; match reader.read_event().ok()? { Event::Eof => break, Event::Start(e) if !in_root => { in_root = true; for a in e.attributes().with_checks(false).flatten() { if let Some(p) = a.key.as_ref().strip_prefix(b"xmlns:") && let (Ok(p), Ok(v)) = (std::str::from_utf8(p), std::str::from_utf8(&a.value)) && !v.contains('"') { decls.push((p.to_string(), v.to_string())); } } } Event::Start(e) => { let local = e.local_name().as_ref().to_vec(); match local.as_slice() { b"pageSetup" => out.page_setup = rel_id_attr(&e), b"legacyDrawing" => out.legacy_drawing = rel_id_attr(&e), b"legacyDrawingHF" => out.legacy_drawing_hf = rel_id_attr(&e), _ => {} } reader.read_to_end(e.name()).ok()?; let end = usize::try_from(reader.buffer_position()).ok()?; let wanted = matches!(local.as_slice(), b"picture" | b"oleObjects" | b"controls" | b"AlternateContent"); if wanted && end.saturating_sub(start) <= MAX_FRAGMENT { let frag = text.get(start..end)?; push_fragment(&mut out, frag, &local, &decls); } } Event::Empty(e) if in_root => { let local = e.local_name().as_ref().to_vec(); if local == b"legacyDrawing" || local == b"legacyDrawingHF" || local == b"pageSetup" { let id = rel_id_attr(&e); match local.as_slice() { b"pageSetup" => out.page_setup = id, b"legacyDrawing" => out.legacy_drawing = id, _ => out.legacy_drawing_hf = id, } } else if local == b"picture" && let Some(frag) = text.get(start..usize::try_from(reader.buffer_position()).ok()?) { push_fragment(&mut out, frag, &local, &decls); } } Event::End(_) => break, _ => {} } } Some(out) } /// The `r:id` of an element (an `id` attribute with a namespace prefix). fn rel_id_attr(e: &BytesStart<'_>) -> Option { e.attributes() .with_checks(false) .flatten() .find(|a| a.key.local_name().as_ref() == b"id" && a.key.prefix().is_some()) .and_then(|a| String::from_utf8(a.value.to_vec()).ok()) } fn push_fragment(out: &mut SheetScan, frag: &str, local: &[u8], decls: &[(String, String)]) { let frag = with_decls(frag, decls); let slot = if local == b"AlternateContent" { // The kept element is the one the first choice holds. let Ok(el) = xml::parse(frag.as_bytes()) else { return }; match el.child("Choice").and_then(|c| c.children.first()) { Some(c) => c.name.clone(), None => return, } } else { String::from_utf8_lossy(local).into_owned() }; if SHEET_SLOTS.contains(&slot.as_str()) && !out.fragments.iter().any(|(s, _)| *s == slot) { out.fragments.push((slot, frag)); } } /// Adds the root's namespace declarations a fragment doesn't declare itself. fn with_decls(frag: &str, decls: &[(String, String)]) -> String { let Some(name_end) = frag.char_indices().skip(1).find(|(_, c)| c.is_whitespace() || *c == '/' || *c == '>').map(|(i, _)| i) else { return frag.to_string(); }; let head = frag.get(..frag.find('>').unwrap_or(frag.len())).unwrap_or(""); let mut add = String::new(); for (p, v) in decls { if !head.contains(&format!("xmlns:{p}=")) { let _ = write!(add, " xmlns:{p}=\"{v}\""); } } format!("{}{add}{}", frag.get(..name_end).unwrap_or(""), frag.get(name_end..).unwrap_or("")) } /// Byte ranges of the `…` (or self-closed) elements in VML text. pub(crate) fn shape_spans(vml: &str) -> Vec<(usize, usize)> { let mut spans = vec![]; let mut from = 0; while let Some(i) = vml.get(from..).and_then(|s| s.find("' || c == '/'); if !is_shape { from = after; continue; } let Some(tag_end) = vml.get(i..).and_then(|s| s.find('>')).map(|j| i + j + 1) else { break }; let end = if vml.get(..tag_end).is_some_and(|t| t.ends_with("/>")) { tag_end } else { match vml.get(tag_end..).and_then(|s| s.find("")) { Some(j) => tag_end + j + "".len(), None => break, } }; spans.push((i, end)); from = end; } spans } /// VML without its note shapes and the shapes numbered in `drop`, each judged as the control /// reader judges it, from the shape's own tags and never from text elsewhere in it: a note by its /// client data's `ObjectType` ([`crate::controls::is_note_data`]), its number from its `id`, else /// its `o:spid` ([`crate::controls::number_of`]). Each tag is read on its own ([`xml::first_start`]), /// so a caption's unclosed `
` doesn't hide the client data after it. A shape with no number /// that isn't a note is kept. fn strip_shapes(vml: &str, drop: &HashSet) -> String { let mut out = String::with_capacity(vml.len()); let mut last = 0; for (a, b) in shape_spans(vml) { let shape = vml.get(a..b).unwrap_or("").as_bytes(); let note = xml::first_start(shape, "ClientData").is_some_and(|d| crate::controls::is_note_data(&d)); let numbered = xml::first_start(shape, "shape").and_then(|s| crate::controls::number_of(&s)).is_some_and(|n| drop.contains(&n)); if note || numbered { out.push_str(vml.get(last..a).unwrap_or("")); last = b; } } out.push_str(vml.get(last..).unwrap_or("")); out } /// Shape numbers (`_x0000_s1025` → 1025) used in VML text. fn shape_numbers(vml: &str) -> Vec { vml.match_indices("_x0000_s") .filter_map(|(i, m)| { let digits: String = vml.get(i + m.len()..)?.chars().take_while(char::is_ascii_digit).take(18).collect(); digits.parse().ok() }) .collect() } /// The highest shape block VML text claims in `` or uses in a shape id. pub(super) fn vml_block_max(vml: &str) -> u64 { let used = shape_numbers(vml).into_iter().max().unwrap_or(0) / 1024; let claimed = vml .find("().ok()).max().unwrap_or(0)) .unwrap_or(0); used.max(claimed) } /// The first shape block free in kept VML: GridCraft's own shapes (notes, then form controls) are /// numbered from `block * 1024 + 1` when they join it ([`merge_vml`]). pub(super) fn first_free_block(kept: &str) -> u64 { shape_numbers(kept).into_iter().max().unwrap_or(0) / 1024 + 1 } /// Kept VML (controls, OLE objects) plus GridCraft's note and form control shapes: ours get ids /// in fresh shape blocks so they can't collide with the kept shapes the sheet XML refers to. pub(super) fn merge_vml(kept: &str, ours: &str) -> String { let Some(close) = kept.rfind("") else { return ours.to_string() }; let block = first_free_block(kept); let mut add = String::new(); // Our shape types (notes, form controls) that the kept drawing doesn't define. let mut from = 0; while let Some(i) = ours.get(from..).and_then(|s| s.find("")).map(|j| i + j + "".len()) else { break }; let ty = ours.get(i..j).unwrap_or(""); let id = attr_value(ty, "id").unwrap_or(""); if !id.is_empty() && !kept.contains(&format!("id=\"{id}\"")) && !kept.contains(&format!("id='{id}'")) { add.push_str(ty); } from = j; } let spans = shape_spans(ours); let blocks = (spans.len() as u64 + 1).div_ceil(1024).max(1); for (k, (a, b)) in spans.into_iter().enumerate() { let shape = ours.get(a..b).unwrap_or(""); let id = block.saturating_mul(1024).saturating_add(1 + k as u64); match (shape.find("id=\"_x0000_s"), shape.find("id=\"_x0000_s").and_then(|i| shape.get(i + 4..)?.find('"').map(|j| i + 4 + j))) { (Some(i), Some(j)) => { let _ = write!(add, "{}id=\"_x0000_s{id}\"{}", shape.get(..i).unwrap_or(""), shape.get(j + 1..).unwrap_or("")); } _ => add.push_str(shape), } } let mut head = kept.get(..close).unwrap_or("").to_string(); // Claim the blocks in the drawing's id map. if let Some(i) = head.find("(x: &'a str, name: &str) -> Option<&'a str> { let mut from = 0; while let Some(i) = x.get(from..)?.find(name).map(|i| i + from) { from = i + name.len(); let starts_token = x.get(..i).is_some_and(|before| before.ends_with(|c: char| c.is_whitespace() || c == '<')); let Some(rest) = x.get(from..).map(str::trim_start).and_then(|r| r.strip_prefix('=')).map(str::trim_start) else { continue }; if !starts_token { continue; } if let Some(q) = rest.chars().next().filter(|q| *q == '"' || *q == '\'') { let body = rest.get(q.len_utf8()..)?; return body.find(q).and_then(|e| body.get(..e)); } } None } /// A kept `` fragment without the controls whose `shapeId` is in `drop` (they are /// written from the model): a bare `` child goes when it is one of them, and within an /// `mc:AlternateContent` child only those controls go, in each of its branches, the wrapper /// staying while a control remains. `None` when nothing is left. A fragment that doesn't parse /// is returned unchanged. fn without_controls(frag: &str, drop: &HashSet) -> Option { if drop.is_empty() { return Some(frag.to_string()); } let mut reader = Reader::from_str(frag); let mut out = String::with_capacity(frag.len()); let (mut last, mut left, mut inside) = (0usize, 0usize, false); loop { let Ok(start) = usize::try_from(reader.buffer_position()) else { return Some(frag.to_string()) }; let ev = match reader.read_event() { Ok(ev) => ev, Err(_) => return Some(frag.to_string()), }; let child = match ev { Event::Eof => break, Event::Start(e) if e.local_name().as_ref() == b"controls" => { inside = true; continue; } Event::End(e) if e.local_name().as_ref() == b"controls" => { inside = false; continue; } Event::Start(e) if inside => { if reader.read_to_end(e.name()).is_err() { return Some(frag.to_string()); } true } Event::Empty(_) if inside => true, _ => false, }; if !child { continue; } let Ok(end) = usize::try_from(reader.buffer_position()) else { return Some(frag.to_string()) }; let text = frag.get(start..end).unwrap_or(""); let Some((kept, controls, dropped)) = controls_kept(text, drop) else { return Some(frag.to_string()) }; if dropped == 0 { // Nothing of ours in it: the child stays as it is. left += 1; } else { out.push_str(frag.get(last..start).unwrap_or("")); if controls > 0 { out.push_str(&kept); left += 1; } last = end; } } out.push_str(frag.get(last..).unwrap_or("")); (left > 0).then_some(out) } /// One child of a `` element with the `` elements numbered in `drop` taken /// out, wherever they are in it (a bare control, or the Choice and Fallback branches of an /// `mc:AlternateContent`), as (the text, the controls that remain, the controls taken out). The /// `shapeId` is read as the control reader reads it (an attribute, in either quote style). `None` /// when the child doesn't parse. fn controls_kept(child: &str, drop: &HashSet) -> Option<(String, usize, usize)> { let mut reader = Reader::from_str(child); let mut out = String::with_capacity(child.len()); let (mut last, mut kept, mut dropped) = (0usize, 0usize, 0usize); loop { let start = usize::try_from(reader.buffer_position()).ok()?; let (e, has_end) = match reader.read_event().ok()? { Event::Eof => break, Event::Start(e) => (e, true), Event::Empty(e) => (e, false), _ => continue, }; if e.local_name().as_ref() != b"control" { // A wrapper or a branch: its controls are the events that follow. continue; } let number = e.try_get_attribute("shapeId").ok().flatten().and_then(|a| std::str::from_utf8(&a.value).ok().and_then(crate::controls::shape_number)); if has_end { reader.read_to_end(e.name()).ok()?; } let end = usize::try_from(reader.buffer_position()).ok()?; if number.is_some_and(|n| drop.contains(&n)) { out.push_str(child.get(last..start)?); last = end; dropped += 1; } else { kept += 1; } } out.push_str(child.get(last..)?); Some((out, kept, dropped)) } /// Rewrites relationship-id attributes (`r:id`, `r:embed`…: any attribute in the relationships /// namespace) of an XML fragment through `map`. `None` when the fragment is damaged or `map` has /// no id for one of them. pub fn map_rel_ids(x: &str, map: &mut dyn FnMut(&str) -> Option) -> Option { let mut reader = Reader::from_str(x); let mut writer = Writer::new(Vec::with_capacity(x.len())); let mut prefixes: HashSet> = HashSet::new(); let mut depth = 0usize; loop { match reader.read_event().ok()? { Event::Eof => break, Event::Start(e) => { depth += 1; if depth > MAX_FRAGMENT_DEPTH { return None; } let e = map_start(&e, &mut prefixes, map)?; writer.write_event(Event::Start(e)).ok()?; } Event::Empty(e) => { let e = map_start(&e, &mut prefixes, map)?; writer.write_event(Event::Empty(e)).ok()?; } Event::End(e) => { depth = depth.saturating_sub(1); writer.write_event(Event::End(e)).ok()?; } ev => writer.write_event(ev).ok()?, } } String::from_utf8(writer.into_inner()).ok() } fn map_start(e: &BytesStart<'_>, prefixes: &mut HashSet>, map: &mut dyn FnMut(&str) -> Option) -> Option> { for a in e.attributes().with_checks(false) { let a = a.ok()?; if let Some(p) = a.key.as_ref().strip_prefix(b"xmlns:") && (a.value.as_ref() == NS_REL.as_bytes() || a.value.as_ref() == NS_REL_STRICT.as_bytes()) { prefixes.insert(p.to_vec()); } } let name = String::from_utf8(e.name().as_ref().to_vec()).ok()?; let mut out = BytesStart::new(name); for a in e.attributes().with_checks(false) { let a = a.ok()?; let key = a.key.as_ref(); let is_rel = !key.starts_with(b"xmlns") && a.key.prefix().is_some_and(|p| prefixes.contains(p.as_ref())); if is_rel { let old = std::str::from_utf8(&a.value).ok()?; let new = map(old)?; out.push_attribute(Attribute { key: QName(key), value: Cow::Owned(esc_attr(&new).into_bytes()) }); } else { out.push_attribute(Attribute { key: QName(key), value: a.value.clone() }); } } Some(out) }