katex-wasm 的 coding agent 自动性能优化#

1
fn fetch_ref(&mut self) -> &Token {
2
    if self.next_token.is_none() {
3
        let token = self.gullet.expand_next_token();
4
        if self.error.is_none() {
5
            if let Some(err) = self.gullet.take_error() {
6
                self.error = Some(err);
7
            }
8
        }
9
        self.next_token = Some(token);
10
    }
11
    return self.next_token.as_ref().unwrap();
12
}

1
let nucleus = self.next_token.take().unwrap();
2
let loc = nucleus.loc;
3
let text = nucleus.text;

1
thread_local! {
2
    static BUILTIN_MACROS: crate::Namespace::Builtins<MacroDefinition> =
3
        prepare_builtins();
4
}

1
Namespace::<MacroDefinition>::new(
2
    BUILTIN_MACROS.with(std::sync::Arc::clone),
3
    settings.get_ref_macros(),
4
)

1
// 节选：注释诊断依赖当前设置，留在运行时处理。
2
if body.contains('%') { continue; }

1
SmallVec<[(u8, Option<String>); 1]>

1
fn value_mut(&mut self, key: u8) -> &mut Option<String> {
2
    let index = match self.values.binary_search_by_key(&key, |entry| entry.0) {
3
        Ok(index) => index,
4
        Err(index) => {
5
            self.values.insert(index, (key, None));
6
            index
7
        }
8
    };
9
    &mut self.values[index].1
10
}

1
impl PartialEq for CssStyle {
2
    fn eq(&self, other: &Self) -> bool {
3
        self.values
4
            .iter()
5
            .filter_map(|(key, value)| value.as_ref().map(|value| (key, value)))
6
            .eq(other
7
                .values
8
                .iter()
9
                .filter_map(|(key, value)| value.as_ref().map(|value| (key, value))))
10
    }
11
}

1
// 原先的逐字符写法：临时 String 随即被复制并释放。
2
out.push_str(&c.to_string());

1
pub fn escape_to(out: &mut String, text: &str) {
2
    let mut start = 0;
3
    for (i, byte) in text.bytes().enumerate() {
4
        let replacement = match byte {
5
            b'&' => "&",
6
            b'>' => ">",
7
            b'<' => "&lt;",
8
            b'"' => "&quot;",
9
            b'\'' => "&#x27;",
10
            _ => continue,
11
        };
12
        // ASCII delimiter offsets are always valid UTF-8 boundaries.
13
        out.push_str(&text[start..i]);
14
        out.push_str(replacement);
15
        start = i + 1;
16
    }
17
    out.push_str(&text[start..]);
18
}

1
pub fn make_em(n: f64) -> String {
2
    let scaled = n.abs() * 10000.0;
3
    // Stay within exact integer precision, and defer halfway cases to Rust's
4
    // correctly rounded formatter. This preserves the previous four digits.
5
    if !n.is_finite() || scaled >= 1e12 || (scaled.fract() - 0.5).abs() <= scaled * f64::EPSILON * 2.0 {
6
        return format!("{:.4}em", n);
7
    }
8
    let rounded = scaled.round() as u64;
9
    let mut output = String::with_capacity(24);
10
    if n.is_sign_negative() && rounded != 0 { output.push('-'); }
11
    let mut digits = itoa::Buffer::new();
12
    output.push_str(digits.format(rounded / 10000));
13
    let fraction = (rounded % 10000) as u32;
14
    if fraction != 0 {
15
        output.push('.');
16
        output.push(char::from_digit(fraction / 1000, 10).unwrap());
17
        output.push(char::from_digit(fraction / 100 % 10, 10).unwrap());
18
        output.push(char::from_digit(fraction / 10 % 10, 10).unwrap());
19
        output.push(char::from_digit(fraction % 10, 10).unwrap());
20
        while output.ends_with('0') { output.pop(); }
21
    }
22
    output.push_str("em");
23
    output
24
}

1
// Time every input. Matching error outputs/exceptions are valid parity cases.
2
const common = formulas.map((_, i) => i);

1
function batch(engine, measured) {
2
  const values = [];
3
  const start = performance.now();
4
  for (const i of common) {
5
    const t = performance.now();
6
    try {
7
      const html = engine.render(formulas[i], { ...settings });
8
      checksum = (checksum + html.length) >>> 0;
9
    } catch (error) {
10
      checksum = (checksum + String(error).length) >>> 0;
11
    }
12
    if (measured) values.push(performance.now() - t);
13
  }
14
  const total = performance.now() - start;
15
  if (measured) samples[engine.id].push(...values);
16
  return total;
17
}