GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
use super::*;

/// XML 1.0 literal attribute whitespace is normalized to spaces; references retain the value.
pub(super) fn xml_attr_escape(s: &str) -> String {
    xml_escape(s).replace('\t', "	").replace('\n', "
").replace('\r', "
")
}

/// Escape type for XML content. Characters XML 1.0 does not allow are dropped, except the line
/// and page breaks (U+000B, U+000C) other apps paste, which become spaces.
pub(super) fn xml_text(s: &str) -> String {
    let s: String = s
        .chars()
        .filter_map(|c| match c {
            '\u{b}' | '\u{c}' => Some(' '),
            c if valid_xml_value(c.encode_utf8(&mut [0; 4])) => Some(c),
            _ => None,
        })
        .collect();
    xml_escape(&s)
}

/// `s` without the characters XML 1.0 does not allow, ready for a double-quoted attribute.
pub(super) fn xml_attr_valid(s: &str) -> String {
    let s: String = s.chars().filter(|c| valid_xml_value(c.encode_utf8(&mut [0; 4]))).collect();
    xml_attr_escape(&s)
}

pub(super) fn valid_xml_value(s: &str) -> bool {
    s.chars().all(|c| matches!(c, '\t' | '\n' | '\r' | '\u{20}'..='\u{d7ff}' | '\u{e000}'..='\u{fffd}' | '\u{10000}'..='\u{10ffff}'))
}

/// An XML name without a colon (an NCName): a letter or `_`, then [`xml_name_char`]s.
pub(super) fn xml_ncname(s: &str) -> bool {
    let mut chars = s.chars();
    chars.next().is_some_and(|c| c.is_alphabetic() || c == '_') && chars.all(xml_name_char)
}

/// Namespace-free XML 1.0 NameChar. The fixed `data-` prefix supplies NameStartChar.
fn xml_name_char(c: char) -> bool {
    matches!(c,
        'A'..='Z' | 'a'..='z' | '0'..='9' | '_' | '-' | '.' | '\u{b7}' |
        '\u{c0}'..='\u{d6}' | '\u{d8}'..='\u{f6}' | '\u{f8}'..='\u{2ff}' |
        '\u{300}'..='\u{37d}' | '\u{37f}'..='\u{1fff}' | '\u{200c}'..='\u{200d}' |
        '\u{203f}'..='\u{2040}' | '\u{2070}'..='\u{218f}' | '\u{2c00}'..='\u{2fef}' |
        '\u{3001}'..='\u{d7ff}' | '\u{f900}'..='\u{fdcf}' | '\u{fdf0}'..='\u{fffd}' |
        '\u{10000}'..='\u{effff}'
    )
}

/// Write every character of `s` beyond ISO 8859-1 as a character reference. Called only when
/// names fit Latin-1, so references occur in values, text or style sheets.
pub(super) fn latin1_refs(s: &mut String) {
    if s.chars().all(|c| u32::from(c) < 0x100) {
        return;
    }
    let mut o = String::with_capacity(s.len() + 64);
    for c in s.chars() {
        if u32::from(c) < 0x100 {
            o.push(c);
        } else {
            let _ = write!(o, "&#x{:X};", u32::from(c));
        }
    }
    *s = o;
}

/// A CSS declaration block as the literal value of an `<!ENTITY>`: quotes, `%` and markup
/// characters become references that still read as themselves inside the `style` attribute.
pub(super) fn entity_value(decl: &str) -> String {
    let mut o = String::with_capacity(decl.len());
    for c in decl.chars() {
        match c {
            '"' => o.push_str("&#34;"),
            '%' => o.push_str("&#37;"),
            // Doubly escaped: the entity's replacement text is parsed again where it is used.
            '&' => o.push_str("&#38;#38;"),
            '<' => o.push_str("&#38;#60;"),
            _ => o.push(c),
        }
    }
    o
}

/// The Dublin Core terms File Info writes to `<metadata>`: the format, title, author (creator),
/// description, each keyword (subject), copyright notice and URL (rights) and created date, the
/// empty ones left out.
fn dublin_core(doc: &Document) -> Vec<(&'static str, String)> {
    let info = &doc.metadata;
    let mut terms = vec![("format", "image/svg+xml".to_string())];
    let created = info.created.map(vectorcraft_doc::metadata::iso8601).unwrap_or_default();
    let fields = [("title", doc.info_title()), ("creator", info.author.as_str()), ("description", info.description.as_str())];
    let rights = [("rights", info.copyright_notice.as_str()), ("rights", info.copyright_url.as_str()), ("date", created.as_str())];
    let keywords = info.keywords.iter().map(|k| ("subject", k.as_str()));
    terms.extend(fields.into_iter().chain(keywords).chain(rights).filter(|(_, v)| !v.trim().is_empty()).map(|(k, v)| (k, v.to_string())));
    terms
}

/// Turn an object name into a valid, readable XML id.
pub(crate) fn sanitize_id(name: &str) -> String {
    let mut s: String = name.trim().chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '_' || c == '.' { c } else { '_' }).collect();
    if s.is_empty() || !s.starts_with(|c: char| c.is_alphabetic() || c == '_') {
        s.insert(0, '_');
    }
    s
}

