guise/markdown/

editor.rs

//! `MarkdownEditor` — an Obsidian-style live-preview markdown editor
//! (gpui entity).
//!
//! Every line renders formatted — headings sized, emphasis styled, list
//! markers replaced by bullets/checkboxes, fenced code highlighted — while
//! the cursor line (and any line the selection touches) *reveals* its
//! markdown syntax for editing. Text soft-wraps; list items keep a hanging
//! indent; checkboxes toggle on click; links open on Cmd+click (plain click
//! when read-only) via [`MarkdownEditorEvent::LinkClick`].
//!
//! ```ignore
//! let editor = cx.new(|cx| {
//!     MarkdownEditor::new(cx).value("# Notes\n\n- [ ] try **guise**")
//! });
//! cx.subscribe(&editor, |_this, _editor, event: &MarkdownEditorEvent, _cx| {
//!     match event {
//!         MarkdownEditorEvent::Change(text) => { /* persist */ }
//!         MarkdownEditorEvent::LinkClick(target) => { /* open */ }
//!     }
//! })
//! .detach();
//! ```

use gpui::prelude::*;
use gpui::{
  canvas, div, point, px, App, Bounds, ClipboardItem, Context, Div, DragMoveEvent, Empty, Entity,
  EntityId, EventEmitter, FocusHandle, Font, FontStyle, FontWeight, Hsla, IntoElement,
  KeyDownEvent, MouseButton, MouseDownEvent, Pixels, ScrollHandle, SharedString,
  StrikethroughStyle, TextAlign, TextRun, UnderlineStyle, Window, WrappedLine,
};

use super::block::{classify, Block, DocState};
use super::layout::{
  byte_for_col, col_for_byte, metrics, plan, src_for_vis, vis_for_src, RowKind, RowPlan,
};
use crate::editor::{token_color, EditorModel, Highlighter, Language, LineState, Pos, TokenKind};
use crate::reactive::Signal;
use crate::theme::theme;
use crate::{Glyph, IconName};

use crate::devtools::Probed;
/// The monospace family for code spans and code blocks.
use crate::style::MONO_FAMILY;
/// Horizontal padding around the document, in px.
const PAD_X: f32 = 16.0;
/// Vertical padding above and below the document, in px.
const PAD_Y: f32 = 12.0;
/// Wrap width used before the first layout pass has measured the content.
const DEFAULT_WRAP: f32 = 640.0;

/// Emitted as the user edits or activates a link.
#[derive(Debug, Clone)]
pub enum MarkdownEditorEvent {
  /// The document changed. Carries the full new text.
  Change(String),
  /// A link was activated (Cmd+click, or plain click when read-only).
  /// Carries the target — a url or a wikilink page name.
  LinkClick(String),
}

/// The drag payload for selection-by-mouse; tagged with the owning entity so
/// two editors in one window never react to each other's drags.
struct MarkdownDrag(EntityId);

/// Per-editor visual overrides. Unset fields fall back to the theme-derived
/// defaults, so an empty style changes nothing.
#[derive(Clone, Copy, Default)]
pub struct MarkdownStyle {
  /// Paint no frame border and no corner radius (an embedded surface).
  pub bare: bool,
  pub bg: Option<Hsla>,
  pub text: Option<Hsla>,
  pub caret: Option<Hsla>,
  pub selection: Option<Hsla>,
  /// Links, bullets, checked boxes, quote bars.
  pub accent: Option<Hsla>,
  pub code_bg: Option<Hsla>,
  pub placeholder: Option<Hsla>,
}

/// One laid-out source line: its plan, shaped text, and geometry. Rebuilt
/// every render; mouse and caret math read the copy from the last frame.
struct Row {
  plan: RowPlan,
  /// `Rc` so the paint closure can share the shaped line with the row.
  text: Option<std::rc::Rc<WrappedLine>>,
  line_h: f32,
  pad_top: f32,
  inset: f32,
  height: f32,
  y: f32,
}

impl Row {
  fn visual_rows(&self) -> usize {
    self
      .text
      .as_ref()
      .map_or(1, |t| t.wrap_boundaries().len() + 1)
  }

  /// Byte offsets where the shaped line wraps, ascending.
  fn boundaries(&self) -> Vec<usize> {
    let Some(text) = &self.text else {
      return Vec::new();
    };
    text
      .wrap_boundaries()
      .iter()
      .map(|b| text.runs()[b.run_ix].glyphs[b.glyph_ix].index)
      .collect()
  }

  /// End-semantics position for a visible byte: a wrap-boundary byte maps
  /// to the end of the earlier visual row.
  fn pos_end(&self, vis: usize) -> (f32, f32) {
    let Some(text) = &self.text else {
      return (0.0, 0.0);
    };
    match text.position_for_index(vis.min(text.len()), px(self.line_h)) {
      Some(p) => (f32::from(p.x), f32::from(p.y)),
      None => (0.0, 0.0),
    }
  }

  /// Caret position for a visible byte: (x, visual row). Start semantics —
  /// a wrap-boundary byte belongs to the row it starts.
  fn caret(&self, vis: usize) -> (f32, usize) {
    let bounds = self.boundaries();
    let row = bounds.iter().filter(|&&b| b <= vis).count();
    if bounds.contains(&vis) {
      return (0.0, row);
    }
    let (x, y) = self.pos_end(vis);
    (
      x,
      if self.line_h > 0.0 {
        (y / self.line_h).round() as usize
      } else {
        0
      },
    )
  }

  /// Selection rectangles for the visible byte range: (x, visual row,
  /// width). `newline` extends the last rect to show a selected line end.
  fn sel_rects(&self, vs: usize, ve: usize, newline: bool, cell: f32) -> Vec<(f32, usize, f32)> {
    let bounds = self.boundaries();
    let (sr, er) = split_visual(&bounds, vs, ve);
    let (sx, _) = if bounds.contains(&vs) {
      (0.0, 0.0)
    } else {
      self.pos_end(vs)
    };
    let (ex, _) = self.pos_end(ve);
    let row_end = |r: usize| -> f32 {
      match bounds.get(r) {
        Some(&b) => self.pos_end(b).0,
        None => self.pos_end(usize::MAX).0,
      }
    };
    let mut rects = Vec::new();
    if sr == er {
      rects.push((sx, sr, (ex - sx).max(0.0)));
    } else {
      rects.push((sx, sr, (row_end(sr) - sx).max(0.0)));
      for r in sr + 1..er {
        rects.push((0.0, r, row_end(r).max(0.0)));
      }
      rects.push((0.0, er, ex.max(0.0)));
    }
    if newline {
      if let Some(last) = rects.last_mut() {
        last.2 += cell;
      }
    }
    rects.retain(|r| r.2 > 0.0);
    rects
  }
}

