perf: inline \u hex parsing and span-based number parsing in JSON parser

- \uXXXX escapes now index directly into the source string instead of
  calling Substring(i+2, 4), saving one string allocation per unicode
  escape encountered while parsing JSON strings.
- \U case: replace s.[0..1] slice comparison (which allocates a string)
  with direct char comparisons s.[0] <> '0' || s.[1] <> '0'.
- parseNum: on net8.0, use Decimal.TryParse(span) / Double.TryParse(span)
  instead of Substring to avoid one string allocation per number token.
  The netstandard2.0 path is unchanged (span overloads not available).

Bumps version to 8.1.8.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

RELEASE_NOTES.md

@@ -1,5 +1,9 @@
 # Release Notes
 
+## 8.1.8 - Apr 13 2026
+
+- Performance: JSON parser avoids one `Substring` allocation per `\uXXXX` escape by directly indexing into the source string; also uses span-based `Decimal.TryParse`/`Double.TryParse` for number tokens on .NET 8 to avoid a `Substring` allocation per number
+
 ## 8.1.7 - Apr 7 2026
 
 - Performance: HTML parser avoids `ToCharArray()` allocations in several code paths: `EmitToAttributeValue` now iterates the substituted string directly; `Cons(char[])` and `Cons(string)` use `StringBuilder.Append` directly; `Pop(count)` uses `Array.init` instead of creating an integer range array; CDATA opening marker no longer creates a temporary `char[]`.

src/FSharp.Data.Json.Core/JsonValue.fs

@@ -349,24 +349,21 @@ type private JsonParser(jsonText: string) =
                 | 'u' ->
                     ensure (i + 5 < s.Length)
 
-                    let hexdigit d =
+                    let inline hexdigit (d: char) =
                         if d >= '0' && d <= '9' then int32 d - int32 '0'
                         elif d >= 'a' && d <= 'f' then int32 d - int32 'a' + 10
                         elif d >= 'A' && d <= 'F' then int32 d - int32 'A' + 10
                         else failwith "hexdigit"
 
-                    let unicodeChar (s: string) =
-                        if s.Length <> 4 then
-                            failwith "unicodeChar"
-
+                    // Direct indexing avoids a Substring allocation per \uXXXX escape.
+                    let ch =
                         char (
-                            hexdigit s.[0] * 4096
-                            + hexdigit s.[1] * 256
-                            + hexdigit s.[2] * 16
-                            + hexdigit s.[3]
+                            hexdigit s.[i + 2] * 4096
+                            + hexdigit s.[i + 3] * 256
+                            + hexdigit s.[i + 4] * 16
+                            + hexdigit s.[i + 5]
                         )
 
-                    let ch = unicodeChar (s.Substring(i + 2, 4))
                     buf.Append(ch) |> ignore
                     i <- i + 4 // the \ and u will also be skipped past further below
                 | 'U' ->
@@ -376,7 +373,7 @@ type private JsonParser(jsonText: string) =
                         if s.Length <> 8 then
                             failwithf "unicodeChar (%O)" s
 
-                        if s.[0..1] <> "00" then
+                        if s.[0] <> '0' || s.[1] <> '0' then
                             failwithf "unicodeChar (%O)" s
 
                         UnicodeHelper.getUnicodeSurrogatePair
@@ -408,6 +405,7 @@ type private JsonParser(jsonText: string) =
             i <- i + 1
 
         let len = i - start
+#if NETSTANDARD2_0
         let sub = s.Substring(start, len)
 
         match TextConversions.AsDecimal CultureInfo.InvariantCulture sub with
@@ -416,6 +414,17 @@ type private JsonParser(jsonText: string) =
             match TextConversions.AsFloat [||] false CultureInfo.InvariantCulture sub with
             | Some x -> JsonValue.Float x
             | _ -> throw ()
+#else
+        // Span-based parsing avoids a Substring allocation per number token.
+        let span = s.AsSpan(start, len)
+
+        match Decimal.TryParse(span, NumberStyles.Currency, CultureInfo.InvariantCulture) with
+        | true, x -> JsonValue.Number x
+        | false, _ ->
+            match Double.TryParse(span, NumberStyles.Any, CultureInfo.InvariantCulture) with
+            | true, x -> JsonValue.Float x
+            | false, _ -> throw ()
+#endif
 
     and parsePair cont =
         let key = parseString ()