Don't count negative sign towards the integer digit limit

crates/jiter/src/number_decoder.rs

@@ -11,6 +11,8 @@ use lexical_parse_float::{FromLexicalWithOptions, Options as ParseFloatOptions,
 
 use crate::errors::{JsonError, JsonResult, json_err, json_error};
 
+const MAX_INT_DIGITS: usize = 4300;
+
 pub trait AbstractNumberDecoder: Sized {
     fn decode(data: &[u8], index: usize, first: u8, allow_inf_nan: bool) -> JsonResult<(Self, usize)>;
 }
@@ -304,8 +306,10 @@ impl IntParse {
 
             loop {
                 let (chunk, new_index) = IntChunk::parse_big(data, index);
-                if (new_index - start) > 4300 {
-                    return json_err!(NumberOutOfRange, start + 4301);
+                let consumed_len = new_index - start;
+                if consumed_len > MAX_INT_DIGITS && (positive || consumed_len > MAX_INT_DIGITS + 1) {
+                    let error_index = start + MAX_INT_DIGITS + if positive { 1 } else { 2 };
+                    return json_err!(NumberOutOfRange, error_index);
                 }
                 match chunk {
                     IntChunk::Ongoing(value) => {
@@ -489,8 +493,10 @@ impl AbstractNumberDecoder for NumberRange {
         }
         loop {
             let (chunk, new_index) = IntChunk::parse_big(data, index);
-            if (new_index - start) > 4300 {
-                return json_err!(NumberOutOfRange, start + 4301);
+            let consumed_len = new_index - start;
+            if consumed_len > MAX_INT_DIGITS && (positive || consumed_len > MAX_INT_DIGITS + 1) {
+                let error_index = start + MAX_INT_DIGITS + if positive { 1 } else { 2 };
+                return json_err!(NumberOutOfRange, error_index);
             }
             #[allow(clippy::single_match_else)]
             match chunk {

crates/jiter/src/parse.rs

@@ -52,11 +52,11 @@ impl Peek {
     }
 }
 
-static TRUE_REST: [u8; 3] = [b'r', b'u', b'e'];
-static FALSE_REST: [u8; 4] = [b'a', b'l', b's', b'e'];
-static NULL_REST: [u8; 3] = [b'u', b'l', b'l'];
-static NAN_REST: [u8; 2] = [b'a', b'N'];
-static INFINITY_REST: [u8; 7] = [b'n', b'f', b'i', b'n', b'i', b't', b'y'];
+static TRUE_REST: [u8; 3] = *b"rue";
+static FALSE_REST: [u8; 4] = *b"alse";
+static NULL_REST: [u8; 3] = *b"ull";
+static NAN_REST: [u8; 2] = *b"aN";
+static INFINITY_REST: [u8; 7] = *b"nfinity";
 
 #[derive(Debug, Clone)]
 pub(crate) struct Parser<'j> {

crates/jiter/tests/main.rs

@@ -1009,17 +1009,36 @@ number_bytes! {
 
 #[cfg(feature = "num-bigint")]
 #[test]
-fn test_4300_int() {
-    let json = (0..4300).map(|_| "9".to_string()).collect::<String>();
-    let bytes = json.as_bytes();
-    let value = JsonValue::parse(bytes, false).unwrap();
-    let expected_big_int = BigInt::from_str(&json).unwrap();
-    match value {
-        JsonValue::BigInt(v) => {
-            assert_eq!(v, expected_big_int);
+fn test_int_digit_limit() {
+    for sign in ["", "-"] {
+        let json = format!("{sign}{}", "9".repeat(4300));
+        let bytes = json.as_bytes();
+        let value = JsonValue::parse(bytes, false).unwrap();
+        let expected_big_int = BigInt::from_str(&json).unwrap();
+        match value {
+            JsonValue::BigInt(v) => {
+                assert_eq!(v, expected_big_int);
+            }
+            _ => panic!("expected big int, got {value:?}"),
         }
-        _ => panic!("expected array, got {value:?}"),
+
+        let mut jiter = Jiter::new(bytes);
+        assert_eq!(jiter.next_number_bytes().unwrap(), bytes);
+        jiter.finish().unwrap();
     }
+
+    let rejected = format!("-{}", "9".repeat(4301));
+    let error = JsonValue::parse(rejected.as_bytes(), false).unwrap_err();
+    assert_eq!(error.error_type, JsonErrorType::NumberOutOfRange);
+    assert_eq!(error.index, 4302);
+
+    let mut jiter = Jiter::new(rejected.as_bytes());
+    let error = jiter.next_number_bytes().unwrap_err();
+    assert_eq!(
+        error.error_type,
+        JiterErrorType::JsonError(JsonErrorType::NumberOutOfRange)
+    );
+    assert_eq!(error.index, 4302);
 }
 
 #[cfg(feature = "num-bigint")]