/// An Obsidian-style live-preview markdown editor. Create with
/// `cx.new(|cx| MarkdownEditor::new(cx))`.
///
/// The text model is the unit-tested [`EditorModel`] (char-index cursor,
/// anchor selection, coalesced undo); markdown structure comes from the pure
/// [`block`](super::block)/[`inline`](super::inline)/[`layout`](super::layout)
/// passes. Read-only editors render pure preview — selection, copy, and
/// plain-click links still work.
pub struct MarkdownEditor {
  model: EditorModel,
  placeholder: SharedString,
  read_only: bool,
  font_size: f32,
  rows: Option<usize>,
  style: MarkdownStyle,
  focus: FocusHandle,
  scroll: ScrollHandle,
  /// Window-space bounds of the document content, captured at prepaint.
  text_bounds: Bounds<Pixels>,
  /// Content width from the last frame — the wrap width for this one.
  wrap_w: f32,
  /// Measured prose cell advance, for indent units and newline cells.
  cell_w: f32,
  /// Last frame's per-line layout, for mouse/caret/scroll math.
  layout: Vec<Row>,
  /// Bring the caret into view on the next render.
  scroll_to_cursor: bool,
  /// Sticky x (content space) for visual-row vertical movement.
  goal_x: Option<f32>,
}

impl EventEmitter<MarkdownEditorEvent> for MarkdownEditor {}

impl MarkdownEditor {
  pub fn new(cx: &mut Context<Self>) -> Self {
    MarkdownEditor {
      model: EditorModel::new(""),
      placeholder: SharedString::default(),
      read_only: false,
      font_size: 15.0,
      rows: None,
      style: MarkdownStyle::default(),
      focus: cx.focus_handle(),
      scroll: ScrollHandle::new(),
      text_bounds: Bounds::default(),
      wrap_w: DEFAULT_WRAP,
      cell_w: 15.0 * 0.55,
      layout: Vec::new(),
      scroll_to_cursor: false,
      goal_x: None,
    }
  }

  // ---- builders ----

  /// Initial markdown text (`text()` is the getter).
  pub fn value(mut self, text: &str) -> Self {
    self.model.set_text(text);
    self
  }

  /// Dimmed hint shown while the document is empty and unfocused.
  pub fn placeholder(mut self, placeholder: impl Into<SharedString>) -> Self {
    self.placeholder = placeholder.into();
    self
  }

  /// Render pure preview: no caret, no edits, no syntax reveal. Selection,
  /// copy, and plain-click link activation still work.
  pub fn read_only(mut self, read_only: bool) -> Self {
    self.read_only = read_only;
    self
  }

  /// Base font size in px (default 15.0). Headings scale from it.
  pub fn font_size(mut self, size: f32) -> Self {
    self.font_size = size;
    self
  }

  /// Minimum height, as a number of paragraph lines.
  pub fn rows(mut self, rows: usize) -> Self {
    self.rows = Some(rows);
    self
  }

  /// Spaces inserted per list indent level (default 4).
  pub fn tab_size(mut self, n: usize) -> Self {
    self.model.set_tab_size(n);
    self
  }

  /// Per-editor visual overrides (see [`MarkdownStyle`]).
  pub fn style(mut self, style: MarkdownStyle) -> Self {
    self.style = style;
    self
  }

  /// Replace the style at runtime (theme switches).
  pub fn set_style(&mut self, style: MarkdownStyle, cx: &mut Context<Self>) {
    self.style = style;
    cx.notify();
  }

  // ---- runtime API ----

  /// The current markdown text.
  pub fn text(&self) -> String {
    self.model.text()
  }

  /// Replace the document, resetting cursor, selection, and history.
  pub fn set_text(&mut self, value: &str, cx: &mut Context<Self>) {
    self.model.set_text(value);
    cx.notify();
  }

  /// The editor's focus handle, so a host can focus it on open.
  pub fn focus_handle(&self) -> FocusHandle {
    self.focus.clone()
  }

  /// Read access to the underlying [`EditorModel`] — cursor, selection,
  /// lines — for hosts building features over the buffer.
  pub fn model(&self) -> &EditorModel {
    &self.model
  }

  /// Mutate the [`EditorModel`] directly. Emits
  /// [`MarkdownEditorEvent::Change`] when the text changed, keeps the
  /// caret visible, and repaints.
  pub fn edit<R>(&mut self, cx: &mut Context<Self>, f: impl FnOnce(&mut EditorModel) -> R) -> R {
    let before = self.model.text();
    let result = f(&mut self.model);
    let after = self.model.text();
    if after != before {
      cx.emit(MarkdownEditorEvent::Change(after));
    }
    self.scroll_to_cursor = true;
    cx.notify();
    result
  }

  /// Two-way bind this editor's text to a `Signal<String>`. The signal is
  /// the source of truth; equality guards on both directions prevent
  /// update loops.
  pub fn bind(entity: &Entity<MarkdownEditor>, signal: &Signal<String>, cx: &mut App) {
    let initial = signal.get(cx);
    entity.update(cx, |this, cx| {
      if this.text() != initial {
        this.set_text(&initial, cx);
      }
    });
    let sink = signal.clone();
    cx.subscribe(entity, move |_editor, event: &MarkdownEditorEvent, cx| {
      if let MarkdownEditorEvent::Change(text) = event {
        sink.set_if_changed(cx, text.clone());
      }
    })
    .detach();
    // Weak handle: a strong clone would form a retain cycle with the
    // subscription above and leak both the editor and the signal.
    let editor = entity.downgrade();
    cx.observe(signal.entity(), move |observed, cx| {
      let value = observed.read(cx).clone();
      editor
        .update(cx, |this, cx| {
          if this.text() != value {
            this.set_text(&value, cx);
          }
        })
        .ok();
    })
    .detach();
  }

  // ---- markdown editing commands ----

  /// Toggle the checkbox on `line` if it is a task item, preserving the
  /// cursor. Returns whether the line was a task.
  pub fn toggle_task(&mut self, line: usize, cx: &mut Context<Self>) -> bool {
    let Some(text) = self.model.line(line) else {
      return false;
    };
    let Block::Task { checked, state, .. } = classify_alone(text) else {
      return false;
    };
    let cursor = self.model.cursor();
    self.edit(cx, |m| {
      // The marker prefix is ASCII, so `state` is also a char column.
      m.move_to(line, state, false);
      m.move_to(line, state + 1, true);
      m.insert(if checked { " " } else { "x" });
      m.move_to(cursor.line, cursor.col, false);
    });
    true
  }

