1pub mod parser;
2mod path_range;
3
4use base64::Engine as _;
5use futures::FutureExt as _;
6use gpui::HitboxBehavior;
7use language::LanguageName;
8use log::Level;
9pub use path_range::{LineCol, PathWithRange};
10use ui::Checkbox;
11
12use std::borrow::Cow;
13use std::iter;
14use std::mem;
15use std::ops::Range;
16use std::path::Path;
17use std::rc::Rc;
18use std::sync::Arc;
19use std::time::Duration;
20
21use collections::{HashMap, HashSet};
22use gpui::{
23 AnyElement, App, BorderStyle, Bounds, ClipboardItem, CursorStyle, DispatchPhase, Edges, Entity,
24 FocusHandle, Focusable, FontStyle, FontWeight, GlobalElementId, Hitbox, Hsla, Image,
25 ImageFormat, KeyContext, Length, MouseDownEvent, MouseEvent, MouseMoveEvent, MouseUpEvent,
26 Point, ScrollHandle, Stateful, StrikethroughStyle, StyleRefinement, StyledText, Task,
27 TextLayout, TextRun, TextStyle, TextStyleRefinement, actions, img, point, quad,
28};
29use language::{Language, LanguageRegistry, Rope};
30use parser::CodeBlockMetadata;
31use parser::{MarkdownEvent, MarkdownTag, MarkdownTagEnd, parse_links_only, parse_markdown};
32use pulldown_cmark::Alignment;
33use sum_tree::TreeMap;
34use theme::SyntaxTheme;
35use ui::{ScrollAxes, Scrollbars, Tooltip, WithScrollbar, prelude::*};
36use util::ResultExt;
37
38use crate::parser::CodeBlockKind;
39
40/// A callback function that can be used to customize the style of links based on the destination URL.
41/// If the callback returns `None`, the default link style will be used.
42type LinkStyleCallback = Rc<dyn Fn(&str, &App) -> Option<TextStyleRefinement>>;
43
44/// Defines custom style refinements for each heading level (H1-H6)
45#[derive(Clone, Default)]
46pub struct HeadingLevelStyles {
47 pub h1: Option<TextStyleRefinement>,
48 pub h2: Option<TextStyleRefinement>,
49 pub h3: Option<TextStyleRefinement>,
50 pub h4: Option<TextStyleRefinement>,
51 pub h5: Option<TextStyleRefinement>,
52 pub h6: Option<TextStyleRefinement>,
53}
54
55#[derive(Clone)]
56pub struct MarkdownStyle {
57 pub base_text_style: TextStyle,
58 pub container_style: StyleRefinement,
59 pub code_block: StyleRefinement,
60 pub code_block_overflow_x_scroll: bool,
61 pub inline_code: TextStyleRefinement,
62 pub block_quote: TextStyleRefinement,
63 pub link: TextStyleRefinement,
64 pub link_callback: Option<LinkStyleCallback>,
65 pub rule_color: Hsla,
66 pub block_quote_border_color: Hsla,
67 pub syntax: Arc<SyntaxTheme>,
68 pub selection_background_color: Hsla,
69 pub heading: StyleRefinement,
70 pub heading_level_styles: Option<HeadingLevelStyles>,
71 pub height_is_multiple_of_line_height: bool,
72 pub prevent_mouse_interaction: bool,
73 pub table_columns_min_size: bool,
74}
75
76impl Default for MarkdownStyle {
77 fn default() -> Self {
78 Self {
79 base_text_style: Default::default(),
80 container_style: Default::default(),
81 code_block: Default::default(),
82 code_block_overflow_x_scroll: false,
83 inline_code: Default::default(),
84 block_quote: Default::default(),
85 link: Default::default(),
86 link_callback: None,
87 rule_color: Default::default(),
88 block_quote_border_color: Default::default(),
89 syntax: Arc::new(SyntaxTheme::default()),
90 selection_background_color: Default::default(),
91 heading: Default::default(),
92 heading_level_styles: None,
93 height_is_multiple_of_line_height: false,
94 prevent_mouse_interaction: false,
95 table_columns_min_size: false,
96 }
97 }
98}
99
100pub struct Markdown {
101 source: SharedString,
102 selection: Selection,
103 pressed_link: Option<RenderedLink>,
104 autoscroll_request: Option<usize>,
105 parsed_markdown: ParsedMarkdown,
106 images_by_source_offset: HashMap<usize, Arc<Image>>,
107 should_reparse: bool,
108 pending_parse: Option<Task<()>>,
109 focus_handle: FocusHandle,
110 language_registry: Option<Arc<LanguageRegistry>>,
111 fallback_code_block_language: Option<LanguageName>,
112 options: Options,
113 copied_code_blocks: HashSet<ElementId>,
114 code_block_scroll_handles: HashMap<usize, ScrollHandle>,
115}
116
117struct Options {
118 parse_links_only: bool,
119}
120
121pub enum CodeBlockRenderer {
122 Default {
123 copy_button: bool,
124 copy_button_on_hover: bool,
125 border: bool,
126 },
127 Custom {
128 render: CodeBlockRenderFn,
129 /// A function that can modify the parent container after the code block
130 /// content has been appended as a child element.
131 transform: Option<CodeBlockTransformFn>,
132 },
133}
134
135pub type CodeBlockRenderFn = Arc<
136 dyn Fn(
137 &CodeBlockKind,
138 &ParsedMarkdown,
139 Range<usize>,
140 CodeBlockMetadata,
141 &mut Window,
142 &App,
143 ) -> Div,
144>;
145
146pub type CodeBlockTransformFn =
147 Arc<dyn Fn(AnyDiv, Range<usize>, CodeBlockMetadata, &mut Window, &App) -> AnyDiv>;
148
149actions!(
150 markdown,
151 [
152 /// Copies the selected text to the clipboard.
153 Copy,
154 /// Copies the selected text as markdown to the clipboard.
155 CopyAsMarkdown
156 ]
157);
158
159impl Markdown {
160 pub fn new(
161 source: SharedString,
162 language_registry: Option<Arc<LanguageRegistry>>,
163 fallback_code_block_language: Option<LanguageName>,
164 cx: &mut Context<Self>,
165 ) -> Self {
166 let focus_handle = cx.focus_handle();
167 let mut this = Self {
168 source,
169 selection: Selection::default(),
170 pressed_link: None,
171 autoscroll_request: None,
172 should_reparse: false,
173 images_by_source_offset: Default::default(),
174 parsed_markdown: ParsedMarkdown::default(),
175 pending_parse: None,
176 focus_handle,
177 language_registry,
178 fallback_code_block_language,
179 options: Options {
180 parse_links_only: false,
181 },
182 copied_code_blocks: HashSet::default(),
183 code_block_scroll_handles: HashMap::default(),
184 };
185 this.parse(cx);
186 this
187 }
188
189 pub fn new_text(source: SharedString, cx: &mut Context<Self>) -> Self {
190 let focus_handle = cx.focus_handle();
191 let mut this = Self {
192 source,
193 selection: Selection::default(),
194 pressed_link: None,
195 autoscroll_request: None,
196 should_reparse: false,
197 parsed_markdown: ParsedMarkdown::default(),
198 images_by_source_offset: Default::default(),
199 pending_parse: None,
200 focus_handle,
201 language_registry: None,
202 fallback_code_block_language: None,
203 options: Options {
204 parse_links_only: true,
205 },
206 copied_code_blocks: HashSet::default(),
207 code_block_scroll_handles: HashMap::default(),
208 };
209 this.parse(cx);
210 this
211 }
212
213 fn code_block_scroll_handle(&mut self, id: usize) -> ScrollHandle {
214 self.code_block_scroll_handles
215 .entry(id)
216 .or_insert_with(ScrollHandle::new)
217 .clone()
218 }
219
220 fn retain_code_block_scroll_handles(&mut self, ids: &HashSet<usize>) {
221 self.code_block_scroll_handles
222 .retain(|id, _| ids.contains(id));
223 }
224
225 fn clear_code_block_scroll_handles(&mut self) {
226 self.code_block_scroll_handles.clear();
227 }
228
229 pub fn is_parsing(&self) -> bool {
230 self.pending_parse.is_some()
231 }
232
233 pub fn source(&self) -> &str {
234 &self.source
235 }
236
237 pub fn append(&mut self, text: &str, cx: &mut Context<Self>) {
238 self.source = SharedString::new(self.source.to_string() + text);
239 self.parse(cx);
240 }
241
242 pub fn replace(&mut self, source: impl Into<SharedString>, cx: &mut Context<Self>) {
243 self.source = source.into();
244 self.parse(cx);
245 }
246
247 pub fn reset(&mut self, source: SharedString, cx: &mut Context<Self>) {
248 if source == self.source() {
249 return;
250 }
251 self.source = source;
252 self.selection = Selection::default();
253 self.autoscroll_request = None;
254 self.pending_parse = None;
255 self.should_reparse = false;
256 // Don't clear parsed_markdown here - keep existing content visible until new parse completes
257 self.parse(cx);
258 }
259
260 #[cfg(any(test, feature = "test-support"))]
261 pub fn parsed_markdown(&self) -> &ParsedMarkdown {
262 &self.parsed_markdown
263 }
264
265 pub fn escape(s: &str) -> Cow<'_, str> {
266 // Valid to use bytes since multi-byte UTF-8 doesn't use ASCII chars.
267 let count = s
268 .bytes()
269 .filter(|c| *c == b'\n' || c.is_ascii_punctuation())
270 .count();
271 if count > 0 {
272 let mut output = String::with_capacity(s.len() + count);
273 let mut is_newline = false;
274 for c in s.chars() {
275 if is_newline && c == ' ' {
276 continue;
277 }
278 is_newline = c == '\n';
279 if c == '\n' {
280 output.push('\n')
281 } else if c.is_ascii_punctuation() {
282 output.push('\\')
283 }
284 output.push(c)
285 }
286 output.into()
287 } else {
288 s.into()
289 }
290 }
291
292 fn copy(&self, text: &RenderedText, _: &mut Window, cx: &mut Context<Self>) {
293 if self.selection.end <= self.selection.start {
294 return;
295 }
296 let text = text.text_for_range(self.selection.start..self.selection.end);
297 cx.write_to_clipboard(ClipboardItem::new_string(text));
298 }
299
300 fn copy_as_markdown(&self, _: &mut Window, cx: &mut Context<Self>) {
301 if self.selection.end <= self.selection.start {
302 return;
303 }
304 let text = self.source[self.selection.start..self.selection.end].to_string();
305 cx.write_to_clipboard(ClipboardItem::new_string(text));
306 }
307
308 fn parse(&mut self, cx: &mut Context<Self>) {
309 if self.source.is_empty() {
310 return;
311 }
312
313 if self.pending_parse.is_some() {
314 self.should_reparse = true;
315 return;
316 }
317 self.should_reparse = false;
318 self.pending_parse = Some(self.start_background_parse(cx));
319 }
320
321 fn start_background_parse(&self, cx: &Context<Self>) -> Task<()> {
322 let source = self.source.clone();
323 let should_parse_links_only = self.options.parse_links_only;
324 let language_registry = self.language_registry.clone();
325 let fallback = self.fallback_code_block_language.clone();
326
327 let parsed = cx.background_spawn(async move {
328 if should_parse_links_only {
329 return (
330 ParsedMarkdown {
331 events: Arc::from(parse_links_only(source.as_ref())),
332 source,
333 languages_by_name: TreeMap::default(),
334 languages_by_path: TreeMap::default(),
335 },
336 Default::default(),
337 );
338 }
339
340 let (events, language_names, paths) = parse_markdown(&source);
341 let mut images_by_source_offset = HashMap::default();
342 let mut languages_by_name = TreeMap::default();
343 let mut languages_by_path = TreeMap::default();
344 if let Some(registry) = language_registry.as_ref() {
345 for name in language_names {
346 let language = if !name.is_empty() {
347 registry.language_for_name_or_extension(&name).left_future()
348 } else if let Some(fallback) = &fallback {
349 registry.language_for_name(fallback.as_ref()).right_future()
350 } else {
351 continue;
352 };
353 if let Ok(language) = language.await {
354 languages_by_name.insert(name, language);
355 }
356 }
357
358 for path in paths {
359 if let Ok(language) = registry
360 .load_language_for_file_path(Path::new(path.as_ref()))
361 .await
362 {
363 languages_by_path.insert(path, language);
364 }
365 }
366 }
367
368 for (range, event) in &events {
369 if let MarkdownEvent::Start(MarkdownTag::Image { dest_url, .. }) = event
370 && let Some(data_url) = dest_url.strip_prefix("data:")
371 {
372 let Some((mime_info, data)) = data_url.split_once(',') else {
373 continue;
374 };
375 let Some((mime_type, encoding)) = mime_info.split_once(';') else {
376 continue;
377 };
378 let Some(format) = ImageFormat::from_mime_type(mime_type) else {
379 continue;
380 };
381 let is_base64 = encoding == "base64";
382 if is_base64
383 && let Some(bytes) = base64::prelude::BASE64_STANDARD
384 .decode(data)
385 .log_with_level(Level::Debug)
386 {
387 let image = Arc::new(Image::from_bytes(format, bytes));
388 images_by_source_offset.insert(range.start, image);
389 }
390 }
391 }
392
393 (
394 ParsedMarkdown {
395 source,
396 events: Arc::from(events),
397 languages_by_name,
398 languages_by_path,
399 },
400 images_by_source_offset,
401 )
402 });
403
404 cx.spawn(async move |this, cx| {
405 let (parsed, images_by_source_offset) = parsed.await;
406
407 this.update(cx, |this, cx| {
408 this.parsed_markdown = parsed;
409 this.images_by_source_offset = images_by_source_offset;
410 this.pending_parse.take();
411 if this.should_reparse {
412 this.parse(cx);
413 }
414 cx.refresh_windows();
415 })
416 .ok();
417 })
418 }
419}
420
421impl Focusable for Markdown {
422 fn focus_handle(&self, _cx: &App) -> FocusHandle {
423 self.focus_handle.clone()
424 }
425}
426
427#[derive(Debug, Default, Clone)]
428enum SelectMode {
429 #[default]
430 Character,
431 Word(Range<usize>),
432 Line(Range<usize>),
433 All,
434}
435
436#[derive(Clone, Default)]
437struct Selection {
438 start: usize,
439 end: usize,
440 reversed: bool,
441 pending: bool,
442 mode: SelectMode,
443}
444
445impl Selection {
446 fn set_head(&mut self, head: usize, rendered_text: &RenderedText) {
447 match &self.mode {
448 SelectMode::Character => {
449 if head < self.tail() {
450 if !self.reversed {
451 self.end = self.start;
452 self.reversed = true;
453 }
454 self.start = head;
455 } else {
456 if self.reversed {
457 self.start = self.end;
458 self.reversed = false;
459 }
460 self.end = head;
461 }
462 }
463 SelectMode::Word(original_range) | SelectMode::Line(original_range) => {
464 let head_range = if matches!(self.mode, SelectMode::Word(_)) {
465 rendered_text.surrounding_word_range(head)
466 } else {
467 rendered_text.surrounding_line_range(head)
468 };
469
470 if head < original_range.start {
471 self.start = head_range.start;
472 self.end = original_range.end;
473 self.reversed = true;
474 } else if head >= original_range.end {
475 self.start = original_range.start;
476 self.end = head_range.end;
477 self.reversed = false;
478 } else {
479 self.start = original_range.start;
480 self.end = original_range.end;
481 self.reversed = false;
482 }
483 }
484 SelectMode::All => {
485 self.start = 0;
486 self.end = rendered_text
487 .lines
488 .last()
489 .map(|line| line.source_end)
490 .unwrap_or(0);
491 self.reversed = false;
492 }
493 }
494 }
495
496 fn tail(&self) -> usize {
497 if self.reversed { self.end } else { self.start }
498 }
499}
500
501#[derive(Debug, Clone, Default)]
502pub struct ParsedMarkdown {
503 pub source: SharedString,
504 pub events: Arc<[(Range<usize>, MarkdownEvent)]>,
505 pub languages_by_name: TreeMap<SharedString, Arc<Language>>,
506 pub languages_by_path: TreeMap<Arc<str>, Arc<Language>>,
507}
508
509impl ParsedMarkdown {
510 pub fn source(&self) -> &SharedString {
511 &self.source
512 }
513
514 pub fn events(&self) -> &Arc<[(Range<usize>, MarkdownEvent)]> {
515 &self.events
516 }
517}
518
519pub struct MarkdownElement {
520 markdown: Entity<Markdown>,
521 style: MarkdownStyle,
522 code_block_renderer: CodeBlockRenderer,
523 on_url_click: Option<Box<dyn Fn(SharedString, &mut Window, &mut App)>>,
524}
525
526impl MarkdownElement {
527 pub fn new(markdown: Entity<Markdown>, style: MarkdownStyle) -> Self {
528 Self {
529 markdown,
530 style,
531 code_block_renderer: CodeBlockRenderer::Default {
532 copy_button: true,
533 copy_button_on_hover: false,
534 border: false,
535 },
536 on_url_click: None,
537 }
538 }
539
540 #[cfg(any(test, feature = "test-support"))]
541 pub fn rendered_text(
542 markdown: Entity<Markdown>,
543 cx: &mut gpui::VisualTestContext,
544 style: impl FnOnce(&Window, &App) -> MarkdownStyle,
545 ) -> String {
546 use gpui::size;
547
548 let (text, _) = cx.draw(
549 Default::default(),
550 size(px(600.0), px(600.0)),
551 |window, cx| Self::new(markdown, style(window, cx)),
552 );
553 text.text
554 .lines
555 .iter()
556 .map(|line| line.layout.wrapped_text())
557 .collect::<Vec<_>>()
558 .join("\n")
559 }
560
561 pub fn code_block_renderer(mut self, variant: CodeBlockRenderer) -> Self {
562 self.code_block_renderer = variant;
563 self
564 }
565
566 pub fn on_url_click(
567 mut self,
568 handler: impl Fn(SharedString, &mut Window, &mut App) + 'static,
569 ) -> Self {
570 self.on_url_click = Some(Box::new(handler));
571 self
572 }
573
574 fn paint_selection(
575 &self,
576 bounds: Bounds<Pixels>,
577 rendered_text: &RenderedText,
578 window: &mut Window,
579 cx: &mut App,
580 ) {
581 let selection = self.markdown.read(cx).selection.clone();
582 let selection_start = rendered_text.position_for_source_index(selection.start);
583 let selection_end = rendered_text.position_for_source_index(selection.end);
584 if let Some(((start_position, start_line_height), (end_position, end_line_height))) =
585 selection_start.zip(selection_end)
586 {
587 if start_position.y == end_position.y {
588 window.paint_quad(quad(
589 Bounds::from_corners(
590 start_position,
591 point(end_position.x, end_position.y + end_line_height),
592 ),
593 Pixels::ZERO,
594 self.style.selection_background_color,
595 Edges::default(),
596 Hsla::transparent_black(),
597 BorderStyle::default(),
598 ));
599 } else {
600 window.paint_quad(quad(
601 Bounds::from_corners(
602 start_position,
603 point(bounds.right(), start_position.y + start_line_height),
604 ),
605 Pixels::ZERO,
606 self.style.selection_background_color,
607 Edges::default(),
608 Hsla::transparent_black(),
609 BorderStyle::default(),
610 ));
611
612 if end_position.y > start_position.y + start_line_height {
613 window.paint_quad(quad(
614 Bounds::from_corners(
615 point(bounds.left(), start_position.y + start_line_height),
616 point(bounds.right(), end_position.y),
617 ),
618 Pixels::ZERO,
619 self.style.selection_background_color,
620 Edges::default(),
621 Hsla::transparent_black(),
622 BorderStyle::default(),
623 ));
624 }
625
626 window.paint_quad(quad(
627 Bounds::from_corners(
628 point(bounds.left(), end_position.y),
629 point(end_position.x, end_position.y + end_line_height),
630 ),
631 Pixels::ZERO,
632 self.style.selection_background_color,
633 Edges::default(),
634 Hsla::transparent_black(),
635 BorderStyle::default(),
636 ));
637 }
638 }
639 }
640
641 fn paint_mouse_listeners(
642 &mut self,
643 hitbox: &Hitbox,
644 rendered_text: &RenderedText,
645 window: &mut Window,
646 cx: &mut App,
647 ) {
648 if self.style.prevent_mouse_interaction {
649 return;
650 }
651
652 let is_hovering_link = hitbox.is_hovered(window)
653 && !self.markdown.read(cx).selection.pending
654 && rendered_text
655 .link_for_position(window.mouse_position())
656 .is_some();
657
658 if !self.style.prevent_mouse_interaction {
659 if is_hovering_link {
660 window.set_cursor_style(CursorStyle::PointingHand, hitbox);
661 } else {
662 window.set_cursor_style(CursorStyle::IBeam, hitbox);
663 }
664 }
665
666 let on_open_url = self.on_url_click.take();
667
668 self.on_mouse_event(window, cx, {
669 let rendered_text = rendered_text.clone();
670 let hitbox = hitbox.clone();
671 move |markdown, event: &MouseDownEvent, phase, window, cx| {
672 if hitbox.is_hovered(window) {
673 if phase.bubble() {
674 if let Some(link) = rendered_text.link_for_position(event.position) {
675 markdown.pressed_link = Some(link.clone());
676 } else {
677 let source_index =
678 match rendered_text.source_index_for_position(event.position) {
679 Ok(ix) | Err(ix) => ix,
680 };
681 let (range, mode) = match event.click_count {
682 1 => {
683 let range = source_index..source_index;
684 (range, SelectMode::Character)
685 }
686 2 => {
687 let range = rendered_text.surrounding_word_range(source_index);
688 (range.clone(), SelectMode::Word(range))
689 }
690 3 => {
691 let range = rendered_text.surrounding_line_range(source_index);
692 (range.clone(), SelectMode::Line(range))
693 }
694 _ => {
695 let range = 0..rendered_text
696 .lines
697 .last()
698 .map(|line| line.source_end)
699 .unwrap_or(0);
700 (range, SelectMode::All)
701 }
702 };
703 markdown.selection = Selection {
704 start: range.start,
705 end: range.end,
706 reversed: false,
707 pending: true,
708 mode,
709 };
710 window.focus(&markdown.focus_handle, cx);
711 }
712
713 window.prevent_default();
714 cx.notify();
715 }
716 } else if phase.capture() {
717 markdown.selection = Selection::default();
718 markdown.pressed_link = None;
719 cx.notify();
720 }
721 }
722 });
723 self.on_mouse_event(window, cx, {
724 let rendered_text = rendered_text.clone();
725 let hitbox = hitbox.clone();
726 let was_hovering_link = is_hovering_link;
727 move |markdown, event: &MouseMoveEvent, phase, window, cx| {
728 if phase.capture() {
729 return;
730 }
731
732 if markdown.selection.pending {
733 let source_index = match rendered_text.source_index_for_position(event.position)
734 {
735 Ok(ix) | Err(ix) => ix,
736 };
737 markdown.selection.set_head(source_index, &rendered_text);
738 markdown.autoscroll_request = Some(source_index);
739 cx.notify();
740 } else {
741 let is_hovering_link = hitbox.is_hovered(window)
742 && rendered_text.link_for_position(event.position).is_some();
743 if is_hovering_link != was_hovering_link {
744 cx.notify();
745 }
746 }
747 }
748 });
749 self.on_mouse_event(window, cx, {
750 let rendered_text = rendered_text.clone();
751 move |markdown, event: &MouseUpEvent, phase, window, cx| {
752 if phase.bubble() {
753 if let Some(pressed_link) = markdown.pressed_link.take()
754 && Some(&pressed_link) == rendered_text.link_for_position(event.position)
755 {
756 if let Some(open_url) = on_open_url.as_ref() {
757 open_url(pressed_link.destination_url, window, cx);
758 } else {
759 cx.open_url(&pressed_link.destination_url);
760 }
761 }
762 } else if markdown.selection.pending {
763 markdown.selection.pending = false;
764 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
765 {
766 let text = rendered_text
767 .text_for_range(markdown.selection.start..markdown.selection.end);
768 cx.write_to_primary(ClipboardItem::new_string(text))
769 }
770 cx.notify();
771 }
772 }
773 });
774 }
775
776 fn autoscroll(
777 &self,
778 rendered_text: &RenderedText,
779 window: &mut Window,
780 cx: &mut App,
781 ) -> Option<()> {
782 let autoscroll_index = self
783 .markdown
784 .update(cx, |markdown, _| markdown.autoscroll_request.take())?;
785 let (position, line_height) = rendered_text.position_for_source_index(autoscroll_index)?;
786
787 let text_style = self.style.base_text_style.clone();
788 let font_id = window.text_system().resolve_font(&text_style.font());
789 let font_size = text_style.font_size.to_pixels(window.rem_size());
790 let em_width = window.text_system().em_width(font_id, font_size).unwrap();
791 window.request_autoscroll(Bounds::from_corners(
792 point(position.x - 3. * em_width, position.y - 3. * line_height),
793 point(position.x + 3. * em_width, position.y + 3. * line_height),
794 ));
795 Some(())
796 }
797
798 fn on_mouse_event<T: MouseEvent>(
799 &self,
800 window: &mut Window,
801 _cx: &mut App,
802 mut f: impl 'static
803 + FnMut(&mut Markdown, &T, DispatchPhase, &mut Window, &mut Context<Markdown>),
804 ) {
805 window.on_mouse_event({
806 let markdown = self.markdown.downgrade();
807 move |event, phase, window, cx| {
808 markdown
809 .update(cx, |markdown, cx| f(markdown, event, phase, window, cx))
810 .log_err();
811 }
812 });
813 }
814}
815
816impl Styled for MarkdownElement {
817 fn style(&mut self) -> &mut StyleRefinement {
818 &mut self.style.container_style
819 }
820}
821
822impl Element for MarkdownElement {
823 type RequestLayoutState = RenderedMarkdown;
824 type PrepaintState = Hitbox;
825
826 fn id(&self) -> Option<ElementId> {
827 None
828 }
829
830 fn source_location(&self) -> Option<&'static core::panic::Location<'static>> {
831 None
832 }
833
834 #[ztracing::instrument(skip_all)]
835 fn request_layout(
836 &mut self,
837 _id: Option<&GlobalElementId>,
838 _inspector_id: Option<&gpui::InspectorElementId>,
839 window: &mut Window,
840 cx: &mut App,
841 ) -> (gpui::LayoutId, Self::RequestLayoutState) {
842 let mut builder = MarkdownElementBuilder::new(
843 &self.style.container_style,
844 self.style.base_text_style.clone(),
845 self.style.syntax.clone(),
846 );
847 let (parsed_markdown, images) = {
848 let markdown = self.markdown.read(cx);
849 (
850 markdown.parsed_markdown.clone(),
851 markdown.images_by_source_offset.clone(),
852 )
853 };
854 let markdown_end = if let Some(last) = parsed_markdown.events.last() {
855 last.0.end
856 } else {
857 0
858 };
859 let mut code_block_ids = HashSet::default();
860
861 let mut current_img_block_range: Option<Range<usize>> = None;
862 for (index, (range, event)) in parsed_markdown.events.iter().enumerate() {
863 // Skip alt text for images that rendered
864 if let Some(current_img_block_range) = ¤t_img_block_range
865 && current_img_block_range.end > range.end
866 {
867 continue;
868 }
869
870 match event {
871 MarkdownEvent::Start(tag) => {
872 match tag {
873 MarkdownTag::Image { .. } => {
874 if let Some(image) = images.get(&range.start) {
875 current_img_block_range = Some(range.clone());
876 builder.modify_current_div(|el| {
877 el.items_center()
878 .flex()
879 .flex_row()
880 .child(img(image.clone()))
881 });
882 }
883 }
884 MarkdownTag::Paragraph => {
885 builder.push_div(
886 div().when(!self.style.height_is_multiple_of_line_height, |el| {
887 el.mb_2().line_height(rems(1.3))
888 }),
889 range,
890 markdown_end,
891 );
892 }
893 MarkdownTag::Heading { level, .. } => {
894 let mut heading = div().mb_2();
895
896 heading = apply_heading_style(
897 heading,
898 *level,
899 self.style.heading_level_styles.as_ref(),
900 );
901
902 heading.style().refine(&self.style.heading);
903
904 let text_style = self.style.heading.text_style().clone();
905
906 builder.push_text_style(text_style);
907 builder.push_div(heading, range, markdown_end);
908 }
909 MarkdownTag::BlockQuote => {
910 builder.push_text_style(self.style.block_quote.clone());
911 builder.push_div(
912 div()
913 .pl_4()
914 .mb_2()
915 .border_l_4()
916 .border_color(self.style.block_quote_border_color),
917 range,
918 markdown_end,
919 );
920 }
921 MarkdownTag::CodeBlock { kind, .. } => {
922 let language = match kind {
923 CodeBlockKind::Fenced => None,
924 CodeBlockKind::FencedLang(language) => {
925 parsed_markdown.languages_by_name.get(language).cloned()
926 }
927 CodeBlockKind::FencedSrc(path_range) => parsed_markdown
928 .languages_by_path
929 .get(&path_range.path)
930 .cloned(),
931 _ => None,
932 };
933
934 let is_indented = matches!(kind, CodeBlockKind::Indented);
935 let scroll_handle = if self.style.code_block_overflow_x_scroll {
936 code_block_ids.insert(range.start);
937 Some(self.markdown.update(cx, |markdown, _| {
938 markdown.code_block_scroll_handle(range.start)
939 }))
940 } else {
941 None
942 };
943
944 match (&self.code_block_renderer, is_indented) {
945 (CodeBlockRenderer::Default { .. }, _) | (_, true) => {
946 // This is a parent container that we can position the copy button inside.
947 let parent_container =
948 div().group("code_block").relative().w_full();
949
950 let mut parent_container: AnyDiv = if let Some(scroll_handle) =
951 scroll_handle.as_ref()
952 {
953 let scrollbars = Scrollbars::new(ScrollAxes::Horizontal)
954 .id(("markdown-code-block-scrollbar", range.start))
955 .tracked_scroll_handle(scroll_handle)
956 .with_track_along(
957 ScrollAxes::Horizontal,
958 cx.theme().colors().editor_background,
959 )
960 .notify_content();
961
962 parent_container
963 .rounded_lg()
964 .custom_scrollbars(scrollbars, window, cx)
965 .into()
966 } else {
967 parent_container.into()
968 };
969
970 if let CodeBlockRenderer::Default { border: true, .. } =
971 &self.code_block_renderer
972 {
973 parent_container = parent_container
974 .rounded_md()
975 .border_1()
976 .border_color(cx.theme().colors().border_variant);
977 }
978
979 parent_container.style().refine(&self.style.code_block);
980 builder.push_div(parent_container, range, markdown_end);
981
982 let code_block = div()
983 .id(("code-block", range.start))
984 .rounded_lg()
985 .map(|mut code_block| {
986 if let Some(scroll_handle) = scroll_handle.as_ref() {
987 code_block.style().restrict_scroll_to_axis =
988 Some(true);
989 code_block
990 .flex()
991 .overflow_x_scroll()
992 .track_scroll(scroll_handle)
993 } else {
994 code_block.w_full()
995 }
996 });
997
998 builder.push_text_style(self.style.code_block.text.to_owned());
999 builder.push_code_block(language);
1000 builder.push_div(code_block, range, markdown_end);
1001 }
1002 (CodeBlockRenderer::Custom { .. }, _) => {}
1003 }
1004 }
1005 MarkdownTag::HtmlBlock => builder.push_div(div(), range, markdown_end),
1006 MarkdownTag::List(bullet_index) => {
1007 builder.push_list(*bullet_index);
1008 builder.push_div(div().pl_2p5(), range, markdown_end);
1009 }
1010 MarkdownTag::Item => {
1011 let bullet = if let Some((_, MarkdownEvent::TaskListMarker(checked))) =
1012 parsed_markdown.events.get(index.saturating_add(1))
1013 {
1014 let source = &parsed_markdown.source()[range.clone()];
1015
1016 Checkbox::new(
1017 ElementId::Name(source.to_string().into()),
1018 if *checked {
1019 ToggleState::Selected
1020 } else {
1021 ToggleState::Unselected
1022 },
1023 )
1024 .fill()
1025 .visualization_only(true)
1026 .into_any_element()
1027 } else if let Some(bullet_index) = builder.next_bullet_index() {
1028 div().child(format!("{}.", bullet_index)).into_any_element()
1029 } else {
1030 div().child("•").into_any_element()
1031 };
1032 builder.push_div(
1033 div()
1034 .when(!self.style.height_is_multiple_of_line_height, |el| {
1035 el.mb_1().gap_1().line_height(rems(1.3))
1036 })
1037 .h_flex()
1038 .items_start()
1039 .child(bullet),
1040 range,
1041 markdown_end,
1042 );
1043 // Without `w_0`, text doesn't wrap to the width of the container.
1044 builder.push_div(div().flex_1().w_0(), range, markdown_end);
1045 }
1046 MarkdownTag::Emphasis => builder.push_text_style(TextStyleRefinement {
1047 font_style: Some(FontStyle::Italic),
1048 ..Default::default()
1049 }),
1050 MarkdownTag::Strong => builder.push_text_style(TextStyleRefinement {
1051 font_weight: Some(FontWeight::BOLD),
1052 ..Default::default()
1053 }),
1054 MarkdownTag::Strikethrough => {
1055 builder.push_text_style(TextStyleRefinement {
1056 strikethrough: Some(StrikethroughStyle {
1057 thickness: px(1.),
1058 color: None,
1059 }),
1060 ..Default::default()
1061 })
1062 }
1063 MarkdownTag::Link { dest_url, .. } => {
1064 if builder.code_block_stack.is_empty() {
1065 builder.push_link(dest_url.clone(), range.clone());
1066 let style = self
1067 .style
1068 .link_callback
1069 .as_ref()
1070 .and_then(|callback| callback(dest_url, cx))
1071 .unwrap_or_else(|| self.style.link.clone());
1072 builder.push_text_style(style)
1073 }
1074 }
1075 MarkdownTag::MetadataBlock(_) => {}
1076 MarkdownTag::Table(alignments) => {
1077 builder.table.start(alignments.clone());
1078
1079 let column_count = alignments.len();
1080 builder.push_div(
1081 div()
1082 .id(("table", range.start))
1083 .grid()
1084 .grid_cols(column_count as u16)
1085 .when(self.style.table_columns_min_size, |this| {
1086 this.grid_cols_min_content(column_count as u16)
1087 })
1088 .when(!self.style.table_columns_min_size, |this| {
1089 this.grid_cols(column_count as u16)
1090 })
1091 .size_full()
1092 .mb_2()
1093 .border(px(1.5))
1094 .border_color(cx.theme().colors().border)
1095 .rounded_sm()
1096 .overflow_hidden(),
1097 range,
1098 markdown_end,
1099 );
1100 }
1101 MarkdownTag::TableHead => {
1102 builder.table.start_head();
1103 builder.push_text_style(TextStyleRefinement {
1104 font_weight: Some(FontWeight::SEMIBOLD),
1105 ..Default::default()
1106 });
1107 }
1108 MarkdownTag::TableRow => {
1109 builder.table.start_row();
1110 }
1111 MarkdownTag::TableCell => {
1112 let is_header = builder.table.in_head;
1113 let row_index = builder.table.row_index;
1114 let col_index = builder.table.col_index;
1115
1116 builder.push_div(
1117 div()
1118 .when(col_index > 0, |this| this.border_l_1())
1119 .when(row_index > 0, |this| this.border_t_1())
1120 .border_color(cx.theme().colors().border)
1121 .px_1()
1122 .py_0p5()
1123 .when(is_header, |this| {
1124 this.bg(cx.theme().colors().title_bar_background)
1125 })
1126 .when(!is_header && row_index % 2 == 1, |this| {
1127 this.bg(cx.theme().colors().panel_background)
1128 }),
1129 range,
1130 markdown_end,
1131 );
1132 }
1133 _ => log::debug!("unsupported markdown tag {:?}", tag),
1134 }
1135 }
1136 MarkdownEvent::End(tag) => match tag {
1137 MarkdownTagEnd::Image => {
1138 current_img_block_range.take();
1139 }
1140 MarkdownTagEnd::Paragraph => {
1141 builder.pop_div();
1142 }
1143 MarkdownTagEnd::Heading(_) => {
1144 builder.pop_div();
1145 builder.pop_text_style()
1146 }
1147 MarkdownTagEnd::BlockQuote(_kind) => {
1148 builder.pop_text_style();
1149 builder.pop_div()
1150 }
1151 MarkdownTagEnd::CodeBlock => {
1152 builder.trim_trailing_newline();
1153
1154 builder.pop_div();
1155 builder.pop_code_block();
1156 builder.pop_text_style();
1157
1158 if let CodeBlockRenderer::Default {
1159 copy_button: true, ..
1160 } = &self.code_block_renderer
1161 {
1162 builder.modify_current_div(|el| {
1163 let content_range = parser::extract_code_block_content_range(
1164 &parsed_markdown.source()[range.clone()],
1165 );
1166 let content_range = content_range.start + range.start
1167 ..content_range.end + range.start;
1168
1169 let code = parsed_markdown.source()[content_range].to_string();
1170 let codeblock = render_copy_code_block_button(
1171 range.end,
1172 code,
1173 self.markdown.clone(),
1174 cx,
1175 );
1176 el.child(
1177 h_flex()
1178 .w_4()
1179 .absolute()
1180 .top_1p5()
1181 .right_1p5()
1182 .justify_end()
1183 .child(codeblock),
1184 )
1185 });
1186 }
1187
1188 if let CodeBlockRenderer::Default {
1189 copy_button_on_hover: true,
1190 ..
1191 } = &self.code_block_renderer
1192 {
1193 builder.modify_current_div(|el| {
1194 let content_range = parser::extract_code_block_content_range(
1195 &parsed_markdown.source()[range.clone()],
1196 );
1197 let content_range = content_range.start + range.start
1198 ..content_range.end + range.start;
1199
1200 let code = parsed_markdown.source()[content_range].to_string();
1201 let codeblock = render_copy_code_block_button(
1202 range.end,
1203 code,
1204 self.markdown.clone(),
1205 cx,
1206 );
1207 el.child(
1208 h_flex()
1209 .w_4()
1210 .absolute()
1211 .top_0()
1212 .right_0()
1213 .justify_end()
1214 .visible_on_hover("code_block")
1215 .child(codeblock),
1216 )
1217 });
1218 }
1219
1220 // Pop the parent container.
1221 builder.pop_div();
1222 }
1223 MarkdownTagEnd::HtmlBlock => builder.pop_div(),
1224 MarkdownTagEnd::List(_) => {
1225 builder.pop_list();
1226 builder.pop_div();
1227 }
1228 MarkdownTagEnd::Item => {
1229 builder.pop_div();
1230 builder.pop_div();
1231 }
1232 MarkdownTagEnd::Emphasis => builder.pop_text_style(),
1233 MarkdownTagEnd::Strong => builder.pop_text_style(),
1234 MarkdownTagEnd::Strikethrough => builder.pop_text_style(),
1235 MarkdownTagEnd::Link => {
1236 if builder.code_block_stack.is_empty() {
1237 builder.pop_text_style()
1238 }
1239 }
1240 MarkdownTagEnd::Table => {
1241 builder.pop_div();
1242 builder.table.end();
1243 }
1244 MarkdownTagEnd::TableHead => {
1245 builder.pop_text_style();
1246 builder.table.end_head();
1247 }
1248 MarkdownTagEnd::TableRow => {
1249 builder.table.end_row();
1250 }
1251 MarkdownTagEnd::TableCell => {
1252 builder.pop_div();
1253 builder.table.end_cell();
1254 }
1255 _ => log::debug!("unsupported markdown tag end: {:?}", tag),
1256 },
1257 MarkdownEvent::Text => {
1258 builder.push_text(&parsed_markdown.source[range.clone()], range.clone());
1259 }
1260 MarkdownEvent::SubstitutedText(text) => {
1261 builder.push_text(text, range.clone());
1262 }
1263 MarkdownEvent::Code => {
1264 builder.push_text_style(self.style.inline_code.clone());
1265 builder.push_text(&parsed_markdown.source[range.clone()], range.clone());
1266 builder.pop_text_style();
1267 }
1268 MarkdownEvent::Html => {
1269 let html = &parsed_markdown.source[range.clone()];
1270 if html.starts_with("<!--") {
1271 builder.html_comment = true;
1272 }
1273 if html.trim_end().ends_with("-->") {
1274 builder.html_comment = false;
1275 continue;
1276 }
1277 if builder.html_comment {
1278 continue;
1279 }
1280 builder.push_text(html, range.clone());
1281 }
1282 MarkdownEvent::InlineHtml => {
1283 let html = &parsed_markdown.source[range.clone()];
1284 if html.starts_with("<code>") {
1285 builder.push_text_style(self.style.inline_code.clone());
1286 continue;
1287 }
1288 if html.trim_end().starts_with("</code>") {
1289 builder.pop_text_style();
1290 continue;
1291 }
1292 builder.push_text(&parsed_markdown.source[range.clone()], range.clone());
1293 }
1294 MarkdownEvent::Rule => {
1295 builder.push_div(
1296 div()
1297 .border_b_1()
1298 .my_2()
1299 .border_color(self.style.rule_color),
1300 range,
1301 markdown_end,
1302 );
1303 builder.pop_div()
1304 }
1305 MarkdownEvent::SoftBreak => builder.push_text(" ", range.clone()),
1306 MarkdownEvent::HardBreak => builder.push_text("\n", range.clone()),
1307 MarkdownEvent::TaskListMarker(_) => {
1308 // handled inside the `MarkdownTag::Item` case
1309 }
1310 _ => log::debug!("unsupported markdown event {:?}", event),
1311 }
1312 }
1313 if self.style.code_block_overflow_x_scroll {
1314 let code_block_ids = code_block_ids;
1315 self.markdown.update(cx, move |markdown, _| {
1316 markdown.retain_code_block_scroll_handles(&code_block_ids);
1317 });
1318 } else {
1319 self.markdown
1320 .update(cx, |markdown, _| markdown.clear_code_block_scroll_handles());
1321 }
1322 let mut rendered_markdown = builder.build();
1323 let child_layout_id = rendered_markdown.element.request_layout(window, cx);
1324 let layout_id = window.request_layout(gpui::Style::default(), [child_layout_id], cx);
1325 (layout_id, rendered_markdown)
1326 }
1327
1328 #[ztracing::instrument(skip_all)]
1329 fn prepaint(
1330 &mut self,
1331 _id: Option<&GlobalElementId>,
1332 _inspector_id: Option<&gpui::InspectorElementId>,
1333 bounds: Bounds<Pixels>,
1334 rendered_markdown: &mut Self::RequestLayoutState,
1335 window: &mut Window,
1336 cx: &mut App,
1337 ) -> Self::PrepaintState {
1338 let focus_handle = self.markdown.read(cx).focus_handle.clone();
1339 window.set_focus_handle(&focus_handle, cx);
1340 window.set_view_id(self.markdown.entity_id());
1341
1342 let hitbox = window.insert_hitbox(bounds, HitboxBehavior::Normal);
1343 rendered_markdown.element.prepaint(window, cx);
1344 self.autoscroll(&rendered_markdown.text, window, cx);
1345 hitbox
1346 }
1347
1348 #[ztracing::instrument(skip_all)]
1349 fn paint(
1350 &mut self,
1351 _id: Option<&GlobalElementId>,
1352 _inspector_id: Option<&gpui::InspectorElementId>,
1353 bounds: Bounds<Pixels>,
1354 rendered_markdown: &mut Self::RequestLayoutState,
1355 hitbox: &mut Self::PrepaintState,
1356 window: &mut Window,
1357 cx: &mut App,
1358 ) {
1359 let mut context = KeyContext::default();
1360 context.add("Markdown");
1361 window.set_key_context(context);
1362 window.on_action(std::any::TypeId::of::<crate::Copy>(), {
1363 let entity = self.markdown.clone();
1364 let text = rendered_markdown.text.clone();
1365 move |_, phase, window, cx| {
1366 let text = text.clone();
1367 if phase == DispatchPhase::Bubble {
1368 entity.update(cx, move |this, cx| this.copy(&text, window, cx))
1369 }
1370 }
1371 });
1372 window.on_action(std::any::TypeId::of::<crate::CopyAsMarkdown>(), {
1373 let entity = self.markdown.clone();
1374 move |_, phase, window, cx| {
1375 if phase == DispatchPhase::Bubble {
1376 entity.update(cx, move |this, cx| this.copy_as_markdown(window, cx))
1377 }
1378 }
1379 });
1380
1381 self.paint_mouse_listeners(hitbox, &rendered_markdown.text, window, cx);
1382 rendered_markdown.element.paint(window, cx);
1383 self.paint_selection(bounds, &rendered_markdown.text, window, cx);
1384 }
1385}
1386
1387fn apply_heading_style(
1388 mut heading: Div,
1389 level: pulldown_cmark::HeadingLevel,
1390 custom_styles: Option<&HeadingLevelStyles>,
1391) -> Div {
1392 heading = match level {
1393 pulldown_cmark::HeadingLevel::H1 => heading.text_3xl(),
1394 pulldown_cmark::HeadingLevel::H2 => heading.text_2xl(),
1395 pulldown_cmark::HeadingLevel::H3 => heading.text_xl(),
1396 pulldown_cmark::HeadingLevel::H4 => heading.text_lg(),
1397 pulldown_cmark::HeadingLevel::H5 => heading.text_base(),
1398 pulldown_cmark::HeadingLevel::H6 => heading.text_sm(),
1399 };
1400
1401 if let Some(styles) = custom_styles {
1402 let style_opt = match level {
1403 pulldown_cmark::HeadingLevel::H1 => &styles.h1,
1404 pulldown_cmark::HeadingLevel::H2 => &styles.h2,
1405 pulldown_cmark::HeadingLevel::H3 => &styles.h3,
1406 pulldown_cmark::HeadingLevel::H4 => &styles.h4,
1407 pulldown_cmark::HeadingLevel::H5 => &styles.h5,
1408 pulldown_cmark::HeadingLevel::H6 => &styles.h6,
1409 };
1410
1411 if let Some(style) = style_opt {
1412 heading.style().text = style.clone();
1413 }
1414 }
1415
1416 heading
1417}
1418
1419fn render_copy_code_block_button(
1420 id: usize,
1421 code: String,
1422 markdown: Entity<Markdown>,
1423 cx: &App,
1424) -> impl IntoElement {
1425 let id = ElementId::named_usize("copy-markdown-code", id);
1426 let was_copied = markdown.read(cx).copied_code_blocks.contains(&id);
1427 IconButton::new(
1428 id.clone(),
1429 if was_copied {
1430 IconName::Check
1431 } else {
1432 IconName::Copy
1433 },
1434 )
1435 .icon_color(Color::Muted)
1436 .icon_size(IconSize::Small)
1437 .style(ButtonStyle::Filled)
1438 .shape(ui::IconButtonShape::Square)
1439 .tooltip(Tooltip::text("Copy"))
1440 .on_click({
1441 let markdown = markdown;
1442 move |_event, _window, cx| {
1443 let id = id.clone();
1444 markdown.update(cx, |this, cx| {
1445 this.copied_code_blocks.insert(id.clone());
1446
1447 cx.write_to_clipboard(ClipboardItem::new_string(code.clone()));
1448
1449 cx.spawn(async move |this, cx| {
1450 cx.background_executor().timer(Duration::from_secs(2)).await;
1451
1452 cx.update(|cx| {
1453 this.update(cx, |this, cx| {
1454 this.copied_code_blocks.remove(&id);
1455 cx.notify();
1456 })
1457 })
1458 .ok();
1459 })
1460 .detach();
1461 });
1462 }
1463 })
1464}
1465
1466impl IntoElement for MarkdownElement {
1467 type Element = Self;
1468
1469 fn into_element(self) -> Self::Element {
1470 self
1471 }
1472}
1473
1474pub enum AnyDiv {
1475 Div(Div),
1476 Stateful(Stateful<Div>),
1477}
1478
1479impl AnyDiv {
1480 fn into_any_element(self) -> AnyElement {
1481 match self {
1482 Self::Div(div) => div.into_any_element(),
1483 Self::Stateful(div) => div.into_any_element(),
1484 }
1485 }
1486}
1487
1488impl From<Div> for AnyDiv {
1489 fn from(value: Div) -> Self {
1490 Self::Div(value)
1491 }
1492}
1493
1494impl From<Stateful<Div>> for AnyDiv {
1495 fn from(value: Stateful<Div>) -> Self {
1496 Self::Stateful(value)
1497 }
1498}
1499
1500impl Styled for AnyDiv {
1501 fn style(&mut self) -> &mut StyleRefinement {
1502 match self {
1503 Self::Div(div) => div.style(),
1504 Self::Stateful(div) => div.style(),
1505 }
1506 }
1507}
1508
1509impl ParentElement for AnyDiv {
1510 fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
1511 match self {
1512 Self::Div(div) => div.extend(elements),
1513 Self::Stateful(div) => div.extend(elements),
1514 }
1515 }
1516}
1517
1518#[derive(Default)]
1519struct TableState {
1520 alignments: Vec<Alignment>,
1521 in_head: bool,
1522 row_index: usize,
1523 col_index: usize,
1524}
1525
1526impl TableState {
1527 fn start(&mut self, alignments: Vec<Alignment>) {
1528 self.alignments = alignments;
1529 self.in_head = false;
1530 self.row_index = 0;
1531 self.col_index = 0;
1532 }
1533
1534 fn end(&mut self) {
1535 self.alignments.clear();
1536 self.in_head = false;
1537 self.row_index = 0;
1538 self.col_index = 0;
1539 }
1540
1541 fn start_head(&mut self) {
1542 self.in_head = true;
1543 }
1544
1545 fn end_head(&mut self) {
1546 self.in_head = false;
1547 }
1548
1549 fn start_row(&mut self) {
1550 self.col_index = 0;
1551 }
1552
1553 fn end_row(&mut self) {
1554 self.row_index += 1;
1555 }
1556
1557 fn end_cell(&mut self) {
1558 self.col_index += 1;
1559 }
1560}
1561
1562struct MarkdownElementBuilder {
1563 div_stack: Vec<AnyDiv>,
1564 rendered_lines: Vec<RenderedLine>,
1565 pending_line: PendingLine,
1566 rendered_links: Vec<RenderedLink>,
1567 current_source_index: usize,
1568 html_comment: bool,
1569 base_text_style: TextStyle,
1570 text_style_stack: Vec<TextStyleRefinement>,
1571 code_block_stack: Vec<Option<Arc<Language>>>,
1572 list_stack: Vec<ListStackEntry>,
1573 table: TableState,
1574 syntax_theme: Arc<SyntaxTheme>,
1575}
1576
1577#[derive(Default)]
1578struct PendingLine {
1579 text: String,
1580 runs: Vec<TextRun>,
1581 source_mappings: Vec<SourceMapping>,
1582}
1583
1584struct ListStackEntry {
1585 bullet_index: Option<u64>,
1586}
1587
1588impl MarkdownElementBuilder {
1589 fn new(
1590 container_style: &StyleRefinement,
1591 base_text_style: TextStyle,
1592 syntax_theme: Arc<SyntaxTheme>,
1593 ) -> Self {
1594 Self {
1595 div_stack: vec![{
1596 let mut base_div = div();
1597 base_div.style().refine(container_style);
1598 base_div.debug_selector(|| "inner".into()).into()
1599 }],
1600 rendered_lines: Vec::new(),
1601 pending_line: PendingLine::default(),
1602 rendered_links: Vec::new(),
1603 current_source_index: 0,
1604 html_comment: false,
1605 base_text_style,
1606 text_style_stack: Vec::new(),
1607 code_block_stack: Vec::new(),
1608 list_stack: Vec::new(),
1609 table: TableState::default(),
1610 syntax_theme,
1611 }
1612 }
1613
1614 fn push_text_style(&mut self, style: TextStyleRefinement) {
1615 self.text_style_stack.push(style);
1616 }
1617
1618 fn text_style(&self) -> TextStyle {
1619 let mut style = self.base_text_style.clone();
1620 for refinement in &self.text_style_stack {
1621 style.refine(refinement);
1622 }
1623 style
1624 }
1625
1626 fn pop_text_style(&mut self) {
1627 self.text_style_stack.pop();
1628 }
1629
1630 fn push_div(&mut self, div: impl Into<AnyDiv>, range: &Range<usize>, markdown_end: usize) {
1631 let mut div = div.into();
1632 self.flush_text();
1633
1634 if range.start == 0 {
1635 // Remove the top margin on the first element.
1636 div.style().refine(&StyleRefinement {
1637 margin: gpui::EdgesRefinement {
1638 top: Some(Length::Definite(px(0.).into())),
1639 left: None,
1640 right: None,
1641 bottom: None,
1642 },
1643 ..Default::default()
1644 });
1645 }
1646
1647 if range.end == markdown_end {
1648 div.style().refine(&StyleRefinement {
1649 margin: gpui::EdgesRefinement {
1650 top: None,
1651 left: None,
1652 right: None,
1653 bottom: Some(Length::Definite(rems(0.).into())),
1654 },
1655 ..Default::default()
1656 });
1657 }
1658
1659 self.div_stack.push(div);
1660 }
1661
1662 fn modify_current_div(&mut self, f: impl FnOnce(AnyDiv) -> AnyDiv) {
1663 self.flush_text();
1664 if let Some(div) = self.div_stack.pop() {
1665 self.div_stack.push(f(div));
1666 }
1667 }
1668
1669 fn pop_div(&mut self) {
1670 self.flush_text();
1671 let div = self.div_stack.pop().unwrap().into_any_element();
1672 self.div_stack.last_mut().unwrap().extend(iter::once(div));
1673 }
1674
1675 fn push_list(&mut self, bullet_index: Option<u64>) {
1676 self.list_stack.push(ListStackEntry { bullet_index });
1677 }
1678
1679 fn next_bullet_index(&mut self) -> Option<u64> {
1680 self.list_stack.last_mut().and_then(|entry| {
1681 let item_index = entry.bullet_index.as_mut()?;
1682 *item_index += 1;
1683 Some(*item_index - 1)
1684 })
1685 }
1686
1687 fn pop_list(&mut self) {
1688 self.list_stack.pop();
1689 }
1690
1691 fn push_code_block(&mut self, language: Option<Arc<Language>>) {
1692 self.code_block_stack.push(language);
1693 }
1694
1695 fn pop_code_block(&mut self) {
1696 self.code_block_stack.pop();
1697 }
1698
1699 fn push_link(&mut self, destination_url: SharedString, source_range: Range<usize>) {
1700 self.rendered_links.push(RenderedLink {
1701 source_range,
1702 destination_url,
1703 });
1704 }
1705
1706 fn push_text(&mut self, text: &str, source_range: Range<usize>) {
1707 self.pending_line.source_mappings.push(SourceMapping {
1708 rendered_index: self.pending_line.text.len(),
1709 source_index: source_range.start,
1710 });
1711 self.pending_line.text.push_str(text);
1712 self.current_source_index = source_range.end;
1713
1714 if let Some(Some(language)) = self.code_block_stack.last() {
1715 let mut offset = 0;
1716 for (range, highlight_id) in language.highlight_text(&Rope::from(text), 0..text.len()) {
1717 if range.start > offset {
1718 self.pending_line
1719 .runs
1720 .push(self.text_style().to_run(range.start - offset));
1721 }
1722
1723 let mut run_style = self.text_style();
1724 if let Some(highlight) = highlight_id.style(&self.syntax_theme) {
1725 run_style = run_style.highlight(highlight);
1726 }
1727 self.pending_line.runs.push(run_style.to_run(range.len()));
1728 offset = range.end;
1729 }
1730
1731 if offset < text.len() {
1732 self.pending_line
1733 .runs
1734 .push(self.text_style().to_run(text.len() - offset));
1735 }
1736 } else {
1737 self.pending_line
1738 .runs
1739 .push(self.text_style().to_run(text.len()));
1740 }
1741 }
1742
1743 fn trim_trailing_newline(&mut self) {
1744 if self.pending_line.text.ends_with('\n') {
1745 self.pending_line
1746 .text
1747 .truncate(self.pending_line.text.len() - 1);
1748 self.pending_line.runs.last_mut().unwrap().len -= 1;
1749 self.current_source_index -= 1;
1750 }
1751 }
1752
1753 fn flush_text(&mut self) {
1754 let line = mem::take(&mut self.pending_line);
1755 if line.text.is_empty() {
1756 return;
1757 }
1758
1759 let text = StyledText::new(line.text).with_runs(line.runs);
1760 self.rendered_lines.push(RenderedLine {
1761 layout: text.layout().clone(),
1762 source_mappings: line.source_mappings,
1763 source_end: self.current_source_index,
1764 });
1765 self.div_stack.last_mut().unwrap().extend([text.into_any()]);
1766 }
1767
1768 fn build(mut self) -> RenderedMarkdown {
1769 debug_assert_eq!(self.div_stack.len(), 1);
1770 self.flush_text();
1771 RenderedMarkdown {
1772 element: self.div_stack.pop().unwrap().into_any_element(),
1773 text: RenderedText {
1774 lines: self.rendered_lines.into(),
1775 links: self.rendered_links.into(),
1776 },
1777 }
1778 }
1779}
1780
1781struct RenderedLine {
1782 layout: TextLayout,
1783 source_mappings: Vec<SourceMapping>,
1784 source_end: usize,
1785}
1786
1787impl RenderedLine {
1788 fn rendered_index_for_source_index(&self, source_index: usize) -> usize {
1789 if source_index >= self.source_end {
1790 return self.layout.len();
1791 }
1792
1793 let mapping = match self
1794 .source_mappings
1795 .binary_search_by_key(&source_index, |probe| probe.source_index)
1796 {
1797 Ok(ix) => &self.source_mappings[ix],
1798 Err(ix) => &self.source_mappings[ix - 1],
1799 };
1800 mapping.rendered_index + (source_index - mapping.source_index)
1801 }
1802
1803 fn source_index_for_rendered_index(&self, rendered_index: usize) -> usize {
1804 if rendered_index >= self.layout.len() {
1805 return self.source_end;
1806 }
1807
1808 let mapping = match self
1809 .source_mappings
1810 .binary_search_by_key(&rendered_index, |probe| probe.rendered_index)
1811 {
1812 Ok(ix) => &self.source_mappings[ix],
1813 Err(ix) => &self.source_mappings[ix - 1],
1814 };
1815 mapping.source_index + (rendered_index - mapping.rendered_index)
1816 }
1817
1818 fn source_index_for_position(&self, position: Point<Pixels>) -> Result<usize, usize> {
1819 let line_rendered_index;
1820 let out_of_bounds;
1821 match self.layout.index_for_position(position) {
1822 Ok(ix) => {
1823 line_rendered_index = ix;
1824 out_of_bounds = false;
1825 }
1826 Err(ix) => {
1827 line_rendered_index = ix;
1828 out_of_bounds = true;
1829 }
1830 };
1831 let source_index = self.source_index_for_rendered_index(line_rendered_index);
1832 if out_of_bounds {
1833 Err(source_index)
1834 } else {
1835 Ok(source_index)
1836 }
1837 }
1838}
1839
1840#[derive(Copy, Clone, Debug, Default)]
1841struct SourceMapping {
1842 rendered_index: usize,
1843 source_index: usize,
1844}
1845
1846pub struct RenderedMarkdown {
1847 element: AnyElement,
1848 text: RenderedText,
1849}
1850
1851#[derive(Clone)]
1852struct RenderedText {
1853 lines: Rc<[RenderedLine]>,
1854 links: Rc<[RenderedLink]>,
1855}
1856
1857#[derive(Debug, Clone, Eq, PartialEq)]
1858struct RenderedLink {
1859 source_range: Range<usize>,
1860 destination_url: SharedString,
1861}
1862
1863impl RenderedText {
1864 fn source_index_for_position(&self, position: Point<Pixels>) -> Result<usize, usize> {
1865 let mut lines = self.lines.iter().peekable();
1866
1867 while let Some(line) = lines.next() {
1868 let line_bounds = line.layout.bounds();
1869 if position.y > line_bounds.bottom() {
1870 if let Some(next_line) = lines.peek()
1871 && position.y < next_line.layout.bounds().top()
1872 {
1873 return Err(line.source_end);
1874 }
1875
1876 continue;
1877 }
1878
1879 return line.source_index_for_position(position);
1880 }
1881
1882 Err(self.lines.last().map_or(0, |line| line.source_end))
1883 }
1884
1885 fn position_for_source_index(&self, source_index: usize) -> Option<(Point<Pixels>, Pixels)> {
1886 for line in self.lines.iter() {
1887 let line_source_start = line.source_mappings.first().unwrap().source_index;
1888 if source_index < line_source_start {
1889 break;
1890 } else if source_index > line.source_end {
1891 continue;
1892 } else {
1893 let line_height = line.layout.line_height();
1894 let rendered_index_within_line = line.rendered_index_for_source_index(source_index);
1895 let position = line.layout.position_for_index(rendered_index_within_line)?;
1896 return Some((position, line_height));
1897 }
1898 }
1899 None
1900 }
1901
1902 fn surrounding_word_range(&self, source_index: usize) -> Range<usize> {
1903 for line in self.lines.iter() {
1904 if source_index > line.source_end {
1905 continue;
1906 }
1907
1908 let line_rendered_start = line.source_mappings.first().unwrap().rendered_index;
1909 let rendered_index_in_line =
1910 line.rendered_index_for_source_index(source_index) - line_rendered_start;
1911 let text = line.layout.text();
1912 let previous_space = if let Some(idx) = text[0..rendered_index_in_line].rfind(' ') {
1913 idx + ' '.len_utf8()
1914 } else {
1915 0
1916 };
1917 let next_space = if let Some(idx) = text[rendered_index_in_line..].find(' ') {
1918 rendered_index_in_line + idx
1919 } else {
1920 text.len()
1921 };
1922
1923 return line.source_index_for_rendered_index(line_rendered_start + previous_space)
1924 ..line.source_index_for_rendered_index(line_rendered_start + next_space);
1925 }
1926
1927 source_index..source_index
1928 }
1929
1930 fn surrounding_line_range(&self, source_index: usize) -> Range<usize> {
1931 for line in self.lines.iter() {
1932 if source_index > line.source_end {
1933 continue;
1934 }
1935 let line_source_start = line.source_mappings.first().unwrap().source_index;
1936 return line_source_start..line.source_end;
1937 }
1938
1939 source_index..source_index
1940 }
1941
1942 fn text_for_range(&self, range: Range<usize>) -> String {
1943 let mut accumulator = String::new();
1944
1945 for line in self.lines.iter() {
1946 if range.start > line.source_end {
1947 continue;
1948 }
1949 let line_source_start = line.source_mappings.first().unwrap().source_index;
1950 if range.end < line_source_start {
1951 break;
1952 }
1953
1954 let text = line.layout.text();
1955
1956 let start = if range.start < line_source_start {
1957 0
1958 } else {
1959 line.rendered_index_for_source_index(range.start)
1960 };
1961 let end = if range.end > line.source_end {
1962 line.rendered_index_for_source_index(line.source_end)
1963 } else {
1964 line.rendered_index_for_source_index(range.end)
1965 }
1966 .min(text.len());
1967
1968 accumulator.push_str(&text[start..end]);
1969 accumulator.push('\n');
1970 }
1971 // Remove trailing newline
1972 accumulator.pop();
1973 accumulator
1974 }
1975
1976 fn link_for_position(&self, position: Point<Pixels>) -> Option<&RenderedLink> {
1977 let source_index = self.source_index_for_position(position).ok()?;
1978 self.links
1979 .iter()
1980 .find(|link| link.source_range.contains(&source_index))
1981 }
1982}
1983
1984#[cfg(test)]
1985mod tests {
1986 use super::*;
1987 use gpui::{TestAppContext, size};
1988
1989 #[gpui::test]
1990 fn test_mappings(cx: &mut TestAppContext) {
1991 // Formatting.
1992 assert_mappings(
1993 &render_markdown("He*l*lo", cx),
1994 vec![vec![(0, 0), (1, 1), (2, 3), (3, 5), (4, 6), (5, 7)]],
1995 );
1996
1997 // Multiple lines.
1998 assert_mappings(
1999 &render_markdown("Hello\n\nWorld", cx),
2000 vec![
2001 vec![(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
2002 vec![(0, 7), (1, 8), (2, 9), (3, 10), (4, 11), (5, 12)],
2003 ],
2004 );
2005
2006 // Multi-byte characters.
2007 assert_mappings(
2008 &render_markdown("αβγ\n\nδεζ", cx),
2009 vec![
2010 vec![(0, 0), (2, 2), (4, 4), (6, 6)],
2011 vec![(0, 8), (2, 10), (4, 12), (6, 14)],
2012 ],
2013 );
2014
2015 // Smart quotes.
2016 assert_mappings(&render_markdown("\"", cx), vec![vec![(0, 0), (3, 1)]]);
2017 assert_mappings(
2018 &render_markdown("\"hey\"", cx),
2019 vec![vec![(0, 0), (3, 1), (4, 2), (5, 3), (6, 4), (9, 5)]],
2020 );
2021
2022 // HTML Comments are ignored
2023 assert_mappings(
2024 &render_markdown(
2025 "<!--\nrdoc-file=string.c\n- str.intern -> symbol\n- str.to_sym -> symbol\n-->\nReturns",
2026 cx,
2027 ),
2028 vec![vec![
2029 (0, 78),
2030 (1, 79),
2031 (2, 80),
2032 (3, 81),
2033 (4, 82),
2034 (5, 83),
2035 (6, 84),
2036 ]],
2037 );
2038 }
2039
2040 fn render_markdown(markdown: &str, cx: &mut TestAppContext) -> RenderedText {
2041 struct TestWindow;
2042
2043 impl Render for TestWindow {
2044 fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
2045 div()
2046 }
2047 }
2048
2049 let (_, cx) = cx.add_window_view(|_, _| TestWindow);
2050 let markdown = cx.new(|cx| Markdown::new(markdown.to_string().into(), None, None, cx));
2051 cx.run_until_parked();
2052 let (rendered, _) = cx.draw(
2053 Default::default(),
2054 size(px(600.0), px(600.0)),
2055 |_window, _cx| MarkdownElement::new(markdown, MarkdownStyle::default()),
2056 );
2057 rendered.text
2058 }
2059
2060 #[gpui::test]
2061 fn test_surrounding_word_range(cx: &mut TestAppContext) {
2062 let rendered = render_markdown("Hello world tesεζ", cx);
2063
2064 // Test word selection for "Hello"
2065 let word_range = rendered.surrounding_word_range(2); // Simulate click on 'l' in "Hello"
2066 let selected_text = rendered.text_for_range(word_range);
2067 assert_eq!(selected_text, "Hello");
2068
2069 // Test word selection for "world"
2070 let word_range = rendered.surrounding_word_range(7); // Simulate click on 'o' in "world"
2071 let selected_text = rendered.text_for_range(word_range);
2072 assert_eq!(selected_text, "world");
2073
2074 // Test word selection for "tesεζ"
2075 let word_range = rendered.surrounding_word_range(14); // Simulate click on 's' in "tesεζ"
2076 let selected_text = rendered.text_for_range(word_range);
2077 assert_eq!(selected_text, "tesεζ");
2078
2079 // Test word selection at word boundary (space)
2080 let word_range = rendered.surrounding_word_range(5); // Simulate click on space between "Hello" and "world", expect highlighting word to the left
2081 let selected_text = rendered.text_for_range(word_range);
2082 assert_eq!(selected_text, "Hello");
2083 }
2084
2085 #[gpui::test]
2086 fn test_surrounding_line_range(cx: &mut TestAppContext) {
2087 let rendered = render_markdown("First line\n\nSecond line\n\nThird lineεζ", cx);
2088
2089 // Test getting line range for first line
2090 let line_range = rendered.surrounding_line_range(5); // Simulate click somewhere in first line
2091 let selected_text = rendered.text_for_range(line_range);
2092 assert_eq!(selected_text, "First line");
2093
2094 // Test getting line range for second line
2095 let line_range = rendered.surrounding_line_range(13); // Simulate click at beginning in second line
2096 let selected_text = rendered.text_for_range(line_range);
2097 assert_eq!(selected_text, "Second line");
2098
2099 // Test getting line range for third line
2100 let line_range = rendered.surrounding_line_range(37); // Simulate click at end of third line with multi-byte chars
2101 let selected_text = rendered.text_for_range(line_range);
2102 assert_eq!(selected_text, "Third lineεζ");
2103 }
2104
2105 #[gpui::test]
2106 fn test_selection_head_movement(cx: &mut TestAppContext) {
2107 let rendered = render_markdown("Hello world test", cx);
2108
2109 let mut selection = Selection {
2110 start: 5,
2111 end: 5,
2112 reversed: false,
2113 pending: false,
2114 mode: SelectMode::Character,
2115 };
2116
2117 // Test forward selection
2118 selection.set_head(10, &rendered);
2119 assert_eq!(selection.start, 5);
2120 assert_eq!(selection.end, 10);
2121 assert!(!selection.reversed);
2122 assert_eq!(selection.tail(), 5);
2123
2124 // Test backward selection
2125 selection.set_head(2, &rendered);
2126 assert_eq!(selection.start, 2);
2127 assert_eq!(selection.end, 5);
2128 assert!(selection.reversed);
2129 assert_eq!(selection.tail(), 5);
2130
2131 // Test forward selection again from reversed state
2132 selection.set_head(15, &rendered);
2133 assert_eq!(selection.start, 5);
2134 assert_eq!(selection.end, 15);
2135 assert!(!selection.reversed);
2136 assert_eq!(selection.tail(), 5);
2137 }
2138
2139 #[gpui::test]
2140 fn test_word_selection_drag(cx: &mut TestAppContext) {
2141 let rendered = render_markdown("Hello world test", cx);
2142
2143 // Start with a simulated double-click on "world" (index 6-10)
2144 let word_range = rendered.surrounding_word_range(7); // Click on 'o' in "world"
2145 let mut selection = Selection {
2146 start: word_range.start,
2147 end: word_range.end,
2148 reversed: false,
2149 pending: true,
2150 mode: SelectMode::Word(word_range),
2151 };
2152
2153 // Drag forward to "test" - should expand selection to include "test"
2154 selection.set_head(13, &rendered); // Index in "test"
2155 assert_eq!(selection.start, 6); // Start of "world"
2156 assert_eq!(selection.end, 16); // End of "test"
2157 assert!(!selection.reversed);
2158 let selected_text = rendered.text_for_range(selection.start..selection.end);
2159 assert_eq!(selected_text, "world test");
2160
2161 // Drag backward to "Hello" - should expand selection to include "Hello"
2162 selection.set_head(2, &rendered); // Index in "Hello"
2163 assert_eq!(selection.start, 0); // Start of "Hello"
2164 assert_eq!(selection.end, 11); // End of "world" (original selection)
2165 assert!(selection.reversed);
2166 let selected_text = rendered.text_for_range(selection.start..selection.end);
2167 assert_eq!(selected_text, "Hello world");
2168
2169 // Drag back within original word - should revert to original selection
2170 selection.set_head(8, &rendered); // Back within "world"
2171 assert_eq!(selection.start, 6); // Start of "world"
2172 assert_eq!(selection.end, 11); // End of "world"
2173 assert!(!selection.reversed);
2174 let selected_text = rendered.text_for_range(selection.start..selection.end);
2175 assert_eq!(selected_text, "world");
2176 }
2177
2178 #[gpui::test]
2179 fn test_selection_with_markdown_formatting(cx: &mut TestAppContext) {
2180 let rendered = render_markdown(
2181 "This is **bold** text, this is *italic* text, use `code` here",
2182 cx,
2183 );
2184 let word_range = rendered.surrounding_word_range(10); // Inside "bold"
2185 let selected_text = rendered.text_for_range(word_range);
2186 assert_eq!(selected_text, "bold");
2187
2188 let word_range = rendered.surrounding_word_range(32); // Inside "italic"
2189 let selected_text = rendered.text_for_range(word_range);
2190 assert_eq!(selected_text, "italic");
2191
2192 let word_range = rendered.surrounding_word_range(51); // Inside "code"
2193 let selected_text = rendered.text_for_range(word_range);
2194 assert_eq!(selected_text, "code");
2195 }
2196
2197 #[gpui::test]
2198 fn test_all_selection(cx: &mut TestAppContext) {
2199 let rendered = render_markdown("Hello world\n\nThis is a test\n\nwith multiple lines", cx);
2200
2201 let total_length = rendered
2202 .lines
2203 .last()
2204 .map(|line| line.source_end)
2205 .unwrap_or(0);
2206
2207 let mut selection = Selection {
2208 start: 0,
2209 end: total_length,
2210 reversed: false,
2211 pending: true,
2212 mode: SelectMode::All,
2213 };
2214
2215 selection.set_head(5, &rendered); // Try to set head in middle
2216 assert_eq!(selection.start, 0);
2217 assert_eq!(selection.end, total_length);
2218 assert!(!selection.reversed);
2219
2220 selection.set_head(25, &rendered); // Try to set head near end
2221 assert_eq!(selection.start, 0);
2222 assert_eq!(selection.end, total_length);
2223 assert!(!selection.reversed);
2224
2225 let selected_text = rendered.text_for_range(selection.start..selection.end);
2226 assert_eq!(
2227 selected_text,
2228 "Hello world\nThis is a test\nwith multiple lines"
2229 );
2230 }
2231
2232 #[test]
2233 fn test_escape() {
2234 assert_eq!(Markdown::escape("hello `world`"), "hello \\`world\\`");
2235 assert_eq!(
2236 Markdown::escape("hello\n cool world"),
2237 "hello\n\ncool world"
2238 );
2239 }
2240
2241 #[track_caller]
2242 fn assert_mappings(rendered: &RenderedText, expected: Vec<Vec<(usize, usize)>>) {
2243 assert_eq!(rendered.lines.len(), expected.len(), "line count mismatch");
2244 for (line_ix, line_mappings) in expected.into_iter().enumerate() {
2245 let line = &rendered.lines[line_ix];
2246
2247 assert!(
2248 line.source_mappings.windows(2).all(|mappings| {
2249 mappings[0].source_index < mappings[1].source_index
2250 && mappings[0].rendered_index < mappings[1].rendered_index
2251 }),
2252 "line {} has duplicate mappings: {:?}",
2253 line_ix,
2254 line.source_mappings
2255 );
2256
2257 for (rendered_ix, source_ix) in line_mappings {
2258 assert_eq!(
2259 line.source_index_for_rendered_index(rendered_ix),
2260 source_ix,
2261 "line {}, rendered_ix {}",
2262 line_ix,
2263 rendered_ix
2264 );
2265
2266 assert_eq!(
2267 line.rendered_index_for_source_index(source_ix),
2268 rendered_ix,
2269 "line {}, source_ix {}",
2270 line_ix,
2271 source_ix
2272 );
2273 }
2274 }
2275 }
2276}