Speed-up HTML escaping a bit using bit tests

```text
$ cargo bench --bench escape
Escaping                time:   [3.2732 µs 3.2803 µs 3.2882 µs]
                        change: [-7.0453% -6.7529% -6.4625%] (p = 0.00 < 0.05)
                        Performance has improved.

```

Author: Kijewski

rinja/src/html.rs

@@ -1,25 +1,39 @@
-use std::fmt;
-use std::num::NonZeroU8;
+use std::{fmt, str};
 
 #[allow(unused)]
-pub(crate) fn write_escaped_str(mut fmt: impl fmt::Write, string: &str) -> fmt::Result {
-    let mut escaped_buf = *b"&#__;";
-    let mut last = 0;
+pub(crate) fn write_escaped_str(mut fmt: impl fmt::Write, mut string: &str) -> fmt::Result {
+    let mut escaped_buf = *b"&#__;\0\0\0";
+    'outer: while !string.is_empty() {
+        for (index, byte) in string.bytes().enumerate() {
+            if !(MIN_CHAR..=MAX_CHAR).contains(&byte) || (BITS & (1 << (byte - MIN_CHAR))) == 0 {
+                continue;
+            }
 
-    for (index, byte) in string.bytes().enumerate() {
-        let escaped = match byte {
-            MIN_CHAR..=MAX_CHAR => TABLE.lookup[(byte - MIN_CHAR) as usize],
-            _ => None,
-        };
-        if let Some(escaped) = escaped {
-            escaped_buf[2] = escaped[0].get();
-            escaped_buf[3] = escaped[1].get();
-            fmt.write_str(&string[last..index])?;
-            fmt.write_str(unsafe { std::str::from_utf8_unchecked(escaped_buf.as_slice()) })?;
-            last = index + 1;
+            [escaped_buf[2], escaped_buf[3]] = TABLE.lookup[(byte - MIN_CHAR) as usize];
+
+            if index > 0 {
+                // SAFETY: We know that the current index cannot exceed the string's length,
+                // and that it is on a char boundary, because `string[i].is_ascii()`.
+                fmt.write_str(unsafe { string.get_unchecked(..index) })?;
+            }
+
+            // SAFETY: We know that `escaped_buf` contains ASCII data.
+            fmt.write_str(unsafe { str::from_utf8_unchecked(&escaped_buf[..5]) })?;
+
+            if index + 1 == string.len() {
+                break 'outer;
+            }
+            // SAFETY: We just checked that the new length is inside the string's bounds.
+            string = unsafe { string.get_unchecked(index + 1..) };
+
+            continue 'outer;
         }
+        if !string.is_empty() {
+            fmt.write_str(string)?;
+        }
+        break;
     }
-    fmt.write_str(&string[last..])
+    Ok(())
 }
 
 #[allow(unused)]
@@ -34,38 +48,53 @@ pub(crate) fn write_escaped_char(mut fmt: impl fmt::Write, c: char) -> fmt::Resu
     })
 }
 
-const MIN_CHAR: u8 = b'"';
-const MAX_CHAR: u8 = b'>';
+const CHARS: &[u8] = b"\"&\'<>";
+
+const MIN_MAX_CHAR: (u8, u8) = {
+    let mut min = 0xff;
+    let mut max = 0x00;
+    let mut i = 0;
+    while i < CHARS.len() {
+        if CHARS[i] < min {
+            min = CHARS[i];
+        }
+        if CHARS[i] > max {
+            max = CHARS[i];
+        }
+        i += 1;
+    }
+    assert!(max - min < 32);
+    (min, max)
+};
+const MIN_CHAR: u8 = MIN_MAX_CHAR.0;
+const MAX_CHAR: u8 = MIN_MAX_CHAR.1;
 
 struct Table {
     _align: [usize; 0],
-    lookup: [Option<[NonZeroU8; 2]>; (MAX_CHAR - MIN_CHAR + 1) as usize],
+    lookup: [[u8; 2]; (MAX_CHAR - MIN_CHAR + 1) as usize],
 }
 
-const TABLE: Table = {
-    const fn n(c: u8) -> Option<[NonZeroU8; 2]> {
-        assert!(MIN_CHAR <= c && c <= MAX_CHAR);
-
-        let n0 = match NonZeroU8::new(c / 10 + b'0') {
-            Some(n) => n,
-            None => panic!(),
-        };
-        let n1 = match NonZeroU8::new(c % 10 + b'0') {
-            Some(n) => n,
-            None => panic!(),
-        };
-        Some([n0, n1])
+const BITS: u32 = {
+    let mut bits = 0u32;
+    let mut i = 0;
+    while i < CHARS.len() {
+        bits |= 1 << (CHARS[i] - MIN_CHAR);
+        i += 1;
     }
+    bits
+};
 
+const TABLE: Table = {
     let mut table = Table {
         _align: [],
-        lookup: [None; (MAX_CHAR - MIN_CHAR + 1) as usize],
+        lookup: [[0; 2]; (MAX_CHAR - MIN_CHAR + 1) as usize],
     };
-
-    table.lookup[(b'"' - MIN_CHAR) as usize] = n(b'"');
-    table.lookup[(b'&' - MIN_CHAR) as usize] = n(b'&');
-    table.lookup[(b'\'' - MIN_CHAR) as usize] = n(b'\'');
-    table.lookup[(b'<' - MIN_CHAR) as usize] = n(b'<');
-    table.lookup[(b'>' - MIN_CHAR) as usize] = n(b'>');
+    let mut i = 0;
+    while i < CHARS.len() {
+        let h = CHARS[i] / 10 + b'0';
+        let l = CHARS[i] % 10 + b'0';
+        table.lookup[(CHARS[i] - MIN_CHAR) as usize] = [h, l];
+        i += 1;
+    }
     table
 };