  /// Wrap the selection (or the word at the cursor) in `marker`, or unwrap
  /// it when already wrapped. Single-line selections only.
  fn toggle_wrap(&mut self, marker: &str, cx: &mut Context<Self>) {
    if self.read_only {
      return;
    }
    let chars = marker.chars().count();
    if self.model.selection().is_none() {
      self.model.select_word();
    }
    let Some((start, end)) = self.model.selection() else {
      // Empty spot: insert a pair and park the cursor inside it.
      self.edit(cx, |m| {
        m.insert(&format!("{marker}{marker}"));
        for _ in 0..chars {
          m.move_left(false);
        }
      });
      return;
    };
    if start.line != end.line {
      return;
    }
    // Selection just inside an existing pair: widen to include it.
    let line = self.model.line(start.line).unwrap_or("");
    let (sb, eb) = (byte_for_col(line, start.col), byte_for_col(line, end.col));
    if line[..sb].ends_with(marker) && line[eb..].starts_with(marker) {
      self.model.move_to(start.line, start.col - chars, false);
      self.model.move_to(end.line, end.col + chars, true);
    }
    let Some(sel) = self.model.selected_text() else {
      return;
    };
    let unwrap = sel.starts_with(marker) && sel.ends_with(marker) && sel.len() >= 2 * marker.len();
    let replacement = if unwrap {
      sel[marker.len()..sel.len() - marker.len()].to_string()
    } else {
      format!("{marker}{sel}{marker}")
    };
    self.edit(cx, |m| m.insert(&replacement));
  }

  /// Wrap the selection as a markdown link and park the cursor where the
  /// missing half goes (url for a selection, text otherwise).
  fn insert_link(&mut self, cx: &mut Context<Self>) {
    if self.read_only {
      return;
    }
    let single_line = matches!(self.model.selection(), Some((s, e)) if s.line == e.line);
    self.edit(cx, |m| {
      if single_line {
        let sel = m.selected_text().unwrap_or_default();
        m.insert(&format!("[{sel}]()"));
        m.move_left(false);
      } else {
        m.insert("[]()");
        for _ in 0..3 {
          m.move_left(false);
        }
      }
    });
  }

  /// Enter: continue lists and quotes; an empty item exits the list.
  fn on_enter(&mut self, cx: &mut Context<Self>) {
    let cursor = self.model.cursor();
    let line = self.model.line(cursor.line).unwrap_or("").to_string();
    let in_code = matches!(
      self.layout.get(cursor.line).map(|r| &r.plan.kind),
      Some(RowKind::Code { .. } | RowKind::Fence { .. } | RowKind::FrontMatter)
    );
    let marker = if in_code || self.model.selection().is_some() {
      None
    } else {
      continuation(&line)
    };
    match marker {
      Some(_) if line[prefix_end(&line)..].trim().is_empty() => {
        // Enter on an empty item clears the marker instead of
        // continuing the list.
        let cols = line.chars().count();
        self.edit(cx, |m| {
          m.move_to(cursor.line, 0, false);
          m.move_to(cursor.line, cols, true);
          m.delete_selection();
        });
      }
      Some(marker) => self.edit(cx, |m| {
        m.newline();
        m.insert(&marker);
      }),
      None => self.edit(cx, |m| m.newline()),
    }
  }

  /// Tab / Shift+Tab: indent or outdent list items; plain Tab elsewhere.
  fn on_tab(&mut self, outdent: bool, cx: &mut Context<Self>) {
    let cursor = self.model.cursor();
    let line = self.model.line(cursor.line).unwrap_or("").to_string();
    let is_item = matches!(
      classify_alone(&line),
      Block::Bullet { .. } | Block::Ordered { .. } | Block::Task { .. }
    );
    if !is_item {
      if !outdent {
        self.edit(cx, |m| m.tab());
      }
      return;
    }
    let n = self.model.tab_size();
    if outdent {
      let lead = line.chars().take_while(|&c| c == ' ').count().min(n);
      if lead == 0 {
        return;
      }
      self.edit(cx, |m| {
        m.move_to(cursor.line, 0, false);
        m.move_to(cursor.line, lead, true);
        m.delete_selection();
        m.move_to(cursor.line, cursor.col.saturating_sub(lead), false);
      });
    } else {
      self.edit(cx, |m| {
        m.move_to(cursor.line, 0, false);
        m.insert(&" ".repeat(n));
        m.move_to(cursor.line, cursor.col + n, false);
      });
    }
  }

  /// Backspace at the start of an item's content removes the whole marker
  /// (list or quote) instead of eating into it invisibly.
  fn backspace_marker(&mut self, cx: &mut Context<Self>) -> bool {
    let cursor = self.model.cursor();
    let line = self.model.line(cursor.line).unwrap_or("").to_string();
    let content = match classify_alone(&line) {
      Block::Bullet { content, .. }
      | Block::Ordered { content, .. }
      | Block::Task { content, .. }
      | Block::Quote { content, .. } => content,
      _ => return false,
    };
    // Marker prefixes are ASCII, so `content` is also a char column.
    if content == 0 || cursor.col != content {
      return false;
    }
    self.edit(cx, |m| {
      m.move_to(cursor.line, 0, false);
      m.move_to(cursor.line, content, true);
      m.delete_selection();
    });
    true
  }

  // ---- input handling ----

