cadrgtsecond/mosham - Change L4J562JRQTGQ3XRGDTTG7II5JBNG5OVRK4CGHIA2CB54YSRIF2WQC

Refactor code in order for future benchmarking

Created by cadrgtsecond on January 22, 2026

L4J562JRQTGQ3XRGDTTG7II5JBNG5OVRK4CGHIA2CB54YSRIF2WQC

Dependencies

In channels

main

Change contents

Replacement in src/render.rs at line 21 [5.34]
B:BD[4.128] → [4.128:153]
```
    face: json_ui::Face,
```
[4.128]
[4.153]
```
    fg: [u8; 4],
    bg: Option<[u8; 4]>,
```
Insertion in src/render.rs at line 25 [5.34]
[4.205]
[4.205]
```
    font_size: u32,
```

Replacement in src/render.rs at line 30 [5.34]

B:BD[4.231] → [4.231:279]

    fn length(&self, font_size: i32) -> usize {

[4.231]

[4.279]

    fn length(&self) -> usize {

Replacement in src/render.rs at line 34 [5.34]

B:BD[4.356] → [4.356:413]

            .map(|i| i.x_advance * font_size / self.upe)

[4.356]

[4.413]

            .map(|i| i.x_advance * self.font_size as i32 / self.upe)

Replacement in src/render.rs at line 40 [5.34]
B:BD[4.476] → [4.476:492]
```
struct Shaper {
```
[4.476]
[4.492]
```
pub struct Shaper {
```

Insertion in src/render.rs at line 44 [5.34]

[4.586]

[6.213]

}
fn shape(
    plans: &mut Plans,
    index: FontIndex,
    font: &rustybuzz::Face,
    mut ubuf: UnicodeBuffer,
) -> GlyphBuffer {
    ubuf.guess_segment_properties();
    let direction = match ubuf.direction() {
        Direction::Invalid => Direction::LeftToRight,
        dir => dir,
    };
    let script = ubuf.script();
    let language = ubuf.language();
    let plan = plans
        .entry((index, direction, script, language.clone()))
        .or_insert_with(|| ShapePlan::new(font, direction, Some(script), language.as_ref(), &[]));
    rustybuzz::shape_with_plan(font, plan, ubuf)

Replacement in src/render.rs at line 66 [5.34]

B:BD[7.442] → [7.442:597]

∅:D[7.597] → [8.345:386]

B:BD[8.345] → [8.345:386]

∅:D[8.386] → [9.495:713]

B:BD[9.495] → [9.495:713]

B:BD[9.713] → [7.598:688]

∅:D[7.688] → [9.866:899]

B:BD[9.866] → [9.866:899]

B:BD[9.899] → [7.689:775]

∅:D[10.172] → [9.986:1002]

∅:D[7.775] → [9.986:1002]

B:BD[9.986] → [9.986:1002]

B:BD[9.1002] → [7.776:829]

∅:D[10.226] → [9.1055:1061]

∅:D[8.441] → [9.1055:1061]

∅:D[7.829] → [9.1055:1061]

B:BD[9.1055] → [9.1055:1061]

B:BD[9.1061] → [7.830:831]

B:BD[7.831] → [4.587:644]

    fn shape(
        plans: &mut Plans,
        index: FontIndex,
        font: &rustybuzz::Face,
        mut ubuf: UnicodeBuffer,
    ) -> GlyphBuffer {
        ubuf.guess_segment_properties();
        let direction = match ubuf.direction() {
            Direction::Invalid => Direction::LeftToRight,
            dir => dir,
        };
        let script = ubuf.script();
        let language = ubuf.language();
        let plan = plans
            .entry((index, direction, script, language.clone()))
            .or_insert_with(|| {
                ShapePlan::new(font, direction, Some(script), language.as_ref(), &[])
            });
        rustybuzz::shape_with_plan(font, plan, ubuf)
    }
    fn make_runs(&mut self, line: RcLine) -> Rc<[Run]> {

[7.442]

[7.926]

    fn make_runs(&mut self, line: RcLine, config: &Config, default_fg: [u8; 4]) -> Rc<[Run]> {
        let font_size = config.font_size;

Replacement in src/render.rs at line 70 [5.34]
B:BD[7.1033] → [7.1033:1068]
```
            let mut curr_font = 0;
```
[7.1033]
[7.1068]
```
            let mut font = 0;
```

Replacement in src/render.rs at line 76 [5.34]

B:BD[11.49] → [12.113:155]

                    let Some(font) = self

[11.49]

[7.1281]

                    let Some(curr_font) = self

Insertion in src/render.rs at line 81 [5.34]

[12.183]

                        // TODO: Render fallback character
                        // For new we'll just use a standin
                        ubuf.add('⋄', 2);

Replacement in src/render.rs at line 86 [5.34]

∅:D[12.240] → [11.50:93]

B:BD[7.1460] → [11.50:93]

∅:D[11.93] → [7.1642:1805]

B:BD[7.1642] → [7.1642:1805]

                    if curr_font != font {
                        let rb_font = &self.fonts[curr_font].1;
                        let glyph_buffer = Self::shape(&mut self.plans, curr_font, rb_font, ubuf);

[12.240]

[13.225]

                    if font != curr_font {
                        let rb_font = &self.fonts[font].1;
                        let glyph_buffer = shape(&mut self.plans, font, rb_font, ubuf);

Replacement in src/render.rs at line 91 [5.34]

B:BD[4.684] → [4.684:782]

                            face: atom.face.clone(),
                            font: curr_font,

[4.684]

[4.782]

                            fg: atom.face.fg.to_rgba(config).unwrap_or(default_fg),
                            bg: atom.face.bg.to_rgba(config),
                            font_size,
                            font,

Replacement in src/render.rs at line 98 [5.34]
∅:D[14.563] → [7.2048:2090]
∅:D[4.909] → [7.2048:2090]
B:BD[7.2048] → [7.2048:2090]
```
                        curr_font = font;
```
[4.909]
[11.94]
```
                        font = curr_font;
```

Replacement in src/render.rs at line 106 [5.34]

B:BD[7.2367] → [7.2367:2514]

                let rb_font = &self.fonts[curr_font].1;
                let glyph_buffer = Self::shape(&mut self.plans, curr_font, rb_font, ubuf);

[7.2258]

[4.910]

                let rb_font = &self.fonts[font].1;
                let glyph_buffer = shape(&mut self.plans, font, rb_font, ubuf);

Replacement in src/render.rs at line 109 [5.34]

B:BD[4.941] → [4.941:1023]

                    face: atom.face.clone(),
                    font: curr_font,

[4.941]

[4.1023]

                    fg: atom.face.fg.to_rgba(config).unwrap_or(default_fg),
                    bg: atom.face.bg.to_rgba(config),
                    font_size,
                    font,

Replacement in src/render.rs at line 125 [5.34]
B:BD[15.97] → [15.97:125]
```
            let oldv = v.0;
```
[15.97]
[15.125]
```
            let used = v.0;
```
Replacement in src/render.rs at line 127 [5.34]
B:BD[15.150] → [15.150:167]
```
            oldv
```
[15.150]
[15.167]
```
            used
```
Replacement in src/render.rs at line 151 [5.34]
B:BD[16.979] → [7.4040:4062]
```
pub struct Renderer {
```
[16.979]
[14.692]
```
/// A wrapper around a buffer
pub struct Target<'a> {
```
Replacement in src/render.rs at line 154 [5.34]
∅:D[14.722] → [7.4209:4258]
B:BD[7.4209] → [7.4209:4258]
B:BD[7.4258] → [12.675:695]
```
    shaper: Shaper,
    rasterizer: Rasterizer,
    font_size: u32,
```
[14.722]
[7.4278]
```
    pub buf: &'a mut [u32],
```

Replacement in src/render.rs at line 156 [5.34]

B:BD[7.4280] → [7.4280:4297]

B:BD[7.4297] → [17.0:51]

∅:D[17.51] → [12.696:784]

B:BD[7.4986] → [12.696:784]

∅:D[12.784] → [7.6073:6091]

B:BD[16.2101] → [7.6073:6091]

B:BD[7.6091] → [17.52:78]

∅:D[17.78] → [7.6166:6210]

B:BD[7.6166] → [7.6166:6210]

B:BD[7.6210] → [12.785:812]

∅:D[12.812] → [7.6239:6256]

B:BD[7.6239] → [7.6239:6256]

B:BD[7.6256] → [12.813:980]

B:BD[12.980] → [6.688:762]

∅:D[6.762] → [12.1064:1790]

B:BD[12.1064] → [12.1064:1790]


impl Renderer {
    pub fn new() -> Result<Self, Box<dyn Error>> {
        let shaper = Shaper::default();
        let rasterizer = Rasterizer::default();
        Ok(Self {
            size: (0, 0),
            shaper,
            rasterizer,
            font_size: 14,
        })
    }
    pub fn configure(&mut self, config: &Config) -> Result<(), Box<dyn Error>> {
        self.font_size = config.mosham_font_size.parse().expect("Invalid font size");
        self.shaper.fonts.clear();
        self.rasterizer.fonts.clear();
        for font in &config.mosham_fonts {
            let property = if font == "monospace" {
                FontPropertyBuilder::new().monospace().build()
            } else {
                FontPropertyBuilder::new().family(font).build()
            };
            let (data, _) = system_fonts::get(&property).expect("Failed to load font");
            let rb_face =
                rustybuzz::Face::from_slice(unsafe { &*(data.as_slice() as *const [u8]) }, 0)
                    .ok_or("Failed to load rustybuzz font")?;
            let fd_face = fontdue::Font::from_bytes(data.as_slice(), FontSettings::default())?;
            self.shaper.fonts.push((data, rb_face));
            self.rasterizer.fonts.push(fd_face);

[7.4280]

[12.1790]

impl<'a> Target<'a> {
    pub fn new(buf: &'a mut [u32], width: usize, height: usize) -> Self {
        Self {
            buf,
            size: (width, height),

Deletion in src/render.rs at line 162 [5.34]

B:BD[12.1800] → [12.1800:1907]

        self.shaper.cache = HashMap::new();
        self.rasterizer.cache = HashMap::new();
        Ok(())

Replacement in src/render.rs at line 164 [5.34]

B:BD[7.6257] → [7.6257:6296]

B:BD[7.6296] → [12.1914:1959]

B:BD[12.1959] → [6.763:770]

B:BD[6.770] → [17.79:251]

    pub fn line_height(&self) -> u32 {
        (self.font_size as f32 * 1.5) as u32
    }
    fn draw_background(
        &mut self,
        buf: &mut [u32],
        x: usize,
        y: usize,
        w: usize,
        h: usize,
        color: [u8; 4],
    ) {

[7.6257]

[14.981]

    #[inline]
    fn draw_rect(&mut self, x: usize, y: usize, w: usize, h: usize, color: [u8; 4]) {

Replacement in src/render.rs at line 168 [5.34]

B:BD[14.1045] → [14.1045:1083]

                if j >= self.size.0 {

[14.1045]

[6.1062]

                if j >= self.size.0 || i >= self.size.1 {

Deletion in src/render.rs at line 171 [5.34]
B:BD[6.1107] → [14.1084:1122]
∅:D[14.1122] → [6.1149:1195]
B:BD[6.1149] → [6.1149:1195]
```
                if i >= self.size.1 {
                    return;
                }
```

Replacement in src/render.rs at line 172 [5.34]

B:BD[17.300] → [3.0:55]

                buf[bidx] = u32::from_be_bytes(color);

[17.300]

[14.1178]

                self.buf[bidx] = u32::from_be_bytes(color);

Insertion in src/render.rs at line 176 [5.34]
[14.1208]
[14.1208]
```
}
```

Replacement in src/render.rs at line 178 [5.34]

B:BD[14.1250] → [14.1250:1296]

B:BD[14.1296] → [17.426:451]

∅:D[17.451] → [4.1127:1200]

B:BD[14.1296] → [4.1127:1200]

∅:D[4.1200] → [14.1381:1463]

B:BD[14.1381] → [14.1381:1463]

B:BD[14.1463] → [4.1201:1370]

    fn rasterize_segment(
        &mut self,
        buf: &mut [u32],
        run: &Run,
        config: &Config,
        default_fg: [u8; 4],
        pos: &mut (usize, usize),
    ) {
        let fs = self.font_size as i32;
        let bg = run.face.bg.to_rgba(config);
        let fg = run.face.fg.to_rgba(config).unwrap_or(default_fg);
        let line_height = self.line_height() as usize;

[14.1209]

[4.1370]

pub fn load_fonts(
    fonts: &[String],
    shaper: &mut Shaper,
    rasterizer: &mut Rasterizer,
) -> Result<(), Box<dyn Error>> {
    shaper.fonts.clear();
    shaper.cache.clear();
    rasterizer.fonts.clear();
    rasterizer.cache.clear();
    for font in fonts {
        let property = if font == "monospace" {
            FontPropertyBuilder::new().monospace().build()
        } else {
            FontPropertyBuilder::new().family(font).build()
        };
        let (data, _) = system_fonts::get(&property).expect("Failed to load font");
        let rb_face = rustybuzz::Face::from_slice(unsafe { &*(data.as_slice() as *const [u8]) }, 0)
            .ok_or("Failed to load rustybuzz font")?;
        let fd_face = fontdue::Font::from_bytes(data.as_slice(), FontSettings::default())?;
        shaper.fonts.push((data, rb_face));
        rasterizer.fonts.push(fd_face);
    }
    Ok(())
}

Replacement in src/render.rs at line 203 [5.34]

B:BD[4.1371] → [4.1371:1436]

B:BD[4.1436] → [17.452:473]

∅:D[17.473] → [4.1436:1625]

B:BD[4.1436] → [4.1436:1625]

        if let Some(bg) = bg {
            self.draw_background(
                buf,
                pos.0,
                pos.1 - line_height + 4,
                run.length(self.font_size as i32),
                line_height,
                bg,
            );
        }

[4.1371]

[4.1625]

pub fn line_height(font_size: f32) -> f32 {
    font_size * 1.5
}

Replacement in src/render.rs at line 207 [5.34]

B:BD[4.1626] → [4.1626:1737]

        let Run {
            upe,
            glyph_buffer,
            font,
            ..
        } = run;

[4.1626]

[14.1566]

fn rasterize_segment(
    buf: &mut Target,
    pos: &mut (usize, usize),
    run: &Run,
    rasterizer: &mut Rasterizer,
) {
    let Run {
        upe,
        glyph_buffer,
        font,
        font_size,
        ..
    } = run;
    let line_height = line_height(*font_size as f32) as usize;
    if let Some(bg) = run.bg {
        buf.draw_rect(
            pos.0,
            pos.1 - line_height + 4,
            run.length(),
            line_height,
            bg,
        );
    }
    let fs = *font_size as i32;

Replacement in src/render.rs at line 232 [5.34]

B:BD[14.1567] → [14.1567:1787]

B:BD[14.1787] → [4.1738:1822]

        for i in 0..glyph_buffer.len() {
            let ginfo = glyph_buffer.glyph_infos()[i];
            let gpos = glyph_buffer.glyph_positions()[i];
            let (metrics, data) =
                self.rasterizer
                    .rasterize_glyph(*font, ginfo.glyph_id as u16, self.font_size);

[14.1567]

[14.1870]

    for i in 0..glyph_buffer.len() {
        let ginfo = glyph_buffer.glyph_infos()[i];
        let gpos = glyph_buffer.glyph_positions()[i];
        let (metrics, data) = rasterizer.rasterize_glyph(*font, ginfo.glyph_id as u16, *font_size);

Replacement in src/render.rs at line 237 [5.34]

B:BD[14.1871] → [14.1871:2025]

            let x_off = gpos.x_offset * fs / upe + metrics.xmin;
            let y_off = gpos.y_offset * fs / upe - metrics.ymin - metrics.height as i32;

[14.1871]

[14.2025]

        let x_off = gpos.x_offset * fs / upe + metrics.xmin;
        let y_off = gpos.y_offset * fs / upe - metrics.ymin - metrics.height as i32;

Replacement in src/render.rs at line 240 [5.34]

B:BD[14.2026] → [14.2026:2255]

B:BD[14.2255] → [17.474:526]

∅:D[17.526] → [14.2313:2564]

B:BD[14.2313] → [14.2313:2564]

B:BD[14.2564] → [17.527:592]

B:BD[17.592] → [3.56:92]

∅:D[3.92] → [14.2600:2651]

B:BD[14.2600] → [14.2600:2651]

B:BD[14.2651] → [3.93:142]

∅:D[3.142] → [4.1823:1869]

∅:D[17.646] → [4.1823:1869]

B:BD[14.2705] → [4.1823:1869]

B:BD[4.1869] → [3.143:217]

∅:D[3.217] → [14.2870:2892]

∅:D[17.725] → [14.2870:2892]

B:BD[14.2870] → [14.2870:2892]

B:BD[17.930] → [17.930:989]

            for row in 0..metrics.height {
                for column in 0..metrics.width {
                    let x = (pos.0 as i32 + x_off) as usize + column;
                    let y = (pos.1 as i32 + y_off) as usize + row;
                    let bidx = x + y * self.size.0;
                    let sidx = column + row * metrics.width;
                    if bidx >= buf.len() {
                        break;
                    }
                    if x > self.size.0 {
                        break;
                    }
                    let mut pixel = u32::to_be_bytes(buf[bidx]);
                    for i in 0..4 {
                        let m = data[sidx] as u32;
                        let d = pixel[i] as u32;
                        let s = fg[i] as u32;
                        pixel[i] = ((d * (255 - m) + s * m) / 255) as u8;
                    }
                    buf[bidx] = u32::from_be_bytes(pixel);

[14.2026]

[14.2933]

        for row in 0..metrics.height {
            for column in 0..metrics.width {
                let x = (pos.0 as i32 + x_off) as usize + column;
                let y = (pos.1 as i32 + y_off) as usize + row;
                let bidx = x + y * buf.size.0;
                let sidx = column + row * metrics.width;
                if bidx >= buf.buf.len() {
                    break;
                }
                if x > buf.size.0 {
                    break;

Insertion in src/render.rs at line 252 [5.34]

[14.2951]

[6.1312]

                let mut pixel = u32::to_be_bytes(buf.buf[bidx]);
                for i in 0..4 {
                    let m = data[sidx] as u32;
                    let d = pixel[i] as u32;
                    let s = run.fg[i] as u32;
                    pixel[i] = ((d * (255 - m) + s * m) / 255) as u8;
                }
                buf.buf[bidx] = u32::from_be_bytes(pixel);

Deletion in src/render.rs at line 261 [5.34]

B:BD[6.1326] → [14.2952:3071]


            pos.0 += (gpos.x_advance * fs / upe) as usize;
            pos.1 += (gpos.y_advance * fs / upe) as usize;

Insertion in src/render.rs at line 262 [5.34]

[6.1336]

[16.2101]


        pos.0 += (gpos.x_advance * fs / upe) as usize;
        pos.1 += (gpos.y_advance * fs / upe) as usize;

Insertion in src/render.rs at line 266 [5.34]
[16.2107]
[7.6335]
```
}
```

Replacement in src/render.rs at line 268 [5.34]

B:BD[7.6336] → [17.990:1133]

∅:D[17.1133] → [6.1337:1629]

B:BD[12.2047] → [6.1337:1629]

B:BD[6.1629] → [17.1134:1213]

∅:D[17.1213] → [14.3146:3201]

B:BD[14.3146] → [14.3146:3201]

    pub fn render(
        &mut self,
        ui: &Ui,
        config: &Config,
        buf: &mut [u32],
    ) -> Result<(), Box<dyn Error>> {
        let default_bg = ui
            .default_face
            .bg
            .to_rgba(config)
            .unwrap_or(config.mosham_black.0);
        let default_fg = ui
            .default_face
            .fg
            .to_rgba(config)
            .unwrap_or(config.mosham_white.0);
        self.draw_background(buf, 0, 0, self.size.0, self.size.1, default_bg);
        let line_height = self.line_height() as usize;

[7.6336]

[5.5341]

pub fn render(
    buf: &mut Target,
    shaper: &mut Shaper,
    rs: &mut Rasterizer,
    ui: &Ui,
    config: &Config,
) -> Result<(), Box<dyn Error>> {
    let default_bg = ui.default_face.bg.to_rgba(config).unwrap_or(config.black.0);
    let default_fg = ui.default_face.fg.to_rgba(config).unwrap_or(config.white.0);
    buf.draw_rect(0, 0, buf.size.0, buf.size.1, default_bg);
    let line_height = line_height(config.font_size as f32) as usize;

Replacement in src/render.rs at line 280 [5.34]

∅:D[6.1774] → [18.42:82]

B:BD[7.6390] → [18.42:82]

∅:D[18.82] → [19.4177:4209]

∅:D[7.6437] → [19.4177:4209]

B:BD[19.4177] → [19.4177:4209]

B:BD[19.4209] → [4.1870:1938]

B:BD[4.1938] → [17.1214:1294]

∅:D[17.1294] → [19.4570:4584]

∅:D[4.2013] → [19.4570:4584]

∅:D[14.3727] → [19.4570:4584]

∅:D[7.6892] → [19.4570:4584]

B:BD[19.4570] → [19.4570:4584]

∅:D[8.1827] → [19.4584:4607]

B:BD[19.4584] → [19.4584:4607]

B:BD[19.4607] → [7.6893:6927]

        let mut pos = (0, line_height);
        for line in &ui.lines {
            for run in self.shaper.make_runs(line.clone()).iter() {
                self.rasterize_segment(buf, run, config, default_fg, &mut pos);
            }
            pos.0 = 0;
            pos.1 += line_height;

[5.5342]

[19.4661]

    let mut pos = (0, line_height);
    for line in &ui.lines {
        for run in shaper.make_runs(line.clone(), config, default_fg).iter() {
            rasterize_segment(buf, &mut pos, run, rs);

Replacement in src/render.rs at line 285 [5.34]

B:BD[19.4671] → [6.2347:2402]

B:BD[6.2402] → [14.3728:3768]

        let line_bg = ui.line_face.bg.to_rgba(config);
        let status_padding: usize = 10;

[19.4671]

[20.158]

        pos.0 = 0;
        pos.1 += line_height;
    }
    let status_padding: usize = 10;

Replacement in src/render.rs at line 290 [5.34]
B:BD[20.159] → [14.3769:3815]
∅:D[20.209] → [5.6831:6850]
∅:D[8.1894] → [5.6831:6850]
∅:D[16.2215] → [5.6831:6850]
∅:D[6.2451] → [5.6831:6850]
∅:D[14.3815] → [5.6831:6850]
∅:D[19.4741] → [5.6831:6850]
∅:D[7.6988] → [5.6831:6850]
B:BD[5.6831] → [5.6831:6850]
```
        pos.1 = self.size.1 - status_padding;
        pos.0 = 0;
```
[20.159]
[19.4742]
```
    pos.1 = buf.size.1 - status_padding;
    pos.0 = 0;
```

Replacement in src/render.rs at line 293 [5.34]

B:BD[19.4743] → [6.2452:2488]

B:BD[6.2488] → [17.1295:1503]

∅:D[17.1503] → [20.511:521]

∅:D[6.2703] → [20.511:521]

∅:D[14.3908] → [20.511:521]

B:BD[20.511] → [20.511:521]

        if let Some(bg) = line_bg {
            self.draw_background(
                buf,
                0,
                pos.1 - line_height + 4,
                self.size.0,
                line_height,
                bg,
            );
        }

[19.4743]

[20.521]

    if let Some(bg) = ui.line_face.bg.to_rgba(config) {
        buf.draw_rect(0, pos.1 - line_height + 4, buf.size.0, line_height, bg);
    }
    let line_fg = ui.line_face.fg.to_rgba(config).unwrap_or(default_fg);

Replacement in src/render.rs at line 298 [5.34]

B:BD[20.522] → [4.2014:2169]

B:BD[4.2169] → [17.1504:1577]

∅:D[17.1577] → [19.5091:5101]

∅:D[4.2237] → [19.5091:5101]

∅:D[14.4408] → [19.5091:5101]

∅:D[7.7405] → [19.5091:5101]

B:BD[19.5091] → [19.5091:5101]

        for run in self.shaper.make_runs(ui.prompt_line.clone()).iter() {
            let line_fg = ui.line_face.fg.to_rgba(config).unwrap_or(default_fg);
            self.rasterize_segment(buf, run, config, line_fg, &mut pos);
        }

[20.522]

[19.5101]

    for run in shaper
        .make_runs(ui.prompt_line.clone(), config, line_fg)
        .iter()
    {
        rasterize_segment(buf, &mut pos, run, rs);
    }

Replacement in src/render.rs at line 305 [5.34]

B:BD[19.5102] → [7.7406:7535]

B:BD[7.7535] → [4.2238:2303]

∅:D[4.2303] → [7.7725:7745]

∅:D[6.3422] → [7.7725:7745]

∅:D[14.4600] → [7.7725:7745]

B:BD[19.5887] → [7.7725:7745]

        let mode_line = self.shaper.make_runs(ui.mode_line.clone());
        let text_width: i32 = mode_line
            .iter()
            .map(|run| run.length(self.font_size as i32) as i32)
            .sum();

[19.5102]

[19.5993]

    let mode_fg = ui.line_face.fg.to_rgba(config).unwrap_or(default_fg);
    let mode_line = shaper.make_runs(ui.mode_line.clone(), config, mode_fg);
    let text_width: i32 = mode_line.iter().map(|run| run.length() as i32).sum();

Replacement in src/render.rs at line 309 [5.34]

B:BD[19.5994] → [14.4601:4666]

B:BD[14.4666] → [4.2304:2423]

B:BD[4.2423] → [17.1578:1651]

∅:D[17.1651] → [4.2491:2501]

B:BD[4.2491] → [4.2491:2501]

        pos.0 = self.size.0.saturating_sub(text_width as usize);
        for run in mode_line.iter() {
            let mode_fg = ui.line_face.fg.to_rgba(config).unwrap_or(default_fg);
            self.rasterize_segment(buf, run, config, mode_fg, &mut pos);
        }

[19.5994]

[4.2501]

    pos.0 = buf.size.0.saturating_sub(text_width as usize);
    for run in mode_line.iter() {
        rasterize_segment(buf, &mut pos, run, rs);
    }

Replacement in src/render.rs at line 314 [5.34]

B:BD[4.2502] → [4.2502:3178]

        let menu_padding_x: usize = 2;
        let menu_padding_y: usize = 2;
        let mut menu_space: usize = 0;
        for menu in &ui.menus {
            let lines: Vec<_> = menu
                .content
                .iter()
                .map(|line| self.shaper.make_runs(line.clone()))
                .collect();
            let menu_bg = menu.menu_face.bg.to_rgba(config).unwrap_or(default_bg);
            let menu_fg = menu.menu_face.fg.to_rgba(config).unwrap_or(default_fg);
            let selected_fg = menu.selected_face.fg.to_rgba(config).unwrap_or(default_fg);
            let selected_bg = menu.selected_face.bg.to_rgba(config).unwrap_or(default_bg);

[4.2502]

[4.3178]

    let menu_padding_x: usize = 2;
    let menu_padding_y: usize = 2;
    let mut menu_space: usize = 0;
    for menu in &ui.menus {
        let menu_bg = menu.menu_face.bg.to_rgba(config).unwrap_or(default_bg);
        let menu_fg = menu.menu_face.fg.to_rgba(config).unwrap_or(default_fg);
        let selected_fg = menu.selected_face.fg.to_rgba(config).unwrap_or(default_fg);
        let selected_bg = menu.selected_face.bg.to_rgba(config).unwrap_or(default_bg);
        let lines = menu.content.iter().enumerate().map(|(i, line)| {
            if menu.selected == i {
                (
                    i,
                    selected_bg,
                    shaper.make_runs(line.clone(), config, selected_fg),
                )
            } else {
                (i, menu_bg, shaper.make_runs(line.clone(), config, menu_fg))
            }
        });

Replacement in src/render.rs at line 334 [5.34]

B:BD[4.3179] → [4.3179:3457]

            match menu.style {
                MenuShowStyle::Prompt => {
                    let width = self.font_size * 15;
                    let num_width = self.size.0 / width as usize;
                    let num_height = usize::min(menu.content.len() / num_width, 10);

[4.3179]

[4.3519]

        match menu.style {
            MenuShowStyle::Prompt => {
                let width = config.font_size * 15;
                let num_width = buf.size.0 / width as usize;
                let num_height = usize::min(menu.content.len() / num_width, 10);

Replacement in src/render.rs at line 340 [5.34]

B:BD[4.3520] → [4.3520:3657]

                    let width = self.size.0 / num_width;
                    menu_space = line_height * num_height + menu_padding_y * 2;

[4.3520]

[4.3657]

                let width = buf.size.0 / num_width;
                menu_space = line_height * num_height + menu_padding_y * 2;

Replacement in src/render.rs at line 343 [5.34]

B:BD[4.3658] → [4.3658:4386]

                    for (i, line) in lines.into_iter().enumerate() {
                        let x = i % num_width;
                        let y = i / num_width;
                        if y >= num_height {
                            break;
                        }
                        pos.0 = x * width + menu_padding_x;
                        pos.1 = (self.size.1).saturating_sub(
                            line_height * (y + 1) + menu_padding_y + status_padding,
                        );
                        let (fg, bg) = if menu.selected == i {
                            (selected_fg, selected_bg)
                        } else {
                            (menu_fg, menu_bg)
                        };

[4.3658]

[4.4386]

                for (i, bg, line) in lines {
                    let x = i % num_width;
                    let y = i / num_width;
                    if y >= num_height {
                        break;
                    }
                    pos.0 = x * width + menu_padding_x;
                    pos.1 = (buf.size.1)
                        .saturating_sub(line_height * (y + 1) + menu_padding_y + status_padding);

Replacement in src/render.rs at line 353 [5.34]

B:BD[4.4387] → [4.4387:4433]

B:BD[4.4433] → [17.1652:1685]

∅:D[17.1685] → [4.4433:4705]

B:BD[4.4433] → [4.4433:4705]

B:BD[4.4705] → [17.1686:1770]

∅:D[17.1770] → [4.4784:4810]

B:BD[4.4784] → [4.4784:4810]

                        self.draw_background(
                            buf,
                            pos.0,
                            pos.1 - line_height + 4,
                            width,
                            line_height,
                            bg,
                        );
                        for run in line.iter() {
                            self.rasterize_segment(buf, run, config, fg, &mut pos);
                        }

[4.4387]

[4.4810]

                    buf.draw_rect(pos.0, pos.1 - line_height + 4, width, line_height, bg);
                    for run in line.iter() {
                        rasterize_segment(buf, &mut pos, run, rs);

Deletion in src/render.rs at line 358 [5.34]
B:BD[4.4850] → [4.4850:4874]
```
                _ => {}
```
Insertion in src/render.rs at line 359 [5.34]
[6.3918]
[14.5129]
```
            _ => {}
```
Insertion in src/render.rs at line 361 [5.34]
[14.5139]
[14.5139]
```
    }
```

Replacement in src/render.rs at line 363 [5.34]

B:BD[14.5140] → [14.5140:5250]

B:BD[14.5250] → [4.4875:5084]

∅:D[4.5084] → [14.5439:5523]

B:BD[14.5439] → [14.5439:5523]

B:BD[14.5523] → [4.5085:5162]

∅:D[4.5162] → [14.5762:6077]

B:BD[14.5762] → [14.5762:6077]

        let info_padding_x: usize = 5;
        let info_padding_y: usize = 5;
        for info in &ui.infos {
            let lines: Vec<_> = info
                .content
                .iter()
                .map(|line| self.shaper.make_runs(line.clone()))
                .collect();
            let width = lines
                .iter()
                .map(|run| {
                    run.iter()
                        .map(|run| run.length(self.font_size as i32) as i32)
                        .sum::<i32>()
                })
                .max()
                .unwrap_or(0) as usize
                + info_padding_x * 2;
            let height = line_height * info.content.len() + info_padding_y * 2;
            let info_bg = info.face.bg.to_rgba(config).unwrap_or(default_bg);

[14.5140]

[14.6077]

    let info_padding_x: usize = 5;
    let info_padding_y: usize = 5;
    for info in &ui.infos {
        let info_fg = info.face.fg.to_rgba(config).unwrap_or(default_fg);

Replacement in src/render.rs at line 368 [5.34]

B:BD[14.6078] → [14.6078:6305]

B:BD[14.6305] → [4.5163:5256]

∅:D[4.5256] → [14.6385:6640]

B:BD[14.6385] → [14.6385:6640]

B:BD[14.6640] → [17.1771:1848]

            match info.style {
                InfoShowStyle::Prompt => {
                    pos.0 = self.size.0.saturating_sub(width);
                    pos.1 = self
                        .size
                        .1
                        .saturating_sub(height + line_height + status_padding + menu_space);
                }
                InfoShowStyle::Modal => {
                    pos.0 = (self.size.0.saturating_sub(width)) / 2;
                    pos.1 = (self.size.1.saturating_sub(height)) / 2;
                }
                _ => {}
            }
            self.draw_background(buf, pos.0, pos.1, width, height, info_bg);

[14.6078]

[4.5257]

        let lines: Vec<_> = info
            .content
            .iter()
            .map(|line| shaper.make_runs(line.clone(), config, info_fg))
            .collect();
        let width = lines
            .iter()
            .map(|run| run.iter().map(|run| run.length() as i32).sum::<i32>())
            .max()
            .unwrap_or(0) as usize
            + info_padding_x * 2;
        let height = line_height * info.content.len() + info_padding_y * 2;
        let info_bg = info.face.bg.to_rgba(config).unwrap_or(default_bg);

Replacement in src/render.rs at line 382 [5.34]

∅:D[4.5258] → [14.6712:6797]

B:BD[14.6712] → [14.6712:6797]

B:BD[14.6797] → [4.5259:5291]

∅:D[4.5291] → [14.6828:6897]

B:BD[14.6828] → [14.6828:6897]

B:BD[14.6897] → [4.5292:5419]

B:BD[4.5419] → [17.1849:1930]

∅:D[17.1930] → [14.7790:7808]

∅:D[4.5495] → [14.7790:7808]

B:BD[14.7790] → [14.7790:7808]

            let start = pos.0 + info_padding_x;
            pos.1 += info_padding_y;
            for runs in lines {
                pos.0 = start;
                pos.1 += line_height;
                for run in runs.iter() {
                    let info_fg = info.face.fg.to_rgba(config).unwrap_or(default_fg);
                    self.rasterize_segment(buf, run, config, info_fg, &mut pos);
                }

[4.5258]

[14.7808]

        match info.style {
            InfoShowStyle::Prompt => {
                pos.0 = buf.size.0.saturating_sub(width);
                pos.1 = buf
                    .size
                    .1
                    .saturating_sub(height + line_height + status_padding + menu_space);
            }
            InfoShowStyle::Modal => {
                pos.0 = (buf.size.0.saturating_sub(width)) / 2;
                pos.1 = (buf.size.1.saturating_sub(height)) / 2;

Insertion in src/render.rs at line 394 [5.34]
[14.7822]
[19.6185]
```
            _ => {}
```

Insertion in src/render.rs at line 396 [5.34]

[19.6195]

[14.7823]

        buf.draw_rect(pos.0, pos.1, width, height, info_bg);

Replacement in src/render.rs at line 398 [5.34]

∅:D[14.7824] → [15.179:214]

B:BD[19.6195] → [15.179:214]

B:BD[19.6234] → [19.6234:6249]

        self.shaper.clear_cache();
        Ok(())

[14.7824]

[5.6892]

        let start = pos.0 + info_padding_x;
        pos.1 += info_padding_y;
        for runs in lines {
            pos.0 = start;
            pos.1 += line_height;
            for run in runs.iter() {
                rasterize_segment(buf, &mut pos, run, rs);
            }
        }

Insertion in src/render.rs at line 408 [5.34]
[5.6898]
[5.6942]
```
    shaper.clear_cache();
    Ok(())
```
Replacement in src/main.rs at line 16 [21.49]
B:BD[5.7047] → [7.8161:8183]
```
    render::Renderer,
```
[5.7047]
[21.208]
```
    render::{Rasterizer, Shaper, Target},
```

Insertion in src/main.rs at line 62 [21.49]

[19.6390]

[22.1819]

}
#[derive(Default)]
struct Render {
    pub shaper: Shaper,
    pub rasterizer: Rasterizer,

Replacement in src/main.rs at line 75 [21.49]
∅:D[17.2306] → [19.6404:6440]
B:BD[19.6404] → [19.6404:6440]
B:BD[19.6440] → [12.2353:2381]
```
    render_state: Option<Renderer>,
    config: Option<Config>,
```
[17.2306]
[12.2381]
```
    render: Render,
    config: Config,
```

Replacement in src/main.rs at line 86 [21.49]

∅:D[17.2333] → [22.1898:1930]

B:BD[22.1898] → [22.1898:1930]

B:BD[22.1930] → [12.2394:2420]

            render_state: None,
            config: None,

[17.2333]

[23.195]

            render: Default::default(),
            config: Default::default(),

Deletion in src/main.rs at line 156 [21.49]
B:BD[24.1308] → [17.2334:2384]
```
        self.render_state = Renderer::new().ok();
```

Replacement in src/main.rs at line 179 [21.49]

B:BD[21.912] → [12.2421:2541]

B:BD[12.2541] → [17.3002:3071]

∅:D[17.3071] → [12.2541:2559]

B:BD[12.2541] → [12.2541:2559]

                if let Some(render) = self.render_state.as_mut()
                    && let Some(config) = &self.config
                    && let Some((_, surface)) = self.pixels.as_mut()
                {

[21.912]

[17.3072]

                if let Some((_, surface)) = self.pixels.as_mut() {

Replacement in src/main.rs at line 181 [21.49]

B:BD[17.3159] → [17.3159:3231]

                    render.render(&self.ui, config, &mut buf).unwrap();

[17.3159]

[17.3231]

                    let width = buf.width().get() as usize;
                    let height = buf.height().get() as usize;
                    let mut target = Target::new(&mut buf, width, height);
                    render::render(
                        &mut target,
                        &mut self.render.shaper,
                        &mut self.render.rasterizer,
                        &self.ui,
                        &self.config,
                    )
                    .unwrap();

Replacement in src/main.rs at line 199 [21.49]

B:BD[25.629] → [17.3303:3455]

                if let Some(render) = self.render_state.as_mut()
                    && let Some((_, surface)) = self.pixels.as_mut()
                {

[25.629]

[17.3455]

                if let Some((_, surface)) = self.pixels.as_mut() {

Deletion in src/main.rs at line 206 [21.49]

B:BD[19.7200] → [14.7871:7950]

                    render.size = (size.width as usize, size.height as usize);

Replacement in src/main.rs at line 207 [21.49]

∅:D[12.2675] → [7.8294:8368]

∅:D[17.3725] → [7.8294:8368]

B:BD[19.7247] → [7.8294:8368]

                    let lines = (size.height / render.line_height()) - 1;

[17.3725]

[6.4165]

                    let lines = (size.height
                        / render::line_height(self.config.font_size as f32) as u32)
                        - 1;

Replacement in src/main.rs at line 246 [21.49]

B:BD[12.2915] → [12.2915:3064]

B:BD[12.3064] → [2.0:87]

                    if let Some(render) = &mut self.render_state {
                        render.configure(&config).expect("Failed to load fonts");
                        let lines = (render.size.1 as u32 / render.line_height()) - 1;

[12.2915]

[2.87]

                    render::load_fonts(
                        &config.fonts,
                        &mut self.render.shaper,
                        &mut self.render.rasterizer,
                    )
                    .expect("Failed to load font");
                    if let Some((_, surface)) = &mut self.pixels {
                        let buf = surface.buffer_mut().unwrap();
                        let lines = (buf.height().get() as u32
                            / render::line_height(config.font_size as f32) as u32)
                            - 1;

Replacement in src/main.rs at line 260 [21.49]

B:BD[6.4236] → [6.4236:4284]

                    self.config = Some(config);

[6.4236]

[6.4284]

                    self.config = config;

Replacement in src/json_ui.rs at line 91 [27.50]

B:BD[26.7887] → [6.4519:5707]

                BuiltinColor::Black => Some(config.mosham_black.0),
                BuiltinColor::Red => Some(config.mosham_red.0),
                BuiltinColor::Green => Some(config.mosham_green.0),
                BuiltinColor::Yellow => Some(config.mosham_yellow.0),
                BuiltinColor::Blue => Some(config.mosham_blue.0),
                BuiltinColor::Magenta => Some(config.mosham_magenta.0),
                BuiltinColor::Cyan => Some(config.mosham_cyan.0),
                BuiltinColor::White => Some(config.mosham_white.0),
                BuiltinColor::BrightBlack => Some(config.mosham_bright_black.0),
                BuiltinColor::BrightRed => Some(config.mosham_bright_red.0),
                BuiltinColor::BrightGreen => Some(config.mosham_bright_green.0),
                BuiltinColor::BrightYellow => Some(config.mosham_bright_yellow.0),
                BuiltinColor::BrightBlue => Some(config.mosham_bright_blue.0),
                BuiltinColor::BrightMagenta => Some(config.mosham_bright_magenta.0),
                BuiltinColor::BrightCyan => Some(config.mosham_bright_cyan.0),
                BuiltinColor::BrightWhite => Some(config.mosham_bright_white.0),

[26.7887]

[6.5707]

                BuiltinColor::Black => Some(config.black.0),
                BuiltinColor::Red => Some(config.red.0),
                BuiltinColor::Green => Some(config.green.0),
                BuiltinColor::Yellow => Some(config.yellow.0),
                BuiltinColor::Blue => Some(config.blue.0),
                BuiltinColor::Magenta => Some(config.magenta.0),
                BuiltinColor::Cyan => Some(config.cyan.0),
                BuiltinColor::White => Some(config.white.0),
                BuiltinColor::BrightBlack => Some(config.bright_black.0),
                BuiltinColor::BrightRed => Some(config.bright_red.0),
                BuiltinColor::BrightGreen => Some(config.bright_green.0),
                BuiltinColor::BrightYellow => Some(config.bright_yellow.0),
                BuiltinColor::BrightBlue => Some(config.bright_blue.0),
                BuiltinColor::BrightMagenta => Some(config.bright_magenta.0),
                BuiltinColor::BrightCyan => Some(config.bright_cyan.0),
                BuiltinColor::BrightWhite => Some(config.bright_white.0),

Replacement in src/json_ui.rs at line 187 [27.50]
B:BD[12.4371] → [12.4371:4403]
```
    vec![String::from("serif")]
```
[12.4371]
[12.4403]
```
    vec![String::from("monospace")]
```

Replacement in src/json_ui.rs at line 189 [27.50]

B:BD[12.4405] → [12.4405:4463]

fn default_font_size() -> String {
    String::from("14")

[12.4405]

[12.4463]

fn default_font_size() -> u32 {
    14

Replacement in src/json_ui.rs at line 193 [27.50]
B:BD[3.1068] → [3.1068:1098]
```
    ArgbColor([0, 0, 0, 255])
```
[3.1068]
[12.4521]
```
    ArgbColor([255, 0, 0, 0])
```
Replacement in src/json_ui.rs at line 196 [27.50]
B:BD[3.1123] → [3.1123:1155]
```
    ArgbColor([255, 0, 0, 255])
```
[3.1123]
[12.4579]
```
    ArgbColor([255, 255, 0, 0])
```
Replacement in src/json_ui.rs at line 199 [27.50]
B:BD[3.1182] → [3.1182:1214]
```
    ArgbColor([0, 255, 0, 255])
```
[3.1182]
[12.4639]
```
    ArgbColor([255, 0, 255, 0])
```
Replacement in src/json_ui.rs at line 202 [27.50]
B:BD[3.1242] → [3.1242:1276]
```
    ArgbColor([255, 255, 0, 255])
```
[3.1242]
[12.4702]
```
    ArgbColor([255, 255, 255, 0])
```
Replacement in src/json_ui.rs at line 205 [27.50]
B:BD[3.1302] → [3.1302:1332]
```
    ArgbColor([0, 0, 255, 0])
```
[3.1302]
[12.4759]
```
    ArgbColor([255, 0, 0, 255])
```
Replacement in src/json_ui.rs at line 208 [27.50]
B:BD[3.1361] → [3.1361:1395]
```
    ArgbColor([255, 0, 255, 255])
```
[3.1361]
[12.4823]
```
    ArgbColor([255, 255, 0, 255])
```
Replacement in src/json_ui.rs at line 211 [27.50]
B:BD[3.1421] → [3.1421:1455]
```
    ArgbColor([0, 255, 255, 255])
```
[3.1421]
[12.4884]
```
    ArgbColor([255, 0, 255, 255])
```
Replacement in src/json_ui.rs at line 217 [27.50]
B:BD[3.1552] → [3.1552:1582]
```
    ArgbColor([0, 0, 0, 255])
```
[3.1552]
[12.5013]
```
    ArgbColor([255, 0, 0, 0])
```
Replacement in src/json_ui.rs at line 220 [27.50]
B:BD[3.1614] → [3.1614:1646]
```
    ArgbColor([255, 0, 0, 255])
```
[3.1614]
[12.5078]
```
    ArgbColor([255, 255, 0, 0])
```
Replacement in src/json_ui.rs at line 223 [27.50]
B:BD[3.1680] → [3.1680:1712]
```
    ArgbColor([0, 255, 0, 255])
```
[3.1680]
[12.5145]
```
    ArgbColor([255, 0, 255, 0])
```
Replacement in src/json_ui.rs at line 226 [27.50]
B:BD[3.1747] → [3.1747:1781]
```
    ArgbColor([255, 255, 0, 255])
```
[3.1747]
[12.5215]
```
    ArgbColor([255, 255, 255, 0])
```
Replacement in src/json_ui.rs at line 229 [27.50]
B:BD[3.1814] → [3.1814:1844]
```
    ArgbColor([0, 0, 255, 0])
```
[3.1814]
[12.5279]
```
    ArgbColor([255, 0, 0, 255])
```
Replacement in src/json_ui.rs at line 232 [27.50]
B:BD[3.1880] → [3.1880:1914]
```
    ArgbColor([255, 0, 255, 255])
```
[3.1880]
[12.5350]
```
    ArgbColor([255, 255, 0, 255])
```
Replacement in src/json_ui.rs at line 235 [27.50]
B:BD[3.1947] → [3.1947:1981]
```
    ArgbColor([0, 255, 255, 255])
```
[3.1947]
[12.5418]
```
    ArgbColor([255, 0, 255, 255])
```

Insertion in src/json_ui.rs at line 260 [27.50]

[12.6075]

}
struct StringIntegerVisitor;
impl<'de> Visitor<'de> for StringIntegerVisitor {
    type Value = u32;
    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("An integer")
    }
    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        v.parse()
            .map_err(|_| E::invalid_value(Unexpected::Other("Expected string"), &""))
    }
}
fn string_integer<'de, D>(deserializer: D) -> Result<u32, D::Error>
where
    D: Deserializer<'de>,
{
    deserializer.deserialize_string(StringIntegerVisitor)

Replacement in src/json_ui.rs at line 285 [27.50]

B:BD[12.6143] → [12.6143:6372]

B:BD[12.6372] → [3.2052:2085]

∅:D[3.2085] → [12.6405:6435]

B:BD[12.6405] → [12.6405:6435]

B:BD[12.6435] → [3.2086:2117]

∅:D[3.2117] → [12.6466:6498]

B:BD[12.6466] → [12.6466:6498]

B:BD[12.6498] → [3.2118:2151]

∅:D[3.2151] → [12.6531:6564]

B:BD[12.6531] → [12.6531:6564]

B:BD[12.6564] → [3.2152:2186]

∅:D[3.2186] → [12.6598:6629]

B:BD[12.6598] → [12.6598:6629]

B:BD[12.6629] → [3.2187:2219]

∅:D[3.2219] → [12.6661:6695]

B:BD[12.6661] → [12.6661:6695]

B:BD[12.6695] → [3.2220:2255]

∅:D[3.2255] → [12.6730:6761]

B:BD[12.6730] → [12.6730:6761]

B:BD[12.6761] → [3.2256:2288]

∅:D[3.2288] → [12.6793:6825]

B:BD[12.6793] → [12.6793:6825]

B:BD[12.6825] → [3.2289:2322]

∅:D[3.2322] → [12.6858:6897]

B:BD[12.6858] → [12.6858:6897]

B:BD[12.6897] → [3.2323:2363]

∅:D[3.2363] → [12.6937:6974]

B:BD[12.6937] → [12.6937:6974]

B:BD[12.6974] → [3.2364:2402]

∅:D[3.2402] → [12.7012:7051]

B:BD[12.7012] → [12.7012:7051]

B:BD[12.7051] → [3.2403:2443]

∅:D[3.2443] → [12.7091:7131]

B:BD[12.7091] → [12.7091:7131]

B:BD[12.7131] → [3.2444:2485]

∅:D[3.2485] → [12.7172:7210]

B:BD[12.7172] → [12.7172:7210]

B:BD[12.7210] → [3.2486:2525]

∅:D[3.2525] → [12.7249:7290]

B:BD[12.7249] → [12.7249:7290]

B:BD[12.7290] → [3.2526:2568]

∅:D[3.2568] → [12.7332:7370]

B:BD[12.7332] → [12.7332:7370]

B:BD[12.7370] → [3.2569:2608]

∅:D[3.2608] → [12.7409:7448]

B:BD[12.7409] → [12.7409:7448]

B:BD[12.7448] → [3.2609:2649]

    #[serde(default = "default_font", deserialize_with = "comma_list_deserialize")]
    pub mosham_fonts: Vec<String>,
    #[serde(default = "default_font_size")]
    pub mosham_font_size: String,
    #[serde(default = "black")]
    pub mosham_black: ArgbColor,
    #[serde(default = "red")]
    pub mosham_red: ArgbColor,
    #[serde(default = "green")]
    pub mosham_green: ArgbColor,
    #[serde(default = "yellow")]
    pub mosham_yellow: ArgbColor,
    #[serde(default = "blue")]
    pub mosham_blue: ArgbColor,
    #[serde(default = "magenta")]
    pub mosham_magenta: ArgbColor,
    #[serde(default = "cyan")]
    pub mosham_cyan: ArgbColor,
    #[serde(default = "white")]
    pub mosham_white: ArgbColor,
    #[serde(default = "bright_black")]
    pub mosham_bright_black: ArgbColor,
    #[serde(default = "bright_red")]
    pub mosham_bright_red: ArgbColor,
    #[serde(default = "bright_green")]
    pub mosham_bright_green: ArgbColor,
    #[serde(default = "bright_yellow")]
    pub mosham_bright_yellow: ArgbColor,
    #[serde(default = "bright_blue")]
    pub mosham_bright_blue: ArgbColor,
    #[serde(default = "bright_magenta")]
    pub mosham_bright_magenta: ArgbColor,
    #[serde(default = "bright_cyan")]
    pub mosham_bright_cyan: ArgbColor,
    #[serde(default = "bright_white")]
    pub mosham_bright_white: ArgbColor,

[12.6143]

[28.509]

    #[serde(
        default = "default_font",
        deserialize_with = "comma_list_deserialize",
        rename = "mosham_fonts"
    )]
    pub fonts: Vec<String>,
    #[serde(
        default = "default_font_size",
        deserialize_with = "string_integer",
        rename = "mosham_font_size"
    )]
    pub font_size: u32,
    #[serde(default = "black", rename = "mosham_black")]
    pub black: ArgbColor,
    #[serde(default = "red", rename = "mosham_red")]
    pub red: ArgbColor,
    #[serde(default = "green", rename = "mosham_green")]
    pub green: ArgbColor,
    #[serde(default = "yellow", rename = "mosham_yellow")]
    pub yellow: ArgbColor,
    #[serde(default = "blue", rename = "mosham_blue")]
    pub blue: ArgbColor,
    #[serde(default = "magenta", rename = "mosham_magenta")]
    pub magenta: ArgbColor,
    #[serde(default = "cyan", rename = "mosham_cyan")]
    pub cyan: ArgbColor,
    #[serde(default = "white", rename = "mosham_white")]
    pub white: ArgbColor,
    #[serde(default = "bright_black", rename = "mosham_bright_black")]
    pub bright_black: ArgbColor,
    #[serde(default = "bright_red", rename = "mosham_bright_red")]
    pub bright_red: ArgbColor,
    #[serde(default = "bright_green", rename = "mosham_bright_green")]
    pub bright_green: ArgbColor,
    #[serde(default = "bright_yellow", rename = "mosham_bright_yellow")]
    pub bright_yellow: ArgbColor,
    #[serde(default = "bright_blue", rename = "mosham_bright_blue")]
    pub bright_blue: ArgbColor,
    #[serde(default = "bright_magenta", rename = "mosham_bright_magenta")]
    pub bright_magenta: ArgbColor,
    #[serde(default = "bright_cyan", rename = "mosham_bright_cyan")]
    pub bright_cyan: ArgbColor,
    #[serde(default = "bright_white", rename = "mosham_bright_white")]
    pub bright_white: ArgbColor,
}
impl Default for Config {
    fn default() -> Self {
        Self {
            fonts: default_font(),
            font_size: default_font_size(),
            black: black(),
            red: red(),
            green: green(),
            yellow: yellow(),
            blue: blue(),
            magenta: magenta(),
            cyan: cyan(),
            white: white(),
            bright_black: bright_black(),
            bright_red: bright_red(),
            bright_green: bright_green(),
            bright_yellow: bright_yellow(),
            bright_blue: bright_blue(),
            bright_magenta: bright_magenta(),
            bright_cyan: bright_cyan(),
            bright_white: bright_white(),
        }
    }

Insertion in Cargo.toml at line 16 [21.1387]

[17.358312]

divan = "0.1.21"
[dev-dependencies]
divan = "0.1.21"
[[bench]]
name = "render"
harness = false

Insertion in Cargo.lock at line 66 [21.1561]

[21.3185]

[29.260]


[[package]]
name = "anstyle"
version = "1.0.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"

Insertion in Cargo.lock at line 205 [21.1561]

[21.6570]

[12.7644]


[[package]]
name = "clap"
version = "4.5.54"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394"
dependencies = [
 "clap_builder",
]

Insertion in Cargo.lock at line 216 [21.1561]

[12.7657]

name = "clap_builder"
version = "4.5.54"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00"
dependencies = [
 "anstyle",
 "clap_lex",
 "terminal_size",
]
[[package]]
name = "clap_lex"
version = "0.7.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32"
[[package]]

Insertion in Cargo.lock at line 261 [21.1561]

[21.7053]

name = "condtype"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf0a07a401f374238ab8e2f11a104d2851bf9ce711ec69804834de8af45c7af"
[[package]]

Insertion in Cargo.lock at line 372 [21.1561]

[17.359106]

]
[[package]]
name = "divan"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a405457ec78b8fe08b0e32b4a3570ab5dff6dd16eb9e76a5ee0a9d9cbd898933"
dependencies = [
 "cfg-if",
 "clap",
 "condtype",
 "divan-macros",
 "libc",
 "regex-lite",

Insertion in Cargo.lock at line 389 [21.1561]

[17.359121]

[21.8893]

name = "divan-macros"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9556bc800956545d6420a640173e5ba7dfa82f38d3ea5a167eb555bc69ac3323"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]
[[package]]

Insertion in Cargo.lock at line 759 [21.1561]
[30.358]
[12.9785]
```
 "divan",
```

Insertion in Cargo.lock at line 1243 [21.1561]

[21.25617]

name = "regex-lite"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da"
[[package]]

Insertion in Cargo.lock at line 1493 [21.1561]

[21.29962]

[29.13866]

]
[[package]]
name = "terminal_size"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60b8cb979cb11c32ce1603f8137b22262a9d131aaa5c37b5678025f22b8becd0"
dependencies = [
 "rustix 1.1.2",
 "windows-sys 0.60.2",

Insertion in Cargo.lock at line 1934 [21.1561]

[21.40123]

]
[[package]]
name = "windows-sys"
version = "0.60.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
dependencies = [
 "windows-targets 0.53.5",

Replacement in Cargo.lock at line 1978 [21.1561]
B:BD[21.41107] → [21.41107:41132]
```
 "windows_i686_gnullvm",
```
[21.41107]
[21.41132]
```
 "windows_i686_gnullvm 0.52.6",
```

Insertion in Cargo.lock at line 1986 [21.1561]

[21.41271]

name = "windows-targets"
version = "0.53.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
dependencies = [
 "windows-link",
 "windows_aarch64_gnullvm 0.53.1",
 "windows_aarch64_msvc 0.53.1",
 "windows_i686_gnu 0.53.1",
 "windows_i686_gnullvm 0.53.1",
 "windows_i686_msvc 0.53.1",
 "windows_x86_64_gnu 0.53.1",
 "windows_x86_64_gnullvm 0.53.1",
 "windows_x86_64_msvc 0.53.1",
]
[[package]]

Insertion in Cargo.lock at line 2015 [21.1561]

[21.41687]

name = "windows_aarch64_gnullvm"
version = "0.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
[[package]]

Insertion in Cargo.lock at line 2031 [21.1561]

[21.42084]


[[package]]
name = "windows_aarch64_msvc"
version = "0.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"

Insertion in Cargo.lock at line 2049 [21.1561]

[21.42486]


[[package]]
name = "windows_i686_gnu"
version = "0.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"

Insertion in Cargo.lock at line 2061 [21.1561]

[21.42691]


[[package]]
name = "windows_i686_gnullvm"
version = "0.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"

Insertion in Cargo.lock at line 2081 [21.1561]

[21.43108]

name = "windows_i686_msvc"
version = "0.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
[[package]]

Insertion in Cargo.lock at line 2097 [21.1561]

[21.43501]


[[package]]
name = "windows_x86_64_gnu"
version = "0.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"

Insertion in Cargo.lock at line 2117 [21.1561]

[21.43928]

name = "windows_x86_64_gnullvm"
version = "0.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
[[package]]

Insertion in Cargo.lock at line 2135 [21.1561]

[21.44336]

name = "windows_x86_64_msvc"
version = "0.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
[[package]]