impl Writer<'_> {
    /// Writing the SVG Tiny 1.2 profile?
    pub(super) fn tiny(&self) -> bool {
        self.opts.profile == Profile::Tiny12
    }

    pub(super) fn num(&self, v: f64) -> String {
        fmt_num(v, self.opts.decimals)
    }

    pub(super) fn indent(&self, depth: usize) -> String {
        if self.opts.minify { String::new() } else { "  ".repeat(depth) }
    }

    pub(super) fn line(&mut self, s: &str) {
        let ind = self.indent(self.depth);
        self.body.push_str(&ind);
        self.body.push_str(&merge_class_attrs(s));
        if !self.opts.minify {
            self.body.push('\n');
        }
    }

    pub(super) fn def(&mut self, depth: usize, s: &str) {
        let ind = self.indent(depth + 1);
        self.defs.push_str(&ind);
        self.defs.push_str(s);
        if !self.opts.minify {
            self.defs.push('\n');
        }
    }

    pub(super) fn fresh_id(&mut self, prefix: &str) -> String {
        let next = self.next_fresh.entry(prefix.to_owned()).or_insert(1);
        loop {
            let id = format!("{}{prefix}-{next}", self.id_prefix);
            *next += 1;
            if self.used_ids.insert(id.clone()) {
                return id;
            }
        }
    }

    /// `base` (with the unique prefix) if free, else `base-2`, `base-3`…
    pub(super) fn unique_id(&mut self, base: &str) -> String {
        let base = format!("{}{base}", self.id_prefix);
        if self.used_ids.insert(base.clone()) {
            return base;
        }
        let next = self.next_suffix.entry(base.clone()).or_insert(2);
        loop {
            let cand = format!("{base}-{next}");
            *next += 1;
            if self.used_ids.insert(cand.clone()) {
                return cand;
            }
        }
    }

    /// Reserve ids for every named object up front so generated def ids never collide with them.
    /// Symbols' art takes no ids, also where the drawing holds it placed by an instance (every
    /// instance of the symbol writes it).
    pub(super) fn assign_name_ids(&mut self) {
        if self.opts.object_ids == ObjectIds::Minimal {
            return;
        }
        let mut art = HashSet::new();
        for s in &self.doc.symbols {
            s.art.walk(&mut |n| {
                art.insert(n.id);
            });
        }
        let mut named: Vec<(NodeId, String)> = Vec::new();
        self.doc.walk(|n| {
            // Ruler guides are not written, so their names reserve no id.
            if n.is_ruler_guide() || art.contains(&n.id) {
                return;
            }
            if let Some(name) = &n.name {
                named.push((n.id, sanitize_id(name)));
            }
        });
        for (id, base) in named {
            let cand = self.unique_id(&base);
            self.names.insert(id, cand);
        }
    }

    /// ` id="…"` for a named object, plus ` data-name="…"` with the name itself when the id had to
    /// differ from it (spaces, punctuation, duplicates, the unique prefix).
    /// The id of `n`'s element (with its name when the id isn't it), then the object's own data
    /// as `data-*` attributes. Sublayers also retain their import marker.
    pub(super) fn id_attr(&mut self, n: &Node) -> String {
        if self.anonymous {
            return String::new();
        }
        let mut out = self.names.get(&n.id).map_or_else(String::new, |id| format!(" id=\"{}\"", xml_escape(id)));
        if let Some(id) = self.names.get(&n.id).filter(|_| !self.bound.is_empty()).cloned() {
            self.note_bound(n.id, &id);
        }
        if let (Some(id), Some(name)) = (self.names.get(&n.id), n.name.as_deref())
            && name != id
        {
            if valid_xml_value(name) {
                out.push_str(&format!(" data-name=\"{}\"", xml_attr_escape(name)));
            } else {
                self.warn("Object names containing invalid XML characters were left out of SVG name attributes");
            }
        }
        // Preserve sublayer identity independently of object data attributes.
        if !out.is_empty() && n.is_layer() && self.layer_nest > 1 {
            out.push_str(&format!(" {}=\"sublayer\"", crate::import::SUBLAYER));
        }
        let classes: Vec<&str> = n
            .extras()
            .attrs
            .as_deref()
            .map_or(&[][..], |a| a.classes.as_slice())
            .iter()
            .map(String::as_str)
            .filter(|c| !c.is_empty() && !c.chars().any(|ch| ch.is_control() || matches!(ch, '\u{fffe}' | '\u{ffff}')))
            .collect();
        // SVG Tiny 1.2 has `class` among its core attributes, so every profile writes them.
        if !classes.is_empty() {
            out.push_str(&format!(" class=\"{}\"", xml_attr_escape(&classes.join(" "))));
        }
        let mut keys = HashSet::new();
        for (k, v) in n.extras().attrs.as_deref().map_or(&[][..], |a| a.data.as_slice()) {
            // Ours (`name`, `vc-…`) are written by the export itself.
            if k == "name" || k.starts_with("vc-") {
                continue;
            }
            if k.is_empty() || !k.chars().all(xml_name_char) || !valid_xml_value(v) {
                self.warn("Data attributes with invalid XML names or characters were left out of SVG");
                continue;
            }
            // Native data is an ordered list. Keep the first valid value of each key.
            if !keys.insert(k.as_str()) {
                self.warn("Repeated data attribute keys were written only once in SVG");
                continue;
            }
            self.non_latin1_names |= k.chars().any(|c| u32::from(c) > 0xff);
            out.push_str(&format!(" data-{k}=\"{}\"", xml_attr_escape(v)));
        }
        self.foreign_attrs(n, &mut out);
        self.event_attrs(n, &mut out);
        out
    }

    /// `n`'s attributes in other applications' namespaces (`plotter:pen="2"`), added to `out`.
    /// Each namespace is declared once, on the root, under the prefix the file gave it unless the
    /// export uses that prefix itself or for another namespace ([`Writer::foreign_prefix`]).
    fn foreign_attrs(&mut self, n: &Node, out: &mut String) {
        let attrs = n.extras().attrs.as_deref().map_or(&[][..], |a| a.foreign.as_slice());
        let mut seen = HashSet::new();
        for a in attrs {
            if !xml_ncname(&a.prefix) || !xml_ncname(&a.name) || a.ns.is_empty() || !valid_xml_value(&a.ns) || !valid_xml_value(&a.value) {
                self.warn("Attributes of other applications with invalid XML names or characters were left out of SVG");
                continue;
            }
            // Native data is a list: one attribute per namespace and name.
            if !seen.insert((a.ns.as_str(), a.name.as_str())) {
                self.warn("Repeated attributes of other applications were written only once in SVG");
                continue;
            }
            let prefix = self.foreign_prefix(&a.ns, &a.prefix);
            self.non_latin1_names |= prefix.chars().chain(a.name.chars()).any(|c| u32::from(c) > 0xff);
            out.push_str(&format!(" {prefix}:{}=\"{}\"", a.name, xml_attr_escape(&a.value)));
        }
    }

    /// The prefix namespace `ns` is written under: `wanted` (the file's), else `wanted2`,
    /// `wanted3`… when the export's own prefixes or another namespace already have it. XML keeps
    /// prefixes starting with `xml` for itself: those become `ns`, `ns2`…
    fn foreign_prefix(&mut self, ns: &str, wanted: &str) -> String {
        if let Some(p) = self.foreign_ns.get(ns) {
            return p.clone();
        }
        const OURS: [&str; 5] = ["svg", "xlink", "rdf", "dc", "vectorcraft"];
        let base = if wanted.to_ascii_lowercase().starts_with("xml") { "ns" } else { wanted };
        let taken = |p: &str| OURS.contains(&p) || self.foreign_ns.values().any(|q| q == p);
        let mut prefix = base.to_string();
        let mut k = 2;
        while taken(&prefix) {
            prefix = format!("{base}{k}");
            k += 1;
        }
        self.foreign_ns.insert(ns.to_string(), prefix.clone());
        prefix
    }

    /// Window › SVG Interactivity: `n`'s events as event attributes (`onclick="…"`), added to
    /// `out`. The SVG Tiny 1.2 profile leaves them out with a warning.
    fn event_attrs(&mut self, n: &Node, out: &mut String) {
        let events = n.extras().attrs.as_deref().map_or(&[][..], |a| a.events.as_slice());
        if events.is_empty() {
            return;
        }
        if self.tiny() {
            self.warn("SVG Tiny 1.2 has no event attributes: SVG Interactivity events were left out");
            return;
        }
        let mut seen = HashSet::new();
        for (event, script) in events {
            // Native data can name anything: only the panel's events are written, once each.
            if !SVG_EVENTS.contains(&event.as_str()) || !valid_xml_value(script) {
                self.warn("SVG Interactivity events with unknown names or invalid XML characters were left out of SVG");
                continue;
            }
            if !seen.insert(event.as_str()) {
                self.warn("Repeated SVG Interactivity events were written only once in SVG");
                continue;
            }
            out.push_str(&format!(" {event}=\"{}\"", xml_attr_escape(script)));
        }
    }

    pub(super) fn matrix(&self, m: Affine) -> String {
        let c = m.as_coeffs();
        format!("matrix({} {} {} {} {} {})", self.num(c[0]), self.num(c[1]), self.num(c[2]), self.num(c[3]), self.num(c[4]), self.num(c[5]))
    }

    /// How style properties are written: the styling option, but SVG Tiny has presentation
    /// attributes alone.
    pub(super) fn styling(&self) -> Styling {
        if self.tiny() { Styling::PresentationAttributes } else { self.opts.styling }
    }

    /// Style properties as attributes, an inline style, or a CSS class, per the styling option.
    pub(super) fn attrs(&mut self, props: &Props) -> String {
        if props.is_empty() {
            return String::new();
        }
        match self.styling() {
            Styling::PresentationAttributes => {
                // CSS-only properties go in a style attribute (SVG Tiny has none: left out).
                let (style, attrs): (Vec<_>, Vec<_>) = props.iter().partition(|(k, _)| {
                    matches!(*k, "mix-blend-mode" | "isolation" | "font-feature-settings" | "font-variation-settings" | "font-kerning")
                });
                let mut s: String = attrs.iter().map(|(k, v)| format!(" {k}=\"{}\"", xml_escape(v))).collect();
                if !style.is_empty() {
                    if self.tiny() {
                        self.warn("SVG Tiny 1.2 has no style sheets: blend modes, isolation, font features and font variation settings are left out");
                    } else {
                        s.push_str(&format!(" style=\"{}\"", xml_escape(&css::declarations(style))));
                    }
                }
                s
            }
            Styling::InlineStyle => format!(" style=\"{}\"", xml_escape(&css::declarations(props))),
            Styling::StyleEntities => format!(" style=\"&st{};\"", self.class(css::declarations(props))),
            Styling::InternalCss => {
                let i = self.class(css::declarations(props));
                format!(" class=\"{}cls-{i}\"", self.id_prefix)
            }
        }
    }

    /// The 1-based number of a distinct declaration block (a CSS class or a style entity).
    fn class(&mut self, decl: String) -> usize {
        if let Some(&i) = self.class_ids.get(decl.as_str()) {
            return i;
        }
        let i = self.classes.len() + 1;
        self.class_ids.insert(decl.clone(), i);
        self.classes.push(decl);
        i
    }

    /// `<metadata>`: the Dublin Core terms of File Info ([`ExportOptions::metadata`]) and the
    /// native document ([`ExportOptions::preserve_editing`]) with the [`body_hash`] of the markup
    /// around this element.
    pub(super) fn metadata(&self, out: &mut String, native: Option<(&[u8], String)>) {
        if !self.opts.metadata && native.is_none() {
            return;
        }
        let nl = if self.opts.minify { "" } else { "\n" };
        let mut line = |depth: usize, s: &str| {
            out.push_str(&self.indent(depth));
            out.push_str(s);
            out.push_str(nl);
        };
        line(1, "<metadata>");
        if self.opts.metadata {
            line(2, "<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">");
            line(3, "<rdf:Description rdf:about=\"\">");
            for (term, value) in dublin_core(self.doc) {
                line(4, &format!("<dc:{term}>{}</dc:{term}>", xml_text(&value)));
            }
            line(3, "</rdf:Description>");
            line(2, "</rdf:RDF>");
        }
        if let Some((bytes, hash)) = native {
            line(
                2,
                &format!(
                    "<vectorcraft:document xmlns:vectorcraft=\"{EDITING_NS}\" hash=\"{hash}\"><![CDATA[{}]]></vectorcraft:document>",
                    base64_encode(bytes)
                ),
            );
        }
        line(1, "</metadata>");
    }

    pub(super) fn path_d(&self, p: &PathData, m: Affine) -> String {
        let mut s = String::new();
        // Each point as "x y", appended in place (no string per number or per point).
        let dec = self.opts.decimals;
        let pt = |s: &mut String, p: Point| {
            let p = m * p;
            crate::push_num(s, p.x, dec);
            s.push(' ');
            crate::push_num(s, p.y, dec);
        };
        for sp in &p.subpaths {
            let n = sp.anchors.len();
            if n == 0 {
                continue;
            }
            if !s.is_empty() {
                s.push(' ');
            }
            s.push('M');
            pt(&mut s, sp.anchors[0].p);
            for i in 0..sp.segment_count() {
                let (a, b) = (&sp.anchors[i], &sp.anchors[(i + 1) % n]);
                if sp.segment_is_line(i) {
                    if sp.closed && i == n - 1 {
                        break;
                    }
                    s.push_str(" L");
                    pt(&mut s, b.p);
                } else {
                    s.push_str(" C");
                    pt(&mut s, a.h_out);
                    s.push(' ');
                    pt(&mut s, b.h_in);
                    s.push(' ');
                    pt(&mut s, b.p);
                }
            }
            if sp.closed {
                s.push_str(" Z");
            }
        }
        s
    }

    /// `p` written with `m` as the SVG basic shape it exactly is, as the reference app's SVG
    /// export writes simple shapes (#4652): an axis-aligned `<rect>`, `<circle>` or `<ellipse>`,
    /// a `<line>`, or a `<polygon>`/`<polyline>` of straight segments. The element name and its
    /// geometry attributes, at the written precision; `None` keeps `<path>`. `<rect>` and
    /// `<ellipse>` start their outline elsewhere than the path, so with a `dashed` stroke a
    /// rectangle is a `<polygon>` and an ellipse stays `<path>`.
    /// Sources: an Illustrator ellipse is an `ellipse` tag unless an anchor is added
    /// (<https://community.adobe.com/t5/illustrator-discussions/trouble-exporting-shape-with-points-to-svg/td-p/10720325>);
    /// rectangles export as `<rect>` and `<polygon>`
    /// (<https://community.adobe.com/t5/illustrator-discussions/force-svg-export-using-all-lt-rect-gt/td-p/11282378>);
    /// a triangle without curves exports as a polygon (<https://hackaday.io/project/170755/log/175565>).
    pub(super) fn basic_shape(&self, p: &PathData, m: Affine, dashed: bool) -> Option<(&'static str, String)> {
        let [sp] = p.subpaths.as_slice() else { return None };
        if !(0..sp.segment_count()).all(|i| sp.segment_is_line(i)) {
            return self.ellipse_shape(sp, m).filter(|_| !dashed);
        }
        let pts: Vec<Point> = sp.anchors.iter().map(|a| m * a.p).collect();
        if sp.closed && !dashed && pts.len() == 4 {
            // The corners as written, so the rectangle's numbers are the path's own.
            let snap = |v: f64| self.num(v).parse::<f64>().unwrap_or(v);
            let corners: Vec<Point> = pts.iter().map(|q| Point::new(snap(q.x), snap(q.y))).collect();
            if let Some(r) = axis_rect(&corners) {
                let (x, y, w, h) = (self.num(r.x0), self.num(r.y0), self.num(r.width()), self.num(r.height()));
                return Some(("rect", format!(" x=\"{x}\" y=\"{y}\" width=\"{w}\" height=\"{h}\"")));
            }
        }
        let points = |tag: &'static str| {
            let mut s = String::from(" points=\"");
            for (i, q) in pts.iter().enumerate() {
                if i > 0 {
                    s.push(' ');
                }
                crate::push_num(&mut s, q.x, self.opts.decimals);
                s.push(',');
                crate::push_num(&mut s, q.y, self.opts.decimals);
            }
            s.push('"');
            Some((tag, s))
        };
        match (sp.closed, pts.as_slice()) {
            (false, [a, b]) => {
                let (x1, y1, x2, y2) = (self.num(a.x), self.num(a.y), self.num(b.x), self.num(b.y));
                // A line of zero length as written keeps `<path>`: renderers disagree on its caps.
                ((&x1, &y1) != (&x2, &y2)).then(|| ("line", format!(" x1=\"{x1}\" y1=\"{y1}\" x2=\"{x2}\" y2=\"{y2}\"")))
            }
            (false, [_, _, _, ..]) => points("polyline"),
            (true, [_, _, _, ..]) => points("polygon"),
            _ => None,
        }
    }

    /// A closed 4-anchor subpath that is an axis-aligned ellipse drawn the standard way (each
    /// quarter a cubic with handles [`KAPPA`] of the radii long), within the written precision:
    /// `<circle>` when its radii are written the same, else `<ellipse>`.
    fn ellipse_shape(&self, sp: &SubPath, m: Affine) -> Option<(&'static str, String)> {
        let tol = 10f64.powi(-i32::from(self.opts.decimals));
        let (anchors, closed) = (sp.anchors.contiguous(), sp.closed);
        let [a0, a1, a2, a3] = &*anchors else { return None };
        let [p0, p1, p2, p3] = [a0.p, a1.p, a2.p, a3.p].map(|p| m * p);
        let c = p0.midpoint(p2);
        let near = |a: f64, b: f64| (a - b).abs() <= tol;
        // Opposite anchors share the centre: one pair on the horizontal axis, the other on the vertical.
        let (rx, ry) = if near(p0.y, c.y) && near(p1.x, c.x) {
            ((p0.x - c.x).abs(), (p1.y - c.y).abs())
        } else if near(p0.x, c.x) && near(p1.y, c.y) {
            ((p1.x - c.x).abs(), (p0.y - c.y).abs())
        } else {
            return None;
        };
        let quarters = anchors.iter().zip(anchors.iter().cycle().skip(1)).all(|(a, b)| {
            let (pa, pb) = (m * a.p, m * b.p);
            (m * a.h_out).distance(pa + (pb - c) * KAPPA) <= tol && (m * b.h_in).distance(pb + (pa - c) * KAPPA) <= tol
        });
        if !closed || c.distance(p1.midpoint(p3)) > tol || rx <= tol || ry <= tol || !quarters {
            return None;
        }
        let (cx, cy, rx, ry) = (self.num(c.x), self.num(c.y), self.num(rx), self.num(ry));
        Some(if rx == ry {
            ("circle", format!(" cx=\"{cx}\" cy=\"{cy}\" r=\"{rx}\""))
        } else {
            ("ellipse", format!(" cx=\"{cx}\" cy=\"{cy}\" rx=\"{rx}\" ry=\"{ry}\""))
        })
    }

    /// Note `w`, once, about something of the document that the file leaves out or that reaches
    /// it changed ([`crate::Output::warnings`]). A note about an option goes to [`Self::note_setting`].
    pub(super) fn warn(&mut self, w: &str) {
        if !self.warnings.iter().any(|x| x == w) {
            self.warnings.push(w.to_string());
        }
    }

    /// Note `w`, once, about an option that wasn't applied or was applied another way while the
    /// art reaches the file as it looks ([`crate::Output::setting_notes`]).
    pub(super) fn note_setting(&mut self, w: &str) {
        if !self.setting_notes.iter().any(|x| x == w) {
            self.setting_notes.push(w.to_string());
        }
    }
}