  fn on_key(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context<Self>) {
    let ks = &event.keystroke;
    let m = ks.modifiers;
    let shift = m.shift;
    if !matches!(ks.key.as_str(), "up" | "down") {
      self.goal_x = None;
    }
    match ks.key.as_str() {
      "left" => {
        if m.platform {
          self.model.home(shift);
        } else if m.alt {
          self.model.word_left(shift);
        } else {
          self.model.move_left(shift);
        }
        self.after_move(cx);
      }
      "right" => {
        if m.platform {
          self.model.end(shift);
        } else if m.alt {
          self.model.word_right(shift);
        } else {
          self.model.move_right(shift);
        }
        self.after_move(cx);
      }
      "up" => {
        if m.platform {
          self.model.doc_start(shift);
          self.after_move(cx);
        } else {
          self.move_visual(false, shift, cx);
        }
      }
      "down" => {
        if m.platform {
          self.model.doc_end(shift);
          self.after_move(cx);
        } else {
          self.move_visual(true, shift, cx);
        }
      }
      "home" => {
        if m.platform {
          self.model.doc_start(shift);
        } else {
          self.model.home(shift);
        }
        self.after_move(cx);
      }
      "end" => {
        if m.platform {
          self.model.doc_end(shift);
        } else {
          self.model.end(shift);
        }
        self.after_move(cx);
      }
      "backspace" => {
        if self.read_only {
          return;
        }
        if self.model.selection().is_none() && !m.platform && !m.alt && self.backspace_marker(cx) {
          cx.stop_propagation();
          return;
        }
        let changed = if self.model.selection().is_some() {
          self.model.delete_selection()
        } else if m.platform {
          self.model.home(true);
          self.model.delete_selection()
        } else if m.alt {
          self.model.word_left(true);
          self.model.delete_selection()
        } else {
          self.model.backspace()
        };
        if changed {
          self.after_edit(cx);
        } else {
          cx.stop_propagation();
        }
      }
      "delete" => {
        if self.read_only {
          return;
        }
        let changed = if self.model.selection().is_some() {
          self.model.delete_selection()
        } else if m.platform {
          self.model.end(true);
          self.model.delete_selection()
        } else if m.alt {
          self.model.word_right(true);
          self.model.delete_selection()
        } else {
          self.model.delete()
        };
        if changed {
          self.after_edit(cx);
        } else {
          cx.stop_propagation();
        }
      }
      "enter" if m.platform => {
        if !self.read_only && self.toggle_task(self.model.cursor().line, cx) {
          cx.stop_propagation();
        }
      }
      "enter" => {
        if self.read_only {
          return;
        }
        self.on_enter(cx);
        cx.stop_propagation();
      }
      "tab" => {
        if m.platform || self.read_only {
          return;
        }
        self.on_tab(shift, cx);
        cx.stop_propagation();
      }
      // Escape bubbles (dialogs close on it) but drops the selection.
      "escape" => {
        if self.model.selection().is_some() {
          self.model.clear_selection();
          cx.notify();
        }
      }
      "a" if m.platform => {
        self.model.select_all();
        cx.notify();
        cx.stop_propagation();
      }
      "b" if m.platform => {
        self.toggle_wrap("**", cx);
        cx.stop_propagation();
      }
      "i" if m.platform => {
        self.toggle_wrap("*", cx);
        cx.stop_propagation();
      }
      "k" if m.platform => {
        self.insert_link(cx);
        cx.stop_propagation();
      }
      "c" if m.platform => {
        if let Some(text) = self.model.copy() {
          cx.write_to_clipboard(ClipboardItem::new_string(text));
        }
        cx.stop_propagation();
      }
      "x" if m.platform => {
        if self.read_only {
          // Selection stays; degrade cut to copy.
          if let Some(text) = self.model.copy() {
            cx.write_to_clipboard(ClipboardItem::new_string(text));
          }
        } else if let Some(text) = self.model.cut() {
          cx.write_to_clipboard(ClipboardItem::new_string(text));
          self.after_edit(cx);
          return;
        }
        cx.stop_propagation();
      }
      "v" if m.platform => {
        if !self.read_only {
          if let Some(text) = cx.read_from_clipboard().and_then(|item| item.text()) {
            if !text.is_empty() {
              self.model.insert(&text);
              self.after_edit(cx);
              return;
            }
          }
        }
        cx.stop_propagation();
      }
      "z" if m.platform => {
        if !self.read_only {
          let changed = if m.shift {
            self.model.redo()
          } else {
            self.model.undo()
          };
          if changed {
            self.after_edit(cx);
            return;
          }
        }
        cx.stop_propagation();
      }
      _ => {
        // Printable input: never on Cmd/Ctrl chords; Option+key is
        // allowed so composed glyphs land.
        if !self.read_only && !m.platform && !m.control {
          if let Some(text) = ks.key_char.as_deref().filter(|t| !t.is_empty()) {
            self.model.insert(text);
            self.after_edit(cx);
          }
        }
        // Everything else bubbles to the host.
      }
    }
    let _ = window;
  }

  fn on_mouse_down(&mut self, ev: &MouseDownEvent, window: &mut Window, cx: &mut Context<Self>) {
    window.focus(&self.focus);
    self.goal_x = None;
    let x = f32::from(ev.position.x) - f32::from(self.text_bounds.origin.x);
    let y = f32::from(ev.position.y) - f32::from(self.text_bounds.origin.y);
    let (line, col) = self.hit(x, y);

    // A click on a task's checkbox toggles it in place.
    if !self.read_only && ev.click_count == 1 {
      if let Some(row) = self.layout.get(line) {
        if let RowKind::Task { .. } = row.plan.kind {
          let in_slot = x < row.inset && x >= 0.0;
          let in_first_row = y >= row.y && y < row.y + row.pad_top + row.line_h;
          if in_slot && in_first_row && self.toggle_task(line, cx) {
            return;
          }
        }
      }
    }
    // Cmd+click (plain click when read-only) follows links.
    if ev.modifiers.platform || self.read_only {
      if let (Some(row), Some(text)) = (self.layout.get(line), self.model.line(line)) {
        if let Some(target) = row.plan.link_at(byte_for_col(text, col)) {
          cx.emit(MarkdownEditorEvent::LinkClick(target.to_string()));
          return;
        }
      }
    }
    match ev.click_count {
      2 => {
        self.model.move_to(line, col, false);
        self.model.select_word();
      }
      n if n > 2 => {
        self.model.move_to(line, col, false);
        self.model.select_line();
      }
      _ => self.model.move_to(line, col, ev.modifiers.shift),
    }
    cx.notify();
  }

  fn on_drag_move(
    &mut self,
    ev: &DragMoveEvent<MarkdownDrag>,
    _window: &mut Window,
    cx: &mut Context<Self>,
  ) {
    if ev.drag(cx).0 != cx.entity_id() {
      return;
    }
    let x = f32::from(ev.event.position.x) - f32::from(self.text_bounds.origin.x);
    let y = f32::from(ev.event.position.y) - f32::from(self.text_bounds.origin.y);
    let (line, col) = self.hit(x, y);
    self.model.move_to(line, col, true);
    self.scroll_to_cursor = true;
    cx.notify();
  }

