Fix: Correct offset for Unicode escape errors

This change corrects an error where the offset for a Unicode escape error was incorrectly adjusted. Previously, the offset was manually incremented by 2, causing errors for invalid escape sequences like `\uD83D` to report an incorrect position. The `handle_unicode_escape_from_slice` function already handles the offset correctly, so the manual adjustment was redundant and wrong. This fix removes the unnecessary offset adjustment, ensuring that error positions are now reported accurately.

Author: victor

.gitignore

@@ -1,2 +1,3 @@
 /target
-/todo
+/todo
+/src/stream.rs

CHANGELOG.md

@@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),  
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.3] - 2025-09-26
+
+### Fixed
+
+- **Corrected offset for Unicode escape errors.** Previously, an incorrect manual adjustment of `+2` was applied to the error offset, causing invalid escape sequences like `\uD83D` to report the wrong position. This change removes the redundant adjustment, ensuring error positions are now reported accurately.
+
 ## [0.1.2] - 2025-09-25
 
 ### Added

Cargo.toml

@@ -19,6 +19,7 @@ keywords = [
 exclude = [
     "/.github",
     "/benches",
+    "/src/stream.rs",
 ]
 
 [dependencies]

src/explicit.rs

@@ -419,9 +419,9 @@ impl<'a> Iterator for Unescape<'a> {
                 // that it can advance.
                 match crate::Unescape::handle_unicode_escape_from_slice(&mut remainder) {
                     Ok(c) => c,
-                    Err(mut e) => {
+                    Err(e) => {
+                        // FIX: handle_unicode_escape_from_slice already handles this for us.
                         // Adjust offset: error is relative to `\u`, but we need it relative to chunk start.
-                        e.offset += 2; // for `\u`
                         return Some(Err(e));
                     }
                 }
@@ -533,6 +533,12 @@ impl<'a> Unescape<'a> {
             lossy: true,
         }
     }
+
+    // TODO: Doc
+    #[inline]
+    pub(crate) const fn remnant(&self) -> &[u8] {
+        self.bytes
+    }
 }
 
 impl fmt::Debug for Unescape<'_> {

src/lib.rs

@@ -85,6 +85,7 @@ use core::{
 use memchr::memchr;
 
 pub mod explicit;
+pub mod stream;
 
 // =============================================================================
 // Escape Implementation
@@ -555,6 +556,7 @@ impl<'a> Unescape<'a> {
         }
     }
 
+    // FIXME: Replace iter with slice and match on b with a table
     /// Helper: parse exactly 4 hex digits from `it`. Returns Ok(u16) or an error.
     #[inline(always)]
     fn parse_hex4(iter: &mut slice::Iter<'a, u8>, base_offset: u8) -> Result<u16, UnescapeError> {
@@ -1788,6 +1790,13 @@ mod tests {
         let got = escape_str(input).collect::<String>();
         assert_eq!(got, want);
 
+        // Test PartialEq too
+        assert_eq!(escape_str(input), want);
+
+        // FIXME: Once logic is unified, remove this.
+        let got = explicit::escape_str(input).collect::<String>();
+        assert_eq!(got, want);
+
         // Test PartialEq too
         assert_eq!(escape_str(input), want)
     }
@@ -1880,6 +1889,16 @@ mod tests {
 
         // Help display
         assert_display(unescape(input).display_utf8(), Ok(want));
+
+        // FIXME: Once logic is unified, remove this.
+        let got = explicit::unescape(input).decode_utf8().unwrap();
+        assert_eq!(got, want);
+
+        // Test PartialEq too
+        assert_eq!(explicit::unescape(input), want);
+
+        // Help display
+        assert_display(explicit::unescape(input).display_utf8(), Ok(want));
     }
 
     #[test]
@@ -1914,6 +1933,17 @@ mod tests {
             })) => {}
             _ => panic!("expected invalid escape"),
         }
+
+        // FIXME: Once logic is unified, remove this.
+        let mut u = explicit::unescape(s);
+
+        match u.next() {
+            Some(Err(UnescapeError {
+                kind: UnescapeErrorKind::InvalidEscape(InvalidEscapeError { found: b'x' }),
+                offset: 1,
+            })) => {}
+            _ => panic!("expected invalid escape"),
+        }
     }
 
     #[test]
@@ -1941,6 +1971,15 @@ mod tests {
             }
         }
         assert!(found);
+
+        // FIXME: Once logic is unified, remove this.
+        assert_eq!(
+            explicit::unescape(input).next(),
+            Some(Err(UnescapeError {
+                kind: UnescapeErrorKind::UnexpectedEof,
+                offset: 4,
+            }))
+        );
     }
 
     // ===================== Chunk_Eq ===================== //