DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
IDML: Keep Lines Together defaults to start/end of paragraph
aiongg3daf7fa1cf03
diff --git a/ROADMAP.md b/ROADMAP.mdindex 87ce118f3..e45c408a4 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -6,13 +6,13 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope**Working today**- Document model: facing/non-facing spreads, parent pages with page-number markers, sections, layers, frames (text / graphic / unassigned), threaded stories, paragraph/character/object styles with based-on, swatches (process/spot/tints/gradients), corner options, text wrap, drop shadow, opacity/blend.-- Text engine: Knuth–Plass paragraph composer and single-line composer, dictionary hyphenation (public-domain Moby list + our own trained Liang patterns), justification with word/letter/glyph-scaling ranges, keep options (keep with next, keep lines together, widows/orphans), balance ragged lines, optical margin alignment, hyphenation zone/limit, columns, threading across frames and spreads, tabs, bullets/numbering, rules, shading, baseline grid, first-baseline options, vertical justification, wrap exclusions, overset detection, caret/hit testing.+- Text engine: Knuth–Plass paragraph composer and single-line composer, dictionary hyphenation (public-domain Moby list + our own trained Liang patterns), justification with word/letter/glyph-scaling ranges, keep options (keep with next, keep lines together — at start/end of paragraph by default, as in InDesign — widows/orphans), balance ragged lines, optical margin alignment, hyphenation zone/limit, columns, threading across frames and spreads, tabs, bullets/numbering, rules, shading, baseline grid, first-baseline options, vertical justification, wrap exclusions, overset detection, caret/hit testing.- Rendering: vello_cpu (SIMD, multithreaded) — pages, items, images with mip levels, gradients, composed text.- UI (egui): application bar + menus, Control panel (object and text modes), Tools panel with flyouts, document tabs, rulers, pasteboard, guides (margins, columns, bleed, baseline grid), frame edges, selection handles, text ports and threads, Properties / Pages / Layers dock, Swatches, Styles, Character, Paragraph, Stroke, Text Wrap panels, New Document and Preferences dialogs, Quick Apply (⌘Return), 4 brightness themes.- Pen tool, Direct Selection anchor/handle editing, rotate from corners, Rotate/Scale/Shear tools, Eyedropper, snapping & smart guides, Align/Distribute, Find/Change (text + GREP), Story Editor, Paragraph Style Options, Effects panel, hidden characters, native macOS menu bar, measured InDesign 2026 look (Medium Dark): Properties sections per selection state, 21 pt spinner fields with arithmetic, Contextual Task Bar, inverse (black) text selection, Pages panel with drag-and-drop reorder / parent apply, Layers panel with per-object rows.- Tools: Selection (click, marquee, move, Alt-duplicate, resize handles), Direct Selection, Type (draw frame, click caret, select, type), Rectangle/Ellipse/Polygon (+ frame variants), Line, Hand, Zoom.- PDF export (krilla): real selectable text with embedded font subsets, DeviceCMYK/RGB + spot Separations, bleed boxes, crop/bleed marks + page info, pages or spreads, PDF/A-2b (PDF/X-4 output intent pending) — `file.exportPdf`, File › Export PDF…, `designcraft-cli run --export out.pdf`.-- IDML interchange (`designcraft-idml`): export and import of swatches, styles, fonts, preferences, parent spreads, spreads/pages, frames, groups, images (embedded or linked), formatted threaded stories — opens in InDesign 2026 and round-trips InDesign-exported files (`file.exportIdml`, `file.openIdml`, File → Export IDML…, CLI `--in x.idml` / `--export x.idml`).+- IDML interchange (`designcraft-idml`): export and import of swatches, styles, fonts, preferences, parent spreads, spreads/pages, frames, groups, images (embedded or linked), formatted threaded stories; attributes a file leaves unset take InDesign's defaults (Keep Lines Together at start/end of paragraph) — opens in InDesign 2026 and round-trips InDesign-exported files (`file.exportIdml`, `file.openIdml`, File → Export IDML…, CLI `--in x.idml` / `--export x.idml`).- Tables (M8): tables anchored in stories (header/footer/body rows, merged cells, per-edge strokes, fills + alternating fills, insets, vertical justification, at-least/exact row heights); composed into the text column (columns scale to fit, rows break across columns/frames with repeating headers/footers, overset); rendered, exported to PDF (real text) and IDML (export + import); Table menu, Table panel, Create Table dialog, caret/typing/Tab navigation and cell selection in cells; `table.*` commands.- Hyperlinks (text or frames → URL / e-mail / page) and bookmarks, exported as PDF link annotations and outline.- EPUB 3 (reflowable) export: stories in reading order, CSS from paragraph/character styles, images, navigation (`file.exportEpub`, CLI `--export x.epub`).diff --git a/crates/compose/src/tests.rs b/crates/compose/src/tests.rsindex 4f129c22b..11790836e 100644--- a/crates/compose/src/tests.rs+++ b/crates/compose/src/tests.rs@@ -592,7 +592,11 @@ fn keep_lines_together_moves_the_paragraph() {let (mut d, sid, _) = keep_doc(n - 3, &[&long], h);let cs = compose_story(&d, sid, &ComposeOptions::default());assert!(column_of_para(&cs, n - 3).contains(&0));- d.story_mut(sid).unwrap().paras[n - 3].para.keep_lines_together = Some(true);+ {+ let p = &mut d.story_mut(sid).unwrap().paras[n - 3].para;+ p.keep_lines_together = Some(true);+ p.keep_all_lines = Some(true);+ }let cs = compose_story(&d, sid, &ComposeOptions::default());assert!(column_of_para(&cs, n - 3).iter().all(|&c| c == 1));}diff --git a/crates/doc/src/attrs.rs b/crates/doc/src/attrs.rsindex 7f456948c..10b3c7a60 100644--- a/crates/doc/src/attrs.rs+++ b/crates/doc/src/attrs.rs@@ -608,7 +608,8 @@ attr_set! {// Keepskeep_with_next: u32 = 0,keep_lines_together: bool = false,- keep_all_lines: bool = true,+ /// All lines in paragraph (true) or at start/end of paragraph (false).+ keep_all_lines: bool = false,keep_first: u32 = 2,keep_last: u32 = 2,start_paragraph: StartParagraph = StartParagraph::Anywhere,diff --git a/crates/doc/src/styles.rs b/crates/doc/src/styles.rsindex d294a9509..3a5b340a7 100644--- a/crates/doc/src/styles.rs+++ b/crates/doc/src/styles.rs@@ -273,8 +273,8 @@ impl Styles {self.object.iter().find(|s| s.name == name)}- /// The paragraph style chain from root to `name` (cycle-safe).- fn para_chain(&self, name: &str) -> Vec<&ParagraphStyle> {+ /// The paragraph style chain from root to `name` (cycle-safe): resolution starts at its first.+ pub fn para_chain(&self, name: &str) -> Vec<&ParagraphStyle> {let mut chain = Vec::new();let mut cur = self.para(name);while let Some(s) = cur {diff --git a/crates/engine/src/tests_idml.rs b/crates/engine/src/tests_idml.rsindex 916872027..2ac666291 100644--- a/crates/engine/src/tests_idml.rs+++ b/crates/engine/src/tests_idml.rs@@ -91,6 +91,91 @@ fn magazine_round_trips_through_idml() {assert_eq!(items(&again.spreads).len(), items(&back.spreads).len());}+/// A one-page IDML package: two threaded frames side by side, 19 lines each (10 pt on 12 pt),+/// paragraphs of `lines` forced-break lines in style `Body`, which carries `body_attrs`.+fn keep_lines_idml(body_attrs: &str, lines: &[usize]) -> Vec<u8> {+ use std::io::Write;+ let paras: String = lines+ .iter()+ .enumerate()+ .map(|(p, &n)| {+ let text = (0..n).map(|k| format!("P{p} line {k}")).collect::<Vec<_>>().join("\u{2028}");+ format!(+ r#"<ParagraphStyleRange AppliedParagraphStyle="ParagraphStyle/Body"><CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content>{text}</Content>{}</CharacterStyleRange></ParagraphStyleRange>"#,+ if p + 1 < lines.len() { "<Br/>" } else { "" }+ )+ })+ .collect();+ let frame = |me: &str, x: f64, prev: &str, next: &str| {+ let pts: String = [(x, 36.0), (x, 276.0), (x + 180.0, 276.0), (x + 180.0, 36.0)]+ .iter()+ .map(|(x, y)| format!(r#"<PathPointType Anchor="{x} {y}" LeftDirection="{x} {y}" RightDirection="{x} {y}"/>"#))+ .collect();+ format!(+ r#"<TextFrame Self="{me}" ParentStory="s1" PreviousTextFrame="{prev}" NextTextFrame="{next}" ItemTransform="1 0 0 1 0 0"><Properties><PathGeometry><GeometryPathType PathOpen="false"><PathPointArray>{pts}</PathPointArray></GeometryPathType></PathGeometry></Properties></TextFrame>"#+ )+ };+ let designmap = format!(+ r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>+<Document xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging" DOMVersion="16.0" Self="d">+<DocumentPreference PageWidth="450" PageHeight="312" FacingPages="false"/>+<RootCharacterStyleGroup Self="rc"><CharacterStyle Self="CharacterStyle/$ID/[No character style]" Name="$ID/[No character style]"/></RootCharacterStyleGroup>+<RootParagraphStyleGroup Self="rp">+<ParagraphStyle Self="ParagraphStyle/$ID/[No paragraph style]" Name="$ID/[No paragraph style]" PointSize="12"/>+<ParagraphStyle Self="ParagraphStyle/Body" Name="Body" PointSize="10" {body_attrs}><Properties><BasedOn type="object">ParagraphStyle/$ID/[No paragraph style]</BasedOn><Leading type="unit">12</Leading></Properties></ParagraphStyle>+</RootParagraphStyleGroup>+<Story Self="s1">{paras}</Story>+<Spread Self="sp1" ItemTransform="1 0 0 1 0 0"><Page Self="p1" GeometricBounds="0 0 312 450" ItemTransform="1 0 0 1 0 0"/>{}{}</Spread>+</Document>"#,+ frame("t1", 36.0, "n", "t2"),+ frame("t2", 234.0, "t1", "n")+ );+ let mut w = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));+ let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);+ w.start_file("mimetype", stored).unwrap();+ w.write_all(b"application/vnd.adobe.indesign-idml-package").unwrap();+ w.start_file("designmap.xml", zip::write::SimpleFileOptions::default()).unwrap();+ w.write_all(designmap.as_bytes()).unwrap();+ w.finish().unwrap().into_inner()+}++/// Lines of paragraph `para` in each frame of the story.+fn para_lines_per_frame(d: &Document, para: usize) -> Vec<usize> {+ let sid = *d.stories.keys().next().unwrap();+ let cs = designcraft_compose::compose_story(d, sid, &Default::default());+ cs.frames.iter().map(|f| f.lines.iter().filter(|l| l.para == para).count()).collect()+}++/// Keep Lines Together without a mode in the IDML: InDesign's default, at start/end of paragraph.+/// A 10-line paragraph starting 6 lines above the first frame's bottom splits 6/4.+#[test]+fn idml_keep_lines_without_mode_split_at_start_and_end() {+ let keep = r#"KeepLinesTogether="true" KeepFirstLines="2" KeepLastLines="2""#;+ let d = designcraft_idml::import_idml(&keep_lines_idml(keep, &[13, 10, 2])).unwrap();+ assert_eq!(para_lines_per_frame(&d, 0), [13, 0]);+ assert_eq!(para_lines_per_frame(&d, 1), [6, 4]);+ // All lines in paragraph, written explicitly: the paragraph moves whole.+ let d = designcraft_idml::import_idml(&keep_lines_idml(&format!(r#"{keep} KeepAllLinesTogether="true""#), &[13, 10, 2])).unwrap();+ assert_eq!(para_lines_per_frame(&d, 1), [0, 10]);+}++/// A document saved in format 1 with Keep Lines Together and no mode still keeps all lines+/// together after loading; saved now, it keeps lines at start/end of paragraph.+#[test]+fn format_1_keep_lines_without_mode_lays_out_all_lines() {+ use std::io::Write;+ let d = designcraft_idml::import_idml(&keep_lines_idml(r#"KeepLinesTogether="true""#, &[13, 10, 2])).unwrap();+ let mut w = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));+ w.start_file("meta.json", zip::write::SimpleFileOptions::default()).unwrap();+ w.write_all(br#"{"format": "designcraft", "version": 1}"#).unwrap();+ w.start_file("document.json", zip::write::SimpleFileOptions::default()).unwrap();+ w.write_all(&serde_json::to_vec(&d).unwrap()).unwrap();+ let v1 = designcraft_format::load(&w.finish().unwrap().into_inner()).unwrap();+ assert_eq!(para_lines_per_frame(&v1, 1), [0, 10]);+ let now = designcraft_format::load(&designcraft_format::save(&d).unwrap()).unwrap();+ assert_eq!(para_lines_per_frame(&now, 1), [6, 4]);+}+#[test]fn idml_commands() {let mut s = Session::new();diff --git a/crates/format/src/lib.rs b/crates/format/src/lib.rsindex 5b4896ccc..e92b6ba08 100644--- a/crates/format/src/lib.rs+++ b/crates/format/src/lib.rs@@ -5,18 +5,19 @@//! - `assets/<id>.<ext>`: embedded placed files, byte-for-byte//! - `meta.json`: format version and generator//!-//! Older single-file JSON documents (assets as base64 in `assetData`) still open.+//! Older single-file JSON documents (assets as base64 in `assetData`) still open. Documents+//! from older format versions are upgraded on load so they lay out as they did.#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]#![forbid(unsafe_code)]use std::io::{Cursor, Read, Write};use std::sync::Arc;-use designcraft_doc::{AssetId, Document};+use designcraft_doc::{AssetId, Document, Story};use serde_json::{Value, json};pub const MIME: &str = "application/vnd.designcraft+zip";-pub const VERSION: u32 = 1;+pub const VERSION: u32 = 2;#[derive(Debug, thiserror::Error)]pub enum FormatError {@@ -87,12 +88,12 @@ fn load_zip(bytes: &[u8]) -> Result<Document, FormatError> {f.read_to_end(&mut v).ok()?;Some(v)};- if let Some(meta) = read(&mut z, "meta.json")- && let Ok(m) = serde_json::from_slice::<Value>(&meta)- && let Some(v) = m.get("version").and_then(Value::as_u64)- && v as u32 > VERSION- {- return Err(FormatError::TooNew(v as u32));+ let version = read(&mut z, "meta.json")+ .and_then(|meta| serde_json::from_slice::<Value>(&meta).ok())+ .and_then(|m| m.get("version").and_then(Value::as_u64))+ .map_or(1, |v| u32::try_from(v).unwrap_or(u32::MAX));+ if version > VERSION {+ return Err(FormatError::TooNew(version));}let json = read(&mut z, "document.json").ok_or_else(|| FormatError::NotOurs("missing document.json".into()))?;let mut doc: Document = serde_json::from_slice(&json).map_err(|e| FormatError::NotOurs(e.to_string()))?;@@ -104,10 +105,51 @@ fn load_zip(bytes: &[u8]) -> Result<Document, FormatError> {Arc::make_mut(a).data = Arc::new(data);}}+ upgrade(&mut doc, version);doc.check().map_err(|e| FormatError::NotOurs(e.to_string()))?;Ok(doc)}+/// Bring a document saved in format `from` up to [`VERSION`].+fn upgrade(doc: &mut Document, from: u32) {+ if from < 2 {+ pin_keep_all_lines(doc);+ }+}++/// Format 1 laid out an unset Keep Lines Together mode as all lines in paragraph. Pin that where+/// nothing set it: at the start of each paragraph style chain, and on paragraphs whose style is+/// missing.+fn pin_keep_all_lines(doc: &mut Document) {+ let roots: std::collections::HashSet<String> = doc+ .styles+ .paragraph+ .iter()+ .filter_map(|s| {+ let chain = doc.styles.para_chain(&s.name);+ if chain.iter().any(|c| c.para.keep_all_lines.is_some()) { None } else { chain.first().map(|c| c.name.clone()) }+ })+ .collect();+ if !roots.is_empty() {+ for s in doc.styles_mut().paragraph.iter_mut().filter(|s| roots.contains(&s.name)) {+ s.para.keep_all_lines = Some(true);+ }+ }+ let styles = doc.styles.clone();+ let mut pin = |st: &mut Story| {+ for p in st.paras.iter_mut().filter(|p| p.para.keep_all_lines.is_none() && styles.para(&p.style).is_none()) {+ p.para.keep_all_lines = Some(true);+ }+ };+ for st in doc.stories.values_mut() {+ let st = Arc::make_mut(st);+ st.for_each_text_mut(&mut pin);+ for n in &mut st.endnotes {+ Arc::make_mut(n).text.for_each_text_mut(&mut pin);+ }+ }+}+fn load_legacy_json(bytes: &[u8]) -> Result<Document, FormatError> {let v: Value = serde_json::from_slice(bytes).map_err(|e| FormatError::NotOurs(e.to_string()))?;let mut doc: Document = serde_json::from_value(v.clone()).map_err(|e| FormatError::NotOurs(e.to_string()))?;@@ -120,6 +162,7 @@ fn load_legacy_json(bytes: &[u8]) -> Result<Document, FormatError> {}}}+ upgrade(&mut doc, 1);doc.check().map_err(|e| FormatError::NotOurs(e.to_string()))?;Ok(doc)}@@ -179,6 +222,72 @@ mod tests {assert_eq!(back.stories, d.stories);}+ /// `doc` as format 1 wrote it.+ fn save_v1(doc: &Document) -> Vec<u8> {+ let mut z = zip::ZipWriter::new(Cursor::new(Vec::new()));+ z.start_file("meta.json", zip::write::SimpleFileOptions::default()).unwrap();+ z.write_all(br#"{"format": "designcraft", "version": 1}"#).unwrap();+ z.start_file("document.json", zip::write::SimpleFileOptions::default()).unwrap();+ z.write_all(&serde_json::to_vec(doc).unwrap()).unwrap();+ z.finish().unwrap().into_inner()+ }++ fn para_style(name: &str, based_on: Option<&str>, keep_all_lines: Option<bool>) -> designcraft_doc::ParagraphStyle {+ designcraft_doc::ParagraphStyle {+ name: name.into(),+ based_on: based_on.map(str::to_string),+ next_style: None,+ para: designcraft_doc::ParaAttrs { keep_lines_together: Some(true), keep_all_lines, ..Default::default() },+ chars: Default::default(),+ shortcut: String::new(),+ }+ }++ /// Format 1 resolved an unset Keep Lines Together mode as all lines: those documents still+ /// do after loading, wherever the mode comes from. New documents keep lines at start/end.+ #[test]+ fn format_1_keep_lines_without_mode_stays_all_lines() {+ let mut d = Document::new(&NewDocument::default());+ let st = d.styles_mut();+ st.paragraph.push(para_style("Root", None, None));+ st.paragraph.push(para_style("Child", Some("Root"), None));+ st.paragraph.push(para_style("Explicit", None, Some(false)));+ st.paragraph.push(para_style("Under explicit", Some("Explicit"), None));+ st.paragraph.push(para_style("Loop A", Some("Loop B"), None));+ st.paragraph.push(para_style("Loop B", Some("Loop A"), None));+ let lid = d.default_layer();+ let names = [designcraft_doc::story::BASIC_PARAGRAPH, "Root", "Child", "Explicit", "Under explicit", "Loop A", "Loop B", "Missing"];+ let text = names.join("\n");+ let (_, sid) = d.add_text_frame(SpreadRef::Doc(0), Rect::new(10.0, 10.0, 200.0, 200.0), lid, &text, ParaFormat::default()).unwrap();+ {+ let s = d.story_mut(sid).unwrap();+ for (p, name) in s.paras.iter_mut().zip(names) {+ p.style = name.into();+ p.para.keep_lines_together = Some(true);+ }+ s.insert_note(1, "Note", ParaFormat { style: "Missing".into(), ..Default::default() });+ }+ let back = load(&save_v1(&d)).unwrap();+ let resolve = |f: &ParaFormat| back.styles.resolve_para(f).0;+ let story = back.story(sid).unwrap();+ for (p, name) in story.paras.iter().zip(names) {+ let pp = resolve(p);+ assert!(pp.keep_lines_together);+ assert_eq!(pp.keep_all_lines, !name.contains("xplicit"), "{name}");+ }+ assert!(resolve(&story.notes[0].text.paras[0]).keep_all_lines, "footnote with a missing style");+ assert!(back.styles.resolve_para_style("Loop A").0.keep_all_lines && back.styles.resolve_para_style("Loop B").0.keep_all_lines);+ // Pinned where the chains start; explicit and inheriting styles are left as they were.+ assert_eq!(back.styles.para("Root").unwrap().para.keep_all_lines, Some(true));+ assert_eq!(back.styles.para("Child").unwrap().para.keep_all_lines, None);+ assert_eq!(back.styles.para("Under explicit").unwrap().para.keep_all_lines, None);+ // The current format keeps the new default: at start/end of paragraph.+ let now = load(&save(&d).unwrap()).unwrap();+ let p = &now.story(sid).unwrap().paras[0];+ assert!(!now.styles.resolve_para(p).0.keep_all_lines);+ assert!(!designcraft_doc::ParaProps::default().keep_all_lines);+ }+#[test]fn rejects_garbage_and_newer_versions() {assert!(load(b"nope").is_err());diff --git a/crates/idml/src/tests.rs b/crates/idml/src/tests.rsindex 02fe63ff8..249d29c0e 100644--- a/crates/idml/src/tests.rs+++ b/crates/idml/src/tests.rs@@ -194,6 +194,48 @@ fn fixture_with_story(story: &str) -> Vec<u8> {])}+fn fixture_with_styles(styles: &str) -> Vec<u8> {+ zip_files(&[+ ("designmap.xml", DESIGNMAP),+ ("Resources/Graphic.xml", GRAPHIC),+ ("Resources/Styles.xml", styles),+ ("Resources/Preferences.xml", PREFS),+ ("MasterSpreads/MasterSpread_m1.xml", MASTER),+ ("Spreads/Spread_sp1.xml", SPREAD),+ ("Stories/Story_s1.xml", STORY),+ ])+}++/// Paragraph styles `Body` (based on the root) and `Loose` (no BasedOn), both with `attrs`.+fn keep_styles(attrs: &str) -> String {+ format!(+ r#"<?xml version="1.0" encoding="UTF-8"?>+<idPkg:Styles xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging" DOMVersion="16.0">+ <RootParagraphStyleGroup Self="rp">+ <ParagraphStyle Self="ParagraphStyle/$ID/[No paragraph style]" Name="$ID/[No paragraph style]" PointSize="12"/>+ <ParagraphStyle Self="ParagraphStyle/Body" Name="Body" {attrs}>+ <Properties><BasedOn type="object">ParagraphStyle/$ID/[No paragraph style]</BasedOn></Properties>+ </ParagraphStyle>+ <ParagraphStyle Self="ParagraphStyle/Loose" Name="Loose" {attrs}/>+ </RootParagraphStyleGroup>+</idPkg:Styles>"#+ )+}++/// Keep Lines Together whose mode no style sets is InDesign's default: at start/end of paragraph.+/// An explicit mode still wins.+#[test]+fn keep_lines_mode_defaults_to_start_and_end() {+ let keep = r#"KeepLinesTogether="true" KeepFirstLines="2" KeepLastLines="2""#;+ for (attrs, all) in [(keep.to_string(), false), (format!(r#"{keep} KeepAllLinesTogether="true""#), true)] {+ let d = import_idml_with(&fixture_with_styles(&keep_styles(&attrs)), &|_| None).unwrap();+ for name in ["Body", "Loose"] {+ let (pp, _) = d.styles.resolve_para_style(name);+ assert_eq!((pp.keep_lines_together, pp.keep_all_lines, pp.keep_first, pp.keep_last), (true, all, 2, 2), "{name}: {attrs}");+ }+ }+}+#[test]fn imports_hand_written_fixture() {let d = import_idml_with(&fixture(), &|_| None).unwrap();