  /// Content-space position → (line, col), through the last frame's
  /// layout and each row's source↔visible mapping.
  fn hit(&self, x: f32, y: f32) -> (usize, usize) {
    if self.layout.is_empty() {
      return (0, 0);
    }
    let mut line = self.layout.len() - 1;
    for (i, row) in self.layout.iter().enumerate() {
      if y < row.y + row.height {
        line = i;
        break;
      }
    }
    line = line.min(self.model.line_count().saturating_sub(1));
    let row = &self.layout[line];
    let Some(text) = self.model.line(line) else {
      return (line, 0);
    };
    let text_h = (row.visual_rows() as f32 * row.line_h).max(row.line_h);
    let local = point(
      px((x - row.inset).max(0.0)),
      px((y - row.y - row.pad_top).clamp(0.0, text_h - 1.0)),
    );
    let vis = match &row.text {
      Some(shaped) => shaped
        .closest_index_for_position(local, px(row.line_h))
        .unwrap_or_else(|near| near),
      None => 0,
    };
    let src = src_for_vis(&row.plan.segs, vis);
    (line, col_for_byte(text, src))
  }

  /// Arrow up/down across *visual* rows, holding a sticky goal x through
  /// shorter rows — soft wrap means source-line movement would skip rows.
  fn move_visual(&mut self, down: bool, extend: bool, cx: &mut Context<Self>) {
    let cursor = self.model.cursor();
    if self.layout.len() != self.model.line_count() {
      // Stale layout (edit since last frame): plain line movement.
      if down {
        self.model.move_down(extend);
      } else {
        self.model.move_up(extend);
      }
      self.after_move(cx);
      return;
    }
    let row = &self.layout[cursor.line];
    let text = self.model.line(cursor.line).unwrap_or("");
    let vis = vis_for_src(&row.plan.segs, byte_for_col(text, cursor.col));
    let (x, vrow) = row.caret(vis);
    let goal = self.goal_x.unwrap_or(row.inset + x);
    self.goal_x = Some(goal);

    let target = if down {
      if vrow + 1 < row.visual_rows() {
        Some((cursor.line, vrow + 1))
      } else if cursor.line + 1 < self.layout.len() {
        Some((cursor.line + 1, 0))
      } else {
        None
      }
    } else if vrow > 0 {
      Some((cursor.line, vrow - 1))
    } else if cursor.line > 0 {
      Some((
        cursor.line - 1,
        self.layout[cursor.line - 1].visual_rows() - 1,
      ))
    } else {
      None
    };
    let Some((tline, tvrow)) = target else {
      if down {
        self.model.doc_end(extend);
      } else {
        self.model.doc_start(extend);
      }
      self.after_move(cx);
      return;
    };
    let trow = &self.layout[tline];
    let local = point(
      px((goal - trow.inset).max(0.0)),
      px((tvrow as f32 + 0.5) * trow.line_h),
    );
    let vis = match &trow.text {
      Some(shaped) => shaped
        .closest_index_for_position(local, px(trow.line_h))
        .unwrap_or_else(|near| near),
      None => 0,
    };
    let src = src_for_vis(&trow.plan.segs, vis);
    let col = col_for_byte(self.model.line(tline).unwrap_or(""), src);
    self.model.move_to(tline, col, extend);
    self.after_move(cx);
  }

  fn after_edit(&mut self, cx: &mut Context<Self>) {
    cx.emit(MarkdownEditorEvent::Change(self.model.text()));
    self.scroll_to_cursor = true;
    cx.notify();
    cx.stop_propagation();
  }

  fn after_move(&mut self, cx: &mut Context<Self>) {
    self.scroll_to_cursor = true;
    cx.notify();
    cx.stop_propagation();
  }

  /// Nudge the scroll offset so the caret's visual row is inside the
  /// viewport. Runs during render, right after the fresh layout is built.
  fn ensure_cursor_visible(&mut self) {
    let cursor = self.model.cursor();
    let Some(row) = self.layout.get(cursor.line) else {
      return;
    };
    let view_h = f32::from(self.scroll.bounds().size.height);
    if view_h <= 0.0 {
      return;
    }
    let text = self.model.line(cursor.line).unwrap_or("");
    let vis = vis_for_src(&row.plan.segs, byte_for_col(text, cursor.col));
    let (_, vrow) = row.caret(vis);
    let top = row.y + row.pad_top + vrow as f32 * row.line_h;
    let bottom = top + row.line_h + 2.0 * PAD_Y;
    let offset = self.scroll.offset();
    let y = scroll_adjust(f32::from(offset.y), view_h, top, bottom);
    if y != f32::from(offset.y) {
      self.scroll.set_offset(point(offset.x, px(y)));
    }
  }
}

impl Render for MarkdownEditor {
  fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
    let focused = self.focus.is_focused(window);
    let base = self.font_size;

    let t = theme(cx);
    let style = self.style;
    let is_dark = t.scheme.is_dark();
    let frame_border = if focused {
      t.primary().hsla()
    } else {
      t.border().hsla()
    };
    let bg = style.bg.unwrap_or_else(|| t.surface().hsla());
    let text_color = style.text.unwrap_or_else(|| t.text().hsla());
    let dimmed = t.dimmed().hsla();
    let marker_color = t.dimmed().alpha(0.75);
    let accent = style.accent.unwrap_or_else(|| t.primary().hsla());
    let caret_color = style.caret.unwrap_or(accent);
    let selection_bg = style.selection.unwrap_or_else(|| t.primary().alpha(0.25));
    let code_bg = style
      .code_bg
      .unwrap_or_else(|| t.surface_hover().alpha(if is_dark { 0.45 } else { 0.6 }));
    let highlight_bg = t
      .color(crate::theme::ColorName::Yellow, if is_dark { 7 } else { 2 })
      .alpha(if is_dark { 0.45 } else { 0.7 });
    let placeholder_color = style.placeholder.unwrap_or_else(|| t.dimmed().hsla());
    let rule_color = t.border().hsla();
    let quote_bar = t.primary().alpha(0.55);
    let radius = t.radius(t.default_radius);
    let token_colors: [Hsla; 8] = TokenKind::ALL.map(|kind| token_color(kind, t));

    let prose = window.text_style().font();
    let mono = Font {
      family: MONO_FAMILY.into(),
      ..prose.clone()
    };
    let cell_w = {
      let ts = window.text_system();
      let font_id = ts.resolve_font(&prose);
      ts.ch_advance(font_id, px(base))
        .map(f32::from)
        .unwrap_or(base * 0.55)
    };
    self.cell_w = cell_w;
    let base_line_h = (base * 1.6).round();

    let cursor = self.model.cursor();
    let selection = self.model.selection();
    let reveal_range = match selection {
      _ if !focused || self.read_only => None,
      Some((s, e)) => Some((s.line, e.line)),
      None => Some((cursor.line, cursor.line)),
    };
    let show_caret = focused && !self.read_only;
    let show_placeholder = self.model.is_empty() && !focused && !self.placeholder.is_empty();

