1const ESC: char = '\u{1b}';
5const CSI: char = '\u{9b}';
6
7#[derive(Default)]
9pub struct Decoder {
10 pending: Vec<u8>,
11}
12
13impl Decoder {
14 pub fn decode(&mut self, data: &[u8], stream: bool) -> String {
15 self.pending.extend_from_slice(data);
16 let bytes = std::mem::take(&mut self.pending);
17 let mut out = String::new();
18 let mut rest = &bytes[..];
19 loop {
20 match std::str::from_utf8(rest) {
21 Ok(text) => {
22 out.push_str(text);
23 break;
24 }
25 Err(error) => {
26 let (valid, after) = rest.split_at(error.valid_up_to());
27 out.push_str(std::str::from_utf8(valid).unwrap_or_default());
28 match error.error_len() {
29 Some(len) => {
30 out.push('\u{fffd}');
31 rest = &after[len..];
32 }
33 None if stream => {
34 self.pending = after.to_vec();
35 break;
36 }
37 None => {
38 out.push('\u{fffd}');
39 break;
40 }
41 }
42 }
43 }
44 }
45 out
46 }
47}
48
49pub fn clean(text: &str) -> String {
51 strip_ansi(text)
52 .chars()
53 .filter(|&c| {
54 let code = c as u32;
55 !(code <= 0x1f && !matches!(code, 0x09 | 0x0a) || (0xfff9..=0xfffb).contains(&code))
56 })
57 .collect()
58}
59
60pub fn strip_ansi(text: &str) -> String {
61 if !text.contains(ESC) && !text.contains(CSI) {
62 return text.to_owned();
63 }
64 let chars: Vec<char> = text.chars().collect();
65 let mut out = String::with_capacity(text.len());
66 let mut i = 0;
67 while i < chars.len() {
68 match osc_end(&chars, i).or_else(|| csi_end(&chars, i)) {
69 Some(end) => i = end,
70 None => {
71 out.push(chars[i]);
72 i += 1;
73 }
74 }
75 }
76 out
77}
78
79fn osc_end(chars: &[char], i: usize) -> Option<usize> {
81 if chars.get(i) != Some(&ESC) || chars.get(i + 1) != Some(&']') {
82 return None;
83 }
84 let mut j = i + 2;
85 while j < chars.len() {
86 match chars[j] {
87 '\u{7}' | '\u{9c}' => return Some(j + 1),
88 ESC if chars.get(j + 1) == Some(&'\\') => return Some(j + 2),
89 _ => j += 1,
90 }
91 }
92 None
93}
94
95fn csi_end(chars: &[char], i: usize) -> Option<usize> {
97 if !matches!(chars.get(i), Some(&ESC) | Some(&CSI)) {
98 return None;
99 }
100 let start = i + 1;
101 let mut most = 0;
102 while chars.get(start + most).is_some_and(|c| "[]()#;?".contains(*c)) {
103 most += 1;
104 }
105 for intermediates in (0..=most).rev() {
106 let p = start + intermediates;
107 let mut ends = Vec::new();
108 param_ends(chars, p, &mut ends);
109 ends.push(p);
110 for end in ends {
111 if chars.get(end).is_some_and(|&c| is_final(c)) {
112 return Some(end + 1);
113 }
114 }
115 }
116 None
117}
118
119fn digits(chars: &[char], at: usize, max: usize) -> usize {
120 let mut n = 0;
121 while n < max && chars.get(at + n).is_some_and(char::is_ascii_digit) {
122 n += 1;
123 }
124 n
125}
126
127fn param_ends(chars: &[char], p: usize, ends: &mut Vec<usize>) {
129 for n in (1..=digits(chars, p, 4)).rev() {
130 separators(chars, p + n, ends);
131 }
132}
133
134fn separators(chars: &[char], at: usize, ends: &mut Vec<usize>) {
135 if chars.get(at).is_some_and(|&c| c == ';' || c == ':') {
136 for n in (0..=digits(chars, at + 1, 4)).rev() {
137 separators(chars, at + 1 + n, ends);
138 }
139 }
140 ends.push(at);
141}
142
143fn is_final(c: char) -> bool {
144 c.is_ascii_digit()
145 || ('A'..='P').contains(&c)
146 || ('R'..='T').contains(&c)
147 || c == 'Z'
148 || c == 'c'
149 || ('f'..='n').contains(&c)
150 || ('q'..='u').contains(&c)
151 || matches!(c, 'y' | '=' | '>' | '<' | '~')
152}
153
154pub const DEFAULT_MAX_BYTES: usize = 50 * 1024;
155pub const DEFAULT_MAX_LINES: usize = 2000;
156
157pub fn truncate_tail(content: &str) -> Option<String> {
159 let mut lines: Vec<&str> = if content.is_empty() {
160 Vec::new()
161 } else {
162 content.split('\n').collect()
163 };
164 if content.ends_with('\n') {
165 lines.pop();
166 }
167 if lines.len() <= DEFAULT_MAX_LINES && content.len() <= DEFAULT_MAX_BYTES {
168 return None;
169 }
170 let mut kept: Vec<String> = Vec::new();
171 let mut bytes = 0;
172 for line in lines.iter().rev() {
173 if kept.len() >= DEFAULT_MAX_LINES {
174 break;
175 }
176 let size = line.len() + usize::from(!kept.is_empty());
177 if bytes + size > DEFAULT_MAX_BYTES {
178 if kept.is_empty() {
179 kept.push(tail_bytes(line, DEFAULT_MAX_BYTES).to_owned());
180 }
181 break;
182 }
183 kept.push((*line).to_owned());
184 bytes += size;
185 }
186 kept.reverse();
187 Some(kept.join("\n"))
188}
189
190pub fn tail_bytes(text: &str, max: usize) -> &str {
192 if text.len() <= max {
193 return text;
194 }
195 let mut start = text.len() - max;
196 while !text.is_char_boundary(start) {
197 start += 1;
198 }
199 &text[start..]
200}