/// An element that has both its own classes and a generated `cls-N` would write `class` twice:
/// join the two into one attribute (the first, the object's own, comes first).
fn merge_class_attrs(s: &str) -> std::borrow::Cow<'_, str> {
    const KEY: &str = " class=\"";
    let tag_end = s.find('>').unwrap_or(s.len());
    let tag = s.get(..tag_end).unwrap_or(s);
    let Some(first) = tag.find(KEY) else { return s.into() };
    let first_val = first + KEY.len();
    let Some(first_len) = tag.get(first_val..).and_then(|t| t.find('"')) else { return s.into() };
    let first_end = first_val + first_len;
    let Some(second) = tag.get(first_end..).and_then(|t| t.find(KEY)).map(|i| i + first_end) else { return s.into() };
    let second_val = second + KEY.len();
    let Some(second_len) = tag.get(second_val..).and_then(|t| t.find('"')) else { return s.into() };
    let second_end = second_val + second_len;
    let (Some(b), Some(head), Some(mid), Some(rest)) =
        (s.get(second_val..second_end), s.get(..first_end), s.get(first_end + 1..second), s.get(second_end + 1..))
    else {
        return s.into();
    };
    format!("{head} {b}\"{mid}{rest}").into()
}

/// The rectangle whose corners `q` are, in order either way round, with its edges alternately
/// horizontal and vertical and none of zero length (`<rect>` doesn't draw an empty one).
fn axis_rect(q: &[Point]) -> Option<Rect> {
    let [a, b, c, d] = *q else { return None };
    let h = |p: Point, q: Point| p.y == q.y && p.x != q.x;
    let v = |p: Point, q: Point| p.x == q.x && p.y != q.y;
    ((h(a, b) && v(b, c) && h(c, d) && v(d, a)) || (v(a, b) && h(b, c) && v(c, d) && h(d, a))).then(|| Rect::from_points(a, c))
}