    // ---- build rows: classify, plan, shape ----
    let wrap_total = self.wrap_w.max(120.0);
    let mut rows: Vec<Row> = Vec::with_capacity(self.model.line_count());
    let mut doc_state = DocState::default();
    let mut hl_state = LineState::default();
    let mut y = 0.0;
    for (i, line) in self.model.lines().iter().enumerate() {
      let lang = doc_state.fence_lang().map(str::to_string);
      let block = classify(line, &mut doc_state);
      if matches!(block, Block::Fence { open: true, .. }) {
        hl_state = LineState::default();
      }
      let reveal = reveal_range.is_some_and(|(s, e)| i >= s && i <= e);
      let plan = plan(line, &block, lang.as_deref(), reveal);

      let m = metrics(&plan.kind);
      let (scale, lh, pt, pb) = (m.scale, m.line_height, m.pad_top, m.pad_bottom);
      let size = (base * scale).round();
      let line_h = (size * lh).round();
      let pad_top = (base * pt).round();
      let pad_bottom = (base * pb).round();

      let inset = match &plan.kind {
        RowKind::Bullet { cols } | RowKind::Task { cols, .. } => {
          *cols as f32 * cell_w + (base * 1.6).round()
        }
        RowKind::Ordered { cols, number } => {
          let shaped = window.text_system().shape_line(
            SharedString::from(format!("{number}.")),
            px(size),
            &[TextRun {
              len: format!("{number}.").len(),
              font: prose.clone(),
              color: Hsla::default(),
              background_color: None,
              underline: None,
              strikethrough: None,
            }],
            None,
          );
          *cols as f32 * cell_w + f32::from(shaped.width) + (base * 0.55).round()
        }
        RowKind::Quote { depth } => *depth as f32 * (base * 1.1).round(),
        RowKind::Code { .. } | RowKind::Fence { .. } => (base * 0.75).round(),
        _ => 0.0,
      };
      let right_pad = match &plan.kind {
        RowKind::Code { .. } | RowKind::Fence { .. } => inset,
        _ => 0.0,
      };
      let wrap = (wrap_total - inset - right_pad).max(60.0);

      let runs = if let RowKind::Code { lang } = &plan.kind {
        let language = fence_language(lang.as_deref());
        let tokens = language.line(&plan.visible, &mut hl_state);
        cover(plan.visible.len(), &tokens)
          .into_iter()
          .map(|(len, kind)| TextRun {
            len,
            font: mono.clone(),
            color: kind.map_or(text_color, |k| token_colors[k.index()]),
            background_color: None,
            underline: None,
            strikethrough: None,
          })
          .collect::<Vec<_>>()
      } else {
        let heading = matches!(plan.kind, RowKind::Heading(_));
        plan
          .runs
          .iter()
          .map(|run| {
            let s = run.style;
            let font = Font {
              family: if s.code {
                MONO_FAMILY.into()
              } else {
                prose.family.clone()
              },
              weight: if heading || s.bold {
                FontWeight::BOLD
              } else {
                prose.weight
              },
              style: if s.italic {
                FontStyle::Italic
              } else {
                prose.style
              },
              ..prose.clone()
            };
            let color = if run.marker {
              marker_color
            } else if run.dim {
              dimmed
            } else if s.link {
              accent
            } else {
              text_color
            };
            TextRun {
              len: run.len,
              font,
              color,
              background_color: if s.highlight {
                Some(highlight_bg)
              } else if s.code {
                Some(code_bg)
              } else {
                None
              },
              underline: (s.link && !run.marker).then(|| UnderlineStyle {
                thickness: px(1.0),
                color: Some(accent),
                wavy: false,
              }),
              strikethrough: s.strike.then(|| StrikethroughStyle {
                thickness: px(1.0),
                color: Some(dimmed),
              }),
            }
          })
          .collect::<Vec<_>>()
      };

      let shaped = window
        .text_system()
        .shape_text(
          SharedString::from(plan.visible.clone()),
          px(size),
          &runs,
          Some(px(wrap)),
          None,
        )
        .ok()
        .and_then(|mut lines| {
          if lines.is_empty() {
            None
          } else {
            Some(std::rc::Rc::new(lines.swap_remove(0)))
          }
        });
      let visual_rows = shaped
        .as_ref()
        .map_or(1, |s| s.wrap_boundaries().len() + 1)
        .max(1);
      let height = pad_top + visual_rows as f32 * line_h + pad_bottom;
      rows.push(Row {
        plan,
        text: shaped,
        line_h,
        pad_top,
        inset,
        height,
        y,
      });
      y += height;
    }
    self.layout = rows;
    if self.scroll_to_cursor {
      self.scroll_to_cursor = false;
      self.ensure_cursor_visible();
    }

