585 lines
19 KiB
Rust
585 lines
19 KiB
Rust
use std::ops::Range;
|
|
|
|
use iced_wgpu::core::text::highlighter;
|
|
use iced_wgpu::core::{Color, Font};
|
|
use iced_wgpu::core::font::{Weight, Style as FontStyle};
|
|
use acord_core::highlight::{highlight_source, HighlightSpan};
|
|
use acord_core::doc::{classify_document, LineKind};
|
|
use crate::editor::{RESULT_PREFIX, ERROR_PREFIX};
|
|
use crate::palette;
|
|
|
|
pub const EVAL_RESULT_KIND: u8 = 24;
|
|
pub const EVAL_ERROR_KIND: u8 = 25;
|
|
|
|
const MD_HEADING_MARKER: u8 = 26;
|
|
const MD_H1: u8 = 27;
|
|
const MD_H2: u8 = 28;
|
|
const MD_H3: u8 = 29;
|
|
const MD_BOLD: u8 = 30;
|
|
const MD_ITALIC: u8 = 31;
|
|
const MD_INLINE_CODE: u8 = 32;
|
|
const MD_FORMAT_MARKER: u8 = 33;
|
|
const MD_LINK_TEXT: u8 = 34;
|
|
const MD_LINK_URL: u8 = 35;
|
|
const MD_BLOCKQUOTE_MARKER: u8 = 36;
|
|
const MD_BLOCKQUOTE: u8 = 37;
|
|
const MD_LIST_MARKER: u8 = 38;
|
|
const MD_FENCE_MARKER: u8 = 39;
|
|
const MD_CODE_BLOCK: u8 = 40;
|
|
const MD_HR: u8 = 41;
|
|
const MD_TASK_OPEN: u8 = 42;
|
|
const MD_TASK_DONE: u8 = 43;
|
|
const MD_BOLD_ITALIC: u8 = 44;
|
|
|
|
#[derive(Clone, PartialEq)]
|
|
pub struct SyntaxSettings {
|
|
pub lang: String,
|
|
pub source: String,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub struct SyntaxHighlight {
|
|
pub kind: u8,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum LineDecor {
|
|
None,
|
|
CodeBlock,
|
|
Blockquote,
|
|
HorizontalRule,
|
|
FenceMarker,
|
|
}
|
|
|
|
pub struct SyntaxHighlighter {
|
|
lang: String,
|
|
spans: Vec<HighlightSpan>,
|
|
line_offsets: Vec<usize>,
|
|
line_kinds: Vec<LineKind>,
|
|
in_fenced_code: bool,
|
|
current_line: usize,
|
|
line_decors: Vec<LineDecor>,
|
|
}
|
|
|
|
impl SyntaxHighlighter {
|
|
fn rebuild(&mut self, source: &str) {
|
|
self.spans = highlight_source(source, &self.lang);
|
|
self.line_offsets.clear();
|
|
let mut offset = 0;
|
|
for line in source.split('\n') {
|
|
self.line_offsets.push(offset);
|
|
offset += line.len() + 1;
|
|
}
|
|
let classified = classify_document(source);
|
|
self.line_kinds = classified.into_iter().map(|cl| cl.kind).collect();
|
|
|
|
self.line_decors.clear();
|
|
let mut in_fence = false;
|
|
for (i, raw_line) in source.split('\n').enumerate() {
|
|
let is_md = i < self.line_kinds.len() && self.line_kinds[i] == LineKind::Markdown;
|
|
if is_md {
|
|
let trimmed = raw_line.trim_start();
|
|
if trimmed.starts_with("```") {
|
|
in_fence = !in_fence;
|
|
self.line_decors.push(LineDecor::FenceMarker);
|
|
} else if in_fence {
|
|
self.line_decors.push(LineDecor::CodeBlock);
|
|
} else if is_horizontal_rule(trimmed) {
|
|
self.line_decors.push(LineDecor::HorizontalRule);
|
|
} else if trimmed.starts_with("> ") || trimmed == ">" {
|
|
self.line_decors.push(LineDecor::Blockquote);
|
|
} else {
|
|
self.line_decors.push(LineDecor::None);
|
|
}
|
|
} else {
|
|
if in_fence { in_fence = false; }
|
|
self.line_decors.push(LineDecor::None);
|
|
}
|
|
}
|
|
|
|
self.in_fenced_code = false;
|
|
self.current_line = 0;
|
|
}
|
|
|
|
fn highlight_markdown(&self, line: &str) -> Vec<(Range<usize>, SyntaxHighlight)> {
|
|
let trimmed = line.trim_start();
|
|
let leading = line.len() - trimmed.len();
|
|
|
|
if is_horizontal_rule(trimmed) {
|
|
return vec![(0..line.len(), SyntaxHighlight { kind: MD_HR })];
|
|
}
|
|
|
|
if let Some(level) = heading_level(trimmed) {
|
|
let marker_end = leading + level + 1;
|
|
let kind = match level {
|
|
1 => MD_H1,
|
|
2 => MD_H2,
|
|
_ => MD_H3,
|
|
};
|
|
let mut spans = vec![
|
|
(0..marker_end, SyntaxHighlight { kind: MD_HEADING_MARKER }),
|
|
];
|
|
if marker_end < line.len() {
|
|
spans.push((marker_end..line.len(), SyntaxHighlight { kind }));
|
|
}
|
|
return spans;
|
|
}
|
|
|
|
if trimmed.starts_with("> ") || trimmed == ">" {
|
|
let marker_end = leading + if trimmed.len() > 1 { 2 } else { 1 };
|
|
let mut spans = vec![
|
|
(0..marker_end, SyntaxHighlight { kind: MD_BLOCKQUOTE_MARKER }),
|
|
];
|
|
if marker_end < line.len() {
|
|
let content = &line[marker_end..];
|
|
let inner = parse_inline(content, marker_end);
|
|
if inner.is_empty() {
|
|
spans.push((marker_end..line.len(), SyntaxHighlight { kind: MD_BLOCKQUOTE }));
|
|
} else {
|
|
spans.extend(inner);
|
|
}
|
|
}
|
|
return spans;
|
|
}
|
|
|
|
if let Some(list_info) = list_marker_info(trimmed) {
|
|
let (marker_len, marker_kind) = match list_info {
|
|
ListKind::TaskOpen(n) => (n, MD_TASK_OPEN),
|
|
ListKind::TaskDone(n) => (n, MD_TASK_DONE),
|
|
ListKind::Plain(n) => (n, MD_LIST_MARKER),
|
|
};
|
|
let marker_end = leading + marker_len;
|
|
let mut spans = vec![
|
|
(0..marker_end, SyntaxHighlight { kind: marker_kind }),
|
|
];
|
|
if marker_end < line.len() {
|
|
let content = &line[marker_end..];
|
|
let inner = parse_inline(content, marker_end);
|
|
if inner.is_empty() {
|
|
return spans;
|
|
}
|
|
spans.extend(inner);
|
|
}
|
|
return spans;
|
|
}
|
|
|
|
parse_inline(line, 0)
|
|
}
|
|
}
|
|
|
|
fn heading_level(trimmed: &str) -> Option<usize> {
|
|
let bytes = trimmed.as_bytes();
|
|
if bytes.is_empty() || bytes[0] != b'#' { return None; }
|
|
let mut level = 0;
|
|
while level < bytes.len() && bytes[level] == b'#' { level += 1; }
|
|
if level > 3 { return None; }
|
|
if level < bytes.len() && bytes[level] == b' ' {
|
|
Some(level)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn is_horizontal_rule(trimmed: &str) -> bool {
|
|
if trimmed.len() < 3 { return false; }
|
|
let first = trimmed.as_bytes()[0];
|
|
if !matches!(first, b'-' | b'*' | b'_') { return false; }
|
|
trimmed.bytes().all(|b| b == first || b == b' ')
|
|
}
|
|
|
|
#[derive(Clone, Copy, PartialEq)]
|
|
enum ListKind {
|
|
Plain(usize),
|
|
TaskOpen(usize),
|
|
TaskDone(usize),
|
|
}
|
|
|
|
fn list_marker_info(trimmed: &str) -> Option<ListKind> {
|
|
let bytes = trimmed.as_bytes();
|
|
if bytes.is_empty() { return None; }
|
|
|
|
if matches!(bytes[0], b'-' | b'*' | b'+') && bytes.get(1) == Some(&b' ') {
|
|
if trimmed.starts_with("- [ ] ") {
|
|
return Some(ListKind::TaskOpen(6));
|
|
}
|
|
if trimmed.starts_with("- [x] ") || trimmed.starts_with("- [X] ") {
|
|
return Some(ListKind::TaskDone(6));
|
|
}
|
|
return Some(ListKind::Plain(2));
|
|
}
|
|
|
|
let mut i = 0;
|
|
while i < bytes.len() && bytes[i].is_ascii_digit() { i += 1; }
|
|
if i > 0 && i < bytes.len() && matches!(bytes[i], b'.' | b')') {
|
|
if bytes.get(i + 1) == Some(&b' ') {
|
|
return Some(ListKind::Plain(i + 2));
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn parse_inline(text: &str, base: usize) -> Vec<(Range<usize>, SyntaxHighlight)> {
|
|
let bytes = text.as_bytes();
|
|
let len = bytes.len();
|
|
let mut spans = Vec::new();
|
|
let mut i = 0;
|
|
|
|
while i < len {
|
|
if bytes[i] == b'\\' && i + 1 < len && is_md_punctuation(bytes[i + 1]) {
|
|
i += 2;
|
|
continue;
|
|
}
|
|
|
|
if i + 2 < len && bytes[i] == b'*' && bytes[i + 1] == b'*' && bytes[i + 2] == b'*' {
|
|
if let Some(end) = find_triple_star(bytes, i + 3) {
|
|
spans.push((base + i..base + i + 3, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
if i + 3 < end {
|
|
spans.push((base + i + 3..base + end, SyntaxHighlight { kind: MD_BOLD_ITALIC }));
|
|
}
|
|
spans.push((base + end..base + end + 3, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
i = end + 3;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if i + 1 < len && bytes[i] == b'*' && bytes[i + 1] == b'*' {
|
|
if let Some(end) = find_closing(bytes, i + 2, b'*', b'*') {
|
|
spans.push((base + i..base + i + 2, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
if i + 2 < end {
|
|
let inner = parse_inline(&text[i + 2..end], base + i + 2);
|
|
if inner.is_empty() {
|
|
spans.push((base + i + 2..base + end, SyntaxHighlight { kind: MD_BOLD }));
|
|
} else {
|
|
for (r, h) in inner {
|
|
let kind = if h.kind == MD_ITALIC { MD_BOLD_ITALIC } else { h.kind };
|
|
spans.push((r, SyntaxHighlight { kind }));
|
|
}
|
|
}
|
|
}
|
|
spans.push((base + end..base + end + 2, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
i = end + 2;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if bytes[i] == b'*' && (i + 1 >= len || bytes[i + 1] != b'*') {
|
|
if let Some(end) = find_single_closing(bytes, i + 1, b'*') {
|
|
if end > i + 1 && bytes[end - 1] != b'*' {
|
|
spans.push((base + i..base + i + 1, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
if i + 1 < end {
|
|
spans.push((base + i + 1..base + end, SyntaxHighlight { kind: MD_ITALIC }));
|
|
}
|
|
spans.push((base + end..base + end + 1, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
i = end + 1;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if bytes[i] == b'`' {
|
|
let tick_count = count_backticks(bytes, i);
|
|
if let Some(end) = find_backtick_close(bytes, i + tick_count, tick_count) {
|
|
spans.push((base + i..base + i + tick_count, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
if i + tick_count < end {
|
|
spans.push((base + i + tick_count..base + end, SyntaxHighlight { kind: MD_INLINE_CODE }));
|
|
}
|
|
spans.push((base + end..base + end + tick_count, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
i = end + tick_count;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if bytes[i] == b'[' {
|
|
if let Some((text_end, url_end)) = find_link(bytes, i) {
|
|
spans.push((base + i..base + i + 1, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
if i + 1 < text_end {
|
|
spans.push((base + i + 1..base + text_end, SyntaxHighlight { kind: MD_LINK_TEXT }));
|
|
}
|
|
spans.push((base + text_end..base + text_end + 2, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
if text_end + 2 < url_end {
|
|
spans.push((base + text_end + 2..base + url_end, SyntaxHighlight { kind: MD_LINK_URL }));
|
|
}
|
|
spans.push((base + url_end..base + url_end + 1, SyntaxHighlight { kind: MD_FORMAT_MARKER }));
|
|
i = url_end + 1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
i += 1;
|
|
}
|
|
|
|
spans
|
|
}
|
|
|
|
fn is_md_punctuation(b: u8) -> bool {
|
|
matches!(b, b'\\' | b'`' | b'*' | b'_' | b'{' | b'}' | b'[' | b']'
|
|
| b'(' | b')' | b'#' | b'+' | b'-' | b'.' | b'!' | b'|')
|
|
}
|
|
|
|
fn find_triple_star(bytes: &[u8], start: usize) -> Option<usize> {
|
|
let mut i = start;
|
|
while i + 2 < bytes.len() {
|
|
if bytes[i] == b'*' && bytes[i + 1] == b'*' && bytes[i + 2] == b'*' {
|
|
return Some(i);
|
|
}
|
|
i += 1;
|
|
}
|
|
None
|
|
}
|
|
|
|
fn count_backticks(bytes: &[u8], start: usize) -> usize {
|
|
let mut n = 0;
|
|
while start + n < bytes.len() && bytes[start + n] == b'`' { n += 1; }
|
|
n
|
|
}
|
|
|
|
fn find_backtick_close(bytes: &[u8], start: usize, count: usize) -> Option<usize> {
|
|
if count == 0 { return None; }
|
|
let mut i = start;
|
|
while i + count <= bytes.len() {
|
|
if count_backticks(bytes, i) == count {
|
|
return Some(i);
|
|
}
|
|
i += 1;
|
|
}
|
|
None
|
|
}
|
|
|
|
fn find_closing(bytes: &[u8], start: usize, c1: u8, c2: u8) -> Option<usize> {
|
|
let mut i = start;
|
|
while i + 1 < bytes.len() {
|
|
if bytes[i] == c1 && bytes[i + 1] == c2 {
|
|
return Some(i);
|
|
}
|
|
i += 1;
|
|
}
|
|
None
|
|
}
|
|
|
|
fn find_single_closing(bytes: &[u8], start: usize, ch: u8) -> Option<usize> {
|
|
let mut i = start;
|
|
while i < bytes.len() {
|
|
if bytes[i] == ch {
|
|
return Some(i);
|
|
}
|
|
i += 1;
|
|
}
|
|
None
|
|
}
|
|
|
|
fn find_link(bytes: &[u8], open: usize) -> Option<(usize, usize)> {
|
|
let mut i = open + 1;
|
|
while i < bytes.len() {
|
|
if bytes[i] == b']' {
|
|
if i + 1 < bytes.len() && bytes[i + 1] == b'(' {
|
|
let text_end = i;
|
|
let mut j = i + 2;
|
|
while j < bytes.len() {
|
|
if bytes[j] == b')' {
|
|
return Some((text_end, j));
|
|
}
|
|
j += 1;
|
|
}
|
|
}
|
|
return None;
|
|
}
|
|
if bytes[i] == b'\n' { return None; }
|
|
i += 1;
|
|
}
|
|
None
|
|
}
|
|
|
|
impl highlighter::Highlighter for SyntaxHighlighter {
|
|
type Settings = SyntaxSettings;
|
|
type Highlight = SyntaxHighlight;
|
|
type Iterator<'a> = std::vec::IntoIter<(Range<usize>, SyntaxHighlight)>;
|
|
|
|
fn new(settings: &Self::Settings) -> Self {
|
|
let mut h = SyntaxHighlighter {
|
|
lang: settings.lang.clone(),
|
|
spans: Vec::new(),
|
|
line_offsets: Vec::new(),
|
|
line_kinds: Vec::new(),
|
|
in_fenced_code: false,
|
|
current_line: 0,
|
|
line_decors: Vec::new(),
|
|
};
|
|
h.rebuild(&settings.source);
|
|
h
|
|
}
|
|
|
|
fn update(&mut self, new_settings: &Self::Settings) {
|
|
self.lang = new_settings.lang.clone();
|
|
self.rebuild(&new_settings.source);
|
|
}
|
|
|
|
fn change_line(&mut self, line: usize) {
|
|
self.current_line = self.current_line.min(line);
|
|
if line == 0 {
|
|
self.in_fenced_code = false;
|
|
}
|
|
}
|
|
|
|
fn highlight_line(&mut self, line: &str) -> Self::Iterator<'_> {
|
|
let ln = self.current_line;
|
|
self.current_line += 1;
|
|
|
|
let trimmed = line.trim_start();
|
|
if trimmed.starts_with(RESULT_PREFIX) {
|
|
return vec![(0..line.len(), SyntaxHighlight { kind: EVAL_RESULT_KIND })].into_iter();
|
|
}
|
|
if trimmed.starts_with(ERROR_PREFIX) {
|
|
return vec![(0..line.len(), SyntaxHighlight { kind: EVAL_ERROR_KIND })].into_iter();
|
|
}
|
|
|
|
let is_markdown = ln < self.line_kinds.len()
|
|
&& self.line_kinds[ln] == LineKind::Markdown;
|
|
|
|
if is_markdown {
|
|
if trimmed.starts_with("```") {
|
|
self.in_fenced_code = !self.in_fenced_code;
|
|
return vec![(0..line.len(), SyntaxHighlight { kind: MD_FENCE_MARKER })].into_iter();
|
|
}
|
|
|
|
if self.in_fenced_code {
|
|
return vec![(0..line.len(), SyntaxHighlight { kind: MD_CODE_BLOCK })].into_iter();
|
|
}
|
|
|
|
let md_spans = self.highlight_markdown(line);
|
|
if !md_spans.is_empty() {
|
|
return md_spans.into_iter();
|
|
}
|
|
} else if self.in_fenced_code {
|
|
self.in_fenced_code = false;
|
|
}
|
|
|
|
if ln >= self.line_offsets.len() {
|
|
return Vec::new().into_iter();
|
|
}
|
|
|
|
let line_start = self.line_offsets[ln];
|
|
let line_end = if ln + 1 < self.line_offsets.len() {
|
|
self.line_offsets[ln + 1] - 1
|
|
} else {
|
|
line_start + line.len()
|
|
};
|
|
|
|
let mut result = Vec::new();
|
|
for span in &self.spans {
|
|
if span.end <= line_start || span.start >= line_end {
|
|
continue;
|
|
}
|
|
let start = span.start.max(line_start) - line_start;
|
|
let end = span.end.min(line_end) - line_start;
|
|
if start < end {
|
|
result.push((start..end, SyntaxHighlight { kind: span.kind }));
|
|
}
|
|
}
|
|
result.into_iter()
|
|
}
|
|
|
|
fn current_line(&self) -> usize {
|
|
self.current_line
|
|
}
|
|
}
|
|
|
|
pub fn highlight_color(kind: u8) -> Color {
|
|
let p = palette::current();
|
|
match kind {
|
|
0 => p.mauve,
|
|
1 => p.blue,
|
|
2 => p.teal,
|
|
3 => p.yellow,
|
|
4 => p.yellow,
|
|
5 => p.teal,
|
|
6 => p.peach,
|
|
7 => p.peach,
|
|
8 => p.green,
|
|
9 => p.peach,
|
|
10 => p.overlay0,
|
|
11 => p.text,
|
|
12 => p.red,
|
|
13 => p.flamingo,
|
|
14 => p.sky,
|
|
15 => p.overlay2,
|
|
16 => p.overlay2,
|
|
17 => p.overlay2,
|
|
18 => p.blue,
|
|
19 => p.mauve,
|
|
20 => p.yellow,
|
|
21 => p.teal,
|
|
22 => p.red,
|
|
23 => p.text,
|
|
24 => p.green,
|
|
25 => p.maroon,
|
|
MD_HEADING_MARKER => p.overlay0,
|
|
MD_H1 => p.rosewater,
|
|
MD_H2 => p.peach,
|
|
MD_H3 => p.yellow,
|
|
MD_BOLD => p.peach,
|
|
MD_ITALIC => p.mauve,
|
|
MD_INLINE_CODE => p.green,
|
|
MD_FORMAT_MARKER => p.overlay0,
|
|
MD_LINK_TEXT => p.blue,
|
|
MD_LINK_URL => p.overlay1,
|
|
MD_BLOCKQUOTE_MARKER => p.overlay0,
|
|
MD_BLOCKQUOTE => p.sky,
|
|
MD_LIST_MARKER => p.sky,
|
|
MD_FENCE_MARKER => p.overlay0,
|
|
MD_CODE_BLOCK => p.text,
|
|
MD_HR => p.overlay1,
|
|
MD_TASK_OPEN => p.overlay2,
|
|
MD_TASK_DONE => p.green,
|
|
MD_BOLD_ITALIC => p.peach,
|
|
_ => p.text,
|
|
}
|
|
}
|
|
|
|
pub fn highlight_font(kind: u8) -> Option<Font> {
|
|
match kind {
|
|
MD_HEADING_MARKER => Some(Font { weight: Weight::Bold, ..Font::MONOSPACE }),
|
|
MD_H1 => Some(Font { weight: Weight::Black, ..Font::DEFAULT }),
|
|
MD_H2 => Some(Font { weight: Weight::Bold, ..Font::DEFAULT }),
|
|
MD_H3 => Some(Font { weight: Weight::Semibold, ..Font::DEFAULT }),
|
|
MD_BOLD => Some(Font { weight: Weight::Bold, ..Font::DEFAULT }),
|
|
MD_ITALIC => Some(Font { style: FontStyle::Italic, ..Font::DEFAULT }),
|
|
MD_BOLD_ITALIC => Some(Font { weight: Weight::Bold, style: FontStyle::Italic, ..Font::DEFAULT }),
|
|
MD_INLINE_CODE => Some(Font::MONOSPACE),
|
|
MD_FORMAT_MARKER => Some(Font::MONOSPACE),
|
|
MD_BLOCKQUOTE => Some(Font { style: FontStyle::Italic, ..Font::DEFAULT }),
|
|
MD_FENCE_MARKER => Some(Font::MONOSPACE),
|
|
MD_CODE_BLOCK => Some(Font::MONOSPACE),
|
|
MD_TASK_DONE => Some(Font { weight: Weight::Bold, ..Font::MONOSPACE }),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn compute_line_decors(source: &str) -> Vec<LineDecor> {
|
|
let classified = classify_document(source);
|
|
let line_kinds: Vec<LineKind> = classified.into_iter().map(|cl| cl.kind).collect();
|
|
let mut decors = Vec::new();
|
|
let mut in_fence = false;
|
|
for (i, raw_line) in source.split('\n').enumerate() {
|
|
let is_md = i < line_kinds.len() && line_kinds[i] == LineKind::Markdown;
|
|
if is_md {
|
|
let trimmed = raw_line.trim_start();
|
|
if trimmed.starts_with("```") {
|
|
in_fence = !in_fence;
|
|
decors.push(LineDecor::FenceMarker);
|
|
} else if in_fence {
|
|
decors.push(LineDecor::CodeBlock);
|
|
} else if is_horizontal_rule(trimmed) {
|
|
decors.push(LineDecor::HorizontalRule);
|
|
} else if trimmed.starts_with("> ") || trimmed == ">" {
|
|
decors.push(LineDecor::Blockquote);
|
|
} else {
|
|
decors.push(LineDecor::None);
|
|
}
|
|
} else {
|
|
if in_fence { in_fence = false; }
|
|
decors.push(LineDecor::None);
|
|
}
|
|
}
|
|
decors
|
|
}
|