    // ---- build elements ----
    let mut row_divs: Vec<Div> = Vec::with_capacity(self.layout.len());
    for (i, row) in self.layout.iter().enumerate() {
      let size_of_row = row
        .text
        .as_ref()
        .map(|t| f32::from(t.font_size()))
        .unwrap_or(base);
      let mut el = div().relative().w_full().h(px(row.height));

      match &row.plan.kind {
        RowKind::Code { .. } => el = el.bg(code_bg),
        RowKind::Fence { open } => {
          el = el.bg(code_bg);
          el = if *open {
            el.rounded_t(px(radius))
          } else {
            el.rounded_b(px(radius))
          };
        }
        RowKind::Rule if !row.plan.revealed => {
          el = el.child(
            div()
              .absolute()
              .left_0()
              .right_0()
              .top(px((row.height / 2.0 - 1.0).max(0.0)))
              .h(px(2.0))
              .rounded(px(1.0))
              .bg(rule_color),
          );
        }
        RowKind::Quote { depth } => {
          let step = (base * 1.1).round();
          for k in 0..*depth {
            el = el.child(
              div()
                .absolute()
                .left(px(k as f32 * step + 1.0))
                .top_0()
                .bottom_0()
                .w(px(3.0))
                .rounded(px(1.5))
                .bg(quote_bar),
            );
          }
        }
        RowKind::Bullet { .. } => {
          let dot = (base * 0.36).round().max(4.0);
          el = el.child(
            div()
              .absolute()
              .left(px(row.inset - dot - (base * 0.6).round()))
              .top(px(row.pad_top + (row.line_h - dot) / 2.0))
              .size(px(dot))
              .rounded_full()
              .bg(marker_color),
          );
        }
        RowKind::Ordered { number, .. } => {
          el = el.child(
            div()
              .absolute()
              .left_0()
              .top(px(row.pad_top))
              .w(px((row.inset - (base * 0.35)).max(0.0)))
              .h(px(row.line_h))
              .flex()
              .items_center()
              .justify_end()
              .text_size(px(size_of_row))
              .text_color(marker_color)
              .child(SharedString::from(format!("{number}."))),
          );
        }
        RowKind::Task { checked, .. } => {
          let box_s = (size_of_row * 1.05).round();
          let boxed = div()
            .absolute()
            .left(px(row.inset - box_s - (base * 0.45).round()))
            .top(px(row.pad_top + (row.line_h - box_s) / 2.0))
            .size(px(box_s))
            .rounded(px(4.0))
            .flex()
            .items_center()
            .justify_center();
          el = el.child(if *checked {
            boxed
              .bg(accent)
              .text_size(px(box_s * 0.8))
              .text_color(gpui::white())
              .child(Glyph::Lucide(IconName::Check))
          } else {
            boxed.border_1().border_color(dimmed)
          });
        }
        _ => {}
      }

      // Selection rectangles.
      if let Some((start, end)) = selection {
        if let Some(text) = self.model.line(i) {
          if let Some((s_col, e_col, newline)) = line_selection(start, end, i, text.chars().count())
          {
            let vs = vis_for_src(&row.plan.segs, byte_for_col(text, s_col));
            let ve = vis_for_src(&row.plan.segs, byte_for_col(text, e_col));
            for (x, vrow, w) in row.sel_rects(vs, ve, newline, cell_w) {
              el = el.child(
                div()
                  .absolute()
                  .left(px(row.inset + x))
                  .top(px(row.pad_top + vrow as f32 * row.line_h))
                  .w(px(w.max(2.0)))
                  .h(px(row.line_h))
                  .bg(selection_bg),
              );
            }
          }
        }
      }

      // The shaped text itself, painted directly so caret/selection
      // math and the glyphs always agree.
      if let Some(shaped) = row.text.clone() {
        if !row.plan.visible.is_empty() {
          let line_h = px(row.line_h);
          let text_h = row.visual_rows() as f32 * row.line_h;
          el = el.child(
            div()
              .absolute()
              .left(px(row.inset))
              .top(px(row.pad_top))
              .w(px((wrap_total - row.inset).max(60.0)))
              .h(px(text_h))
              .child(canvas(
                |_, _, _| (),
                move |bounds, _, window, cx| {
                  let origin = bounds.origin;
                  shaped
                    .paint_background(origin, line_h, TextAlign::Left, None, window, cx)
                    .ok();
                  shaped
                    .paint(origin, line_h, TextAlign::Left, None, window, cx)
                    .ok();
                },
              )),
          );
        }
      }

      // Caret.
      if show_caret && i == cursor.line {
        if let Some(text) = self.model.line(i) {
          let vis = vis_for_src(&row.plan.segs, byte_for_col(text, cursor.col));
          let (x, vrow) = row.caret(vis);
          el = el.child(
            div()
              .absolute()
              .left(px((row.inset + x - 1.0).max(0.0)))
              .top(px(row.pad_top + vrow as f32 * row.line_h))
              .w(px(2.0))
              .h(px(row.line_h))
              .bg(caret_color),
          );
        }
      }

      row_divs.push(el);
    }

    // Invisible bounds probe: its painted origin is content cell (0, 0)
    // and its width is next frame's wrap width.
    let entity = cx.entity();
    let probe = canvas(
      move |bounds, _window, cx| {
        entity.update(cx, |this, cx| {
          this.text_bounds = bounds;
          let w = f32::from(bounds.size.width);
          if (w - this.wrap_w).abs() > 0.5 {
            this.wrap_w = w;
            cx.notify();
          }
        });
      },
      |_, _, _, _| {},
    )
    .absolute()
    .size_full();

    let mut lines_col = div()
      .relative()
      .flex()
      .flex_col()
      .w_full()
      .child(probe)
      .children(row_divs);
    if show_placeholder {
      lines_col = lines_col.child(
        div()
          .absolute()
          .top_0()
          .left_0()
          .text_color(placeholder_color)
          .child(self.placeholder.clone()),
      );
    }

    let content = div().w_full().py(px(PAD_Y)).px(px(PAD_X)).child(lines_col);

    let mut body = div()
      .id("guise-markdown-body")
      .track_focus(&self.focus)
      .on_key_down(cx.listener(Self::on_key))
      .on_mouse_down(MouseButton::Left, cx.listener(Self::on_mouse_down))
      .on_drag(MarkdownDrag(cx.entity_id()), |_, _, _, cx| {
        cx.new(|_| Empty)
      })
      .on_drag_move(cx.listener(Self::on_drag_move))
      .overflow_y_scroll()
      .track_scroll(&self.scroll)
      .w_full()
      .max_h_full()
      .cursor_text()
      .child(content);
    if let Some(rows) = self.rows {
      body = body.min_h(px(rows as f32 * base_line_h + 2.0 * PAD_Y));
    }

    let mut frame = div().flex().flex_col().w_full().h_full();
    if !style.bare {
      frame = frame
        .rounded(px(radius))
        .border_1()
        .border_color(frame_border);
    }
    frame
      .bg(bg)
      .overflow_hidden()
      .text_size(px(base))
      .line_height(px(base_line_h))
      .text_color(text_color)
      .child(body)
      .probe("MarkdownEditor")
  }
}

// ---- pure helpers (unit-tested) ---------------------------------------------

/// Map a fence info string onto a highlighter language.
fn fence_language(lang: Option<&str>) -> Language {
  match lang {
    Some("rust" | "rs") => Language::Rust,
    Some("sql") => Language::Sql,
    Some("json" | "jsonc") => Language::Json,
    _ => Language::None,
  }
}

/// Classify a single line out of document context (fences and frontmatter
/// need the document pass; lists, quotes, and headings don't).
fn classify_alone(line: &str) -> Block {
  let mut state = DocState::default();
  classify("", &mut state);
  classify(line, &mut state)
}

/// The list/quote marker that continues `line` onto the next one, ready to
/// insert after the auto-copied indent — `None` when the line isn't a
/// continuable item.
fn continuation(line: &str) -> Option<String> {
  match classify_alone(line) {
    Block::Task { indent, .. } => {
      let ch = line.as_bytes()[indent] as char;
      Some(format!("{ch} [ ] "))
    }
    Block::Bullet { indent, .. } => {
      let ch = line.as_bytes()[indent] as char;
      Some(format!("{ch} "))
    }
    Block::Ordered { indent, number, .. } => {
      let delim = line[indent..]
        .bytes()
        .find(|b| *b == b'.' || *b == b')')
        .unwrap_or(b'.') as char;
      Some(format!("{}{delim} ", number + 1))
    }
    Block::Quote { depth, .. } => Some("> ".repeat(depth as usize)),
    _ => None,
  }
}

/// Where a continuable item's marker prefix ends (its content offset).
fn prefix_end(line: &str) -> usize {
  match classify_alone(line) {
    Block::Task { content, .. }
    | Block::Bullet { content, .. }
    | Block::Ordered { content, .. }
    | Block::Quote { content, .. } => content,
    _ => 0,
  }
}

/// The visual rows a visible byte range spans, given the wrap-boundary
/// bytes: (start row, end row). Range starts at a boundary belong to the
/// later row; range ends at a boundary belong to the earlier one.
fn split_visual(bounds: &[usize], vs: usize, ve: usize) -> (usize, usize) {
  let sr = bounds.iter().filter(|&&b| b <= vs).count();
  let er = bounds.iter().filter(|&&b| b < ve).count();
  (sr, er.max(sr))
}

/// Cover `len` bytes with contiguous span lengths: token ranges keep their
/// kind, gaps get `None`. Clamps overlap/overflow so lengths sum to `len`.
fn cover(
  len: usize,
  tokens: &[(std::ops::Range<usize>, TokenKind)],
) -> Vec<(usize, Option<TokenKind>)> {
  let mut out = Vec::new();
  let mut at = 0;
  for (range, kind) in tokens {
    let start = range.start.max(at).min(len);
    let end = range.end.max(start).min(len);
    if start > at {
      out.push((start - at, None));
    }
    if end > start {
      out.push((end - start, Some(*kind)));
    }
    at = end.max(at);
  }
  if at < len {
    out.push((len - at, None));
  }
  out
}

/// The selected char-column range on `line` for a normalized selection
/// `(start, end)`, or `None` when the selection misses the line. The `bool`
/// is whether the selection continues past this line's end.
fn line_selection(
  start: Pos,
  end: Pos,
  line: usize,
  line_len: usize,
) -> Option<(usize, usize, bool)> {
  if line < start.line || line > end.line {
    return None;
  }
  let s = if line == start.line {
    start.col.min(line_len)
  } else {
    0
  };
  let e = if line == end.line {
    end.col.min(line_len)
  } else {
    line_len
  };
  let e = e.max(s);
  let newline = line < end.line;
  if e == s && !newline {
    return None;
  }
  Some((s, e, newline))
}

/// Adjust a scroll offset (0 or negative, more negative = scrolled further)
/// so the content range `top..bottom` is inside a `view`-long viewport.
fn scroll_adjust(offset: f32, view: f32, top: f32, bottom: f32) -> f32 {
  let mut adjusted = offset;
  if bottom + adjusted > view {
    adjusted = view - bottom;
  }
  if top + adjusted < 0.0 {
    adjusted = -top;
  }
  adjusted
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn continuation_markers() {
    assert_eq!(continuation("- item"), Some("- ".into()));
    assert_eq!(continuation("* item"), Some("* ".into()));
    assert_eq!(continuation("  - item"), Some("- ".into()));
    assert_eq!(continuation("- [x] done"), Some("- [ ] ".into()));
    assert_eq!(continuation("3. third"), Some("4. ".into()));
    assert_eq!(continuation("3) third"), Some("4) ".into()));
    assert_eq!(continuation("> quoted"), Some("> ".into()));
    assert_eq!(continuation("> > deep"), Some("> > ".into()));
    assert_eq!(continuation("plain"), None);
    assert_eq!(continuation("# heading"), None);
  }

  #[test]
  fn prefix_end_finds_content() {
    assert_eq!(prefix_end("- item"), 2);
    assert_eq!(prefix_end("  - [ ] x"), 8);
    assert_eq!(prefix_end("> q"), 2);
    assert_eq!(prefix_end("plain"), 0);
  }

  #[test]
  fn split_visual_rows() {
    // No wrapping: everything is row 0.
    assert_eq!(split_visual(&[], 0, 10), (0, 0));
    // One boundary at 10: [0..10) is row 0, [10..) is row 1.
    assert_eq!(split_visual(&[10], 2, 8), (0, 0));
    assert_eq!(split_visual(&[10], 2, 15), (0, 1));
    assert_eq!(split_visual(&[10], 12, 15), (1, 1));
    // Starts at the boundary → later row; ends at it → earlier row.
    assert_eq!(split_visual(&[10], 10, 15), (1, 1));
    assert_eq!(split_visual(&[10], 2, 10), (0, 0));
    // Degenerate empty range never inverts.
    assert_eq!(split_visual(&[10], 10, 10), (1, 1));
  }

  #[test]
  fn cover_spans_exactly() {
    let tokens = vec![(2..5, TokenKind::Keyword)];
    let s = cover(10, &tokens);
    let total: usize = s.iter().map(|(len, _)| len).sum();
    assert_eq!(total, 10);
    assert_eq!(s[1], (3, Some(TokenKind::Keyword)));
    assert_eq!(cover(4, &[]), vec![(4, None)]);
  }

  #[test]
  fn fence_language_mapping() {
    assert_eq!(fence_language(Some("rust")), Language::Rust);
    assert_eq!(fence_language(Some("rs")), Language::Rust);
    assert_eq!(fence_language(Some("json")), Language::Json);
    assert_eq!(fence_language(Some("python")), Language::None);
    assert_eq!(fence_language(None), Language::None);
  }

  #[test]
  fn scroll_adjust_reveals_target() {
    assert_eq!(scroll_adjust(-10.0, 100.0, 20.0, 40.0), -10.0);
    assert_eq!(scroll_adjust(-50.0, 100.0, 20.0, 40.0), -20.0);
    assert_eq!(scroll_adjust(0.0, 100.0, 150.0, 170.0), -70.0);
  }

  fn at(line: usize, col: usize) -> Pos {
    Pos::new(line, col)
  }

  #[test]
  fn line_selection_matches_editor_semantics() {
    assert_eq!(
      line_selection(at(1, 2), at(1, 5), 1, 8),
      Some((2, 5, false))
    );
    assert_eq!(line_selection(at(0, 3), at(2, 2), 1, 4), Some((0, 4, true)));
    assert_eq!(line_selection(at(0, 3), at(2, 2), 3, 4), None);
    assert_eq!(line_selection(at(0, 0), at(2, 1), 1, 0), Some((0, 0, true)));
  }
}