json-as 1.2.6 → 1.3.1

package/README.md

@@ -14,6 +14,7 @@
   - [Using Raw JSON Strings](#using-raw-json-strings)
   - [Working with Enums](#working-with-enums)
   - [Using Custom Serializers or Deserializers](#using-custom-serializers-or-deserializers)
+  - [Overriding built-in Container Types](#overriding-built-in-container-types)
 - [Performance](#performance)
   - [Comparison to JavaScript](#comparison-to-javascript)
   - [Performance Tuning](#performance-tuning)
@@ -36,7 +37,7 @@ npm install json-as
 Add the `--transform` to your `asc` command (e.g. in package.json)
 
 ```bash
---transform json-as/transform
+--transform json-as
 ```
 
 Optionally, for additional performance, also add:
@@ -50,7 +51,7 @@ Alternatively, add it to your `asconfig.json`
 ```typescript
 {
   "options": {
-    "transform": ["json-as/transform"]
+    "transform": ["json-as"]
   }
 }
 ```
@@ -334,11 +335,11 @@ const serialized = JSON.stringify<Foo>(Foo.bar);
 
 This library supports custom serialization and deserialization methods, which can be defined using the `@serializer` and `@deserializer` decorators.
 
-Here's an example of creating a custom data type called `Point` which serializes to `(x,y)`
+Custom serializers and deserializers must always speak valid JSON. You can optionally provide the JSON value shape they operate on using one of: `"any"`, `"string"`, `"number"`, `"object"`, `"array"`, `"boolean"`, or `"null"`. If omitted, the shape defaults to `"any"`.
 
-```typescript
-import { bytes } from "json-as/assembly/util";
+Here's an example of creating a custom data type called `Point` which serializes to a JSON string:
 
+```typescript
 @json
 class Point {
   x: f64 = 0.0;
@@ -348,21 +349,21 @@ class Point {
     this.y = y;
   }
 
-  @serializer
+  @serializer("string")
   serializer(self: Point): string {
-    return `(${self.x},${self.y})`;
+    return JSON.stringify(`${self.x},${self.y}`);
   }
 
-  @deserializer
+  @deserializer("string")
   deserializer(data: string): Point {
-    const dataSize = bytes(data);
-    if (dataSize <= 2) throw new Error("Could not deserialize provided data as type Point");
+    const raw = JSON.parse<string>(data);
+    if (!raw.length) throw new Error("Could not deserialize provided data as type Point");
 
-    const c = data.indexOf(",");
-    const x = data.slice(1, c);
-    const y = data.slice(c + 1, data.length - 1);
+    const c = raw.indexOf(",");
+    const x = raw.slice(0, c);
+    const y = raw.slice(c + 1);
 
-    return new Point(f64.parse(x), f64.parse(y));
+    return new Point(f64.parse(x), f64.parse(y)); // NEVER use this in deserializers. Always return a new instance
   }
 }
 
@@ -375,9 +376,11 @@ console.log("Serialized    " + serialized);
 console.log("Deserialized  " + JSON.stringify(deserialized));
 ```
 
-The serializer function converts a `Point` instance into a string format `(x,y)`.
+The serializer function converts a `Point` instance into a valid JSON string value.
+
+The deserializer function parses that JSON string back into a `Point` instance.
 
-The deserializer function parses the string `(x,y)` back into a `Point` instance.
+Custom deserializers should always instantiate and return a new object. They should not assume an existing destination instance will be passed in or reused.
 
 These functions are then wrapped before being consumed by the json-as library:
 
@@ -396,19 +399,98 @@ These functions are then wrapped before being consumed by the json-as library:
 
 This allows custom serialization while maintaining a generic interface for the library to access.
 
-## Performance
+### Overriding built-in container types
 
-The `json-as` library is engineered for **multi-GB/s processing speeds**, leveraging SIMD and SWAR optimizations along with highly efficient transformations. The charts below highlight key performance metrics such as build time, operations-per-second, and throughput.
+Undecorated subclasses of built-in container types keep the built-in JSON behavior.
+
+This rule applies consistently across:
+
+- `JSON.stringify(...)`
+- `JSON.parse<T>(...)`
+- `JSON.Value.from(...)`
+- `JSON.internal.stringify(...)`
+- `JSON.internal.parse(...)`
+
+For example:
+
+- `class MyBytes extends Uint8Array {}` still serializes like a normal `Uint8Array`
+- `class MyMap extends Map<string, i32> {}` still serializes like a normal `Map<string, i32>`
+- the same applies to subclassable built-ins such as `Array`, `Set`, and typed arrays
+
+If you decorate that subclass with `@json`, it is treated as a normal generated class instead of inheriting the built-in container behavior. That means generated `__SERIALIZE` / `__DESERIALIZE` logic and custom serializer/deserializer hooks can take over.
+
+If you want a different wire format, decorate the subclass with `@json` and provide custom `@serializer(...)` / `@deserializer(...)` methods:
+
+```typescript
+function hexDigit(value: u8): string {
+  return String.fromCharCode(value < 10 ? 48 + value : 87 + value);
+}
+
+function parseHexNibble(code: u16): u8 {
+  if (code >= 48 && code <= 57) return <u8>(code - 48);
+  if (code >= 97 && code <= 102) return <u8>(code - 87);
+  return <u8>(code - 55);
+}
+
+@json
+class HexBytes extends Uint8Array {
+  constructor(length: i32 = 0) {
+    super(length);
+  }
+
+  @serializer("string")
+  serializer(self: HexBytes): string {
+    let out = "";
+    for (let i = 0; i < self.length; i++) {
+      const value = unchecked(self[i]);
+      out += hexDigit(value >> 4);
+      out += hexDigit(value & 0x0f);
+    }
+    return JSON.stringify(out);
+  }
+
+  @deserializer("string")
+  deserializer(data: string): HexBytes {
+    const raw = JSON.parse<string>(data);
+    const out = new HexBytes(raw.length >> 1);
+
+    for (let i = 0, j = 0; i < raw.length; i += 2, j++) {
+      const hi = parseHexNibble(<u16>raw.charCodeAt(i));
+      const lo = parseHexNibble(<u16>raw.charCodeAt(i + 1));
+      unchecked((out[j] = <u8>((hi << 4) | lo)));
+    }
 
-You can **re-run the benchmarks** at any time by clicking the button below. After the workflow completes, refresh this page to view updated results.  
+    return out;
+  }
+}
+
+const bytes = new HexBytes(4);
+bytes[0] = 10;
+bytes[1] = 20;
+bytes[2] = 30;
+bytes[3] = 40;
+
+JSON.stringify(bytes);      // "\"0a141e28\""
+JSON.parse<HexBytes>("\"0a141e28\"");
+```
+
+This same pattern works for subclassable built-ins like `Array`, `Map`, `Set`, and typed arrays.
 
-[![Run Benchmarks](https://img.shields.io/badge/Run_Benchmark-blue)](https://github.com/JairusSW/json-as/actions/workflows/benchmark.yml)
+`ArrayBuffer` and `String` are `@final` in AssemblyScript, so they cannot be subclassed there.
+
+## Performance
+
+The `json-as` library is engineered for **multi-GB/s processing speeds**, leveraging SIMD and SWAR optimizations along with highly efficient transformations. The charts below highlight key performance metrics such as build time, operations-per-second, and throughput.
 
 ### Comparison to JavaScript
 
-The following charts compare JSON-AS (both SWAR and SIMD variants) against JavaScript's native `JSON` implementation. Benchmarks were conducted in a GitHub Actions environment. On modern hardware, you may see even higher throughput.
+The following charts compare JSON-AS (both SWAR and SIMD variants) against JavaScript's native `JSON` implementation. The published charts are generated locally and pushed to the `docs` branch.
 
 > Note: Benchmarks reflect the **latest version**. Older versions may show different performance.
+>
+> Current local benchmark machine: AMD Ryzen 7 7800X3D (8 cores, 8 threads), 96 MB L3 cache, 32 GB RAM.
+>
+> Benchmark results include normal end-to-end work such as allocating the destination object or array before deserializing into it. Raw parser throughput is higher than the published figures because these numbers intentionally include that allocation/setup cost.
 
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart01.svg" alt="Performance Chart 1">
 
@@ -418,9 +500,9 @@ The following charts compare JSON-AS (both SWAR and SIMD variants) against JavaS
 
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart04.png" alt="Performance Chart 4">
 
-> Note: I have focused on extensively optimizing serialization. I used to have deserialization be highly unsafe and extremely fast, but I've since doubled down on safety for deserialization which has negatively affected performance. I will be optimizing soon.
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart05.png" alt="Performance Chart 5">
 
-> Note on Token: I am currently working on optimizing the token deserialization process. This reflects the *future* performance of this library.
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart06.png" alt="Performance Chart 6">
 
 ### Performance Tuning
 
@@ -433,46 +515,63 @@ Here's a short list:
 
 **JSON_MODE** (default: SWAR) - Selects which mode should be used. Can be `NAIVE,SWAR,SIMD`. Note that `--enable simd` may be required.
 
+**JSON_USE_FAST_PATH** (default: 0) - When set to `1`, the transform emits the fast `__DESERIALIZE` implementation for generated structs. When unset or `0`, it emits only the slow path.
+
 **JSON_WRITE** (default: "") - Select a series of files to output after transform and optimization passes have completed for easy inspection. Usage: `JSON_WRITE=.path-to-file-a.ts,./path-to-file-b.ts`
 
-### Running benchmarks locally
+### Running Benchmarks Locally
 
-Benchmarks are run directly on top of v8 for more tailored control
+Benchmarks are run directly on top of `v8` for tighter control over the engine configuration.
 
-1. Download JSVU off of npm
+1. Install the local benchmark prerequisites:
 
 ```bash
-npm install jsvu -g
+npm install -g jsvu
+jsvu --engines=v8
 ```
 
-2. Modify your dotfiles to add `~/.jsvu/bin` to `PATH`
+2. Add `~/.jsvu/bin` to your `PATH` and make sure `wasm-opt` is installed:
 
 ```bash
 export PATH="${HOME}/.jsvu/bin:${PATH}"
+sudo apt-get install -y binaryen
 ```
 
-3. Clone the repository
+3. Install project dependencies:
 
 ```bash
-git clone https://github.com/JairusSW/json-as
+npm install
 ```
 
-4. Install dependencies
+4. Run either benchmark suite directly:
 
 ```bash
-npm i
+./run-bench.as.sh
+./run-bench.js.sh
 ```
 
-5. Run benchmarks for either AssemblyScript or JavaScript
+5. Build charts from the latest local logs:
 
 ```bash
-./run-bench.as.sh
+./build-charts.sh
 ```
 
-or
+6. Publish benchmark charts to the `docs` branch:
 
 ```bash
-./run-bench.js.sh
+./publish-benchmarks.sh
+```
+
+If you already have fresh logs and only want to rebuild charts and push them:
+
+```bash
+./publish-benchmarks.sh --no-run
+```
+
+Or run the full local publish flow in one step:
+
+```bash
+npm run bench:publish
 ```
 
 ## Debugging

package/assembly/custom/util.ts

@@ -15,11 +15,7 @@
  * @param str - Any number. Can include scientific notation.
  */
 // @ts-ignore: Decorator
-@inline export function snip_fast<T extends number>(
-  str: string,
-  len: u32 = 0,
-  offset: u32 = 0,
-): T {
+@inline export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u32 = 0): T {
   if (isSigned<T>()) {
     const firstChar: u32 = load<u16>(changetype<usize>(str));
     if (firstChar == 48) return 0 as T;
@@ -39,31 +35,19 @@
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return -(
-                val /
-                10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)
-              ) as T;
+              return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(
-                val *
-                10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)
-              ) as T;
+              return -(val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
             }
           } else if (high > 57) {
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return -(
-                val /
-                10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)
-              ) as T;
+              return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(
-                val *
-                10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)
-              ) as T;
+              return -(val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
             }
           } else {
             val = (val * 100 + (low - 48) * 10 + (high - 48)) as T;
@@ -78,16 +62,10 @@
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return -(
-              val /
-              10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)
-            ) as T;
+            return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return -(
-              val *
-              10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)
-            ) as T;
+            return -(val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
         } else {
           val = (val * 10 + (ch - 48)) as T;
@@ -106,21 +84,17 @@
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return (val /
-                10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+              return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val *
-                10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
+              return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
             }
           } else if (high > 57) {
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return (val /
-                10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+              return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val *
-                10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
+              return (val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
             }
           } else {
             // Optimized with multiplications and shifts.
@@ -135,12 +109,10 @@
         // e is 101 and E is 69.
         if (ch > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            val = (val /
-              10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+            val = (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            val = (val *
-              10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
+            val = (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
           return val as T;
         } else {
@@ -165,21 +137,17 @@
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return (val /
-              10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+            return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val *
-              10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
+            return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
         } else if (high > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-            return (val /
-              10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+            return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val *
-              10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
+            return (val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
           }
         } else {
           // Optimized with multiplications and shifts.
@@ -194,12 +162,10 @@
       // e is 101 and E is 69.
       if (ch > 57) {
         if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-          return (val /
-            10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+          return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
         } else {
           // Inlined this operation instead of using a loop
-          return (val *
-            10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
+          return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
         }
       } else {
         val = (val * 10 + (ch - 48)) as T;
@@ -214,11 +180,7 @@
  */
 
 // @ts-ignore
-@inline export function __atoi_fast<T extends number>(
-  str: string,
-  start: u32 = 0,
-  end: u32 = 0,
-): T {
+@inline export function __atoi_fast<T extends number>(str: string, start: u32 = 0, end: u32 = 0): T {
   // @ts-ignore
   let val: T = 0;
   if (!end) end = start + u32(str.length << 1);
@@ -227,21 +189,18 @@
     if (load<u16>(changetype<usize>(str) + <usize>start) == 45) {
       start += 2;
       for (; start < end; start += 2) {
-        val = (val * 10 +
-          (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+        val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
       }
       return -val as T;
     } else {
       for (; start < end; start += 2) {
-        val = (val * 10 +
-          (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+        val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
       }
       return val as T;
     }
   } else {
     for (; start < end; start += 2) {
-      val = (val * 10 +
-        (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+      val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
     }
     return val as T;
   }
@@ -308,12 +267,7 @@
 }
 
 // @ts-ignore
-@inline export function containsCodePoint(
-  str: string,
-  code: u32,
-  start: i32,
-  end: i32,
-): bool {
+@inline export function containsCodePoint(str: string, code: u32, start: i32, end: i32): bool {
   for (let i = start; i <= end; i++) {
     if (unsafeCharCodeAt(str, i) == code) return true;
   }

package/assembly/deserialize/float.ts

@@ -0,0 +1,181 @@
+import { ptrToStr } from "../util/ptrToStr";
+
+// @ts-ignore: inline
+@inline function pow10Fast(exponent: u32): f64 {
+  let result = 1.0;
+  if (exponent & 1) result *= 1e1;
+  if (exponent & 2) result *= 1e2;
+  if (exponent & 4) result *= 1e4;
+  if (exponent & 8) result *= 1e8;
+  if (exponent & 16) result *= 1e16;
+  if (exponent & 32) result *= 1e32;
+  if (exponent & 64) result *= 1e64;
+  if (exponent & 128) result *= 1e128;
+  if (exponent & 256) result *= 1e256;
+  return result;
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloat<T>(srcStart: usize, srcEnd: usize): T {
+  let negative = false;
+  if (load<u16>(srcStart) == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) unreachable();
+  }
+
+  let value: f64 = 0.0;
+  let seenDigit = false;
+
+  while (srcStart < srcEnd) {
+    const digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10.0 + <f64>digit;
+    seenDigit = true;
+    srcStart += 2;
+  }
+
+  if (srcStart < srcEnd && load<u16>(srcStart) == 46) {
+    srcStart += 2;
+    let fraction: u64 = 0;
+    let digits: u32 = 0;
+    while (srcStart < srcEnd) {
+      const digit = <u32>load<u16>(srcStart) - 48;
+      if (digit > 9) break;
+      fraction = fraction * 10 + digit;
+      digits += 1;
+      seenDigit = true;
+      srcStart += 2;
+    }
+    if (digits != 0) value += <f64>fraction / pow10Fast(digits);
+  }
+
+  if (!seenDigit) {
+    // @ts-ignore
+    const type: T = 0;
+    // @ts-ignore
+    if (type instanceof f64) return f64.parse(ptrToStr(srcStart, srcEnd));
+    // @ts-ignore
+    return f32.parse(ptrToStr(srcStart, srcEnd));
+  }
+
+  if (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == 101 || code == 69) {
+      srcStart += 2;
+      if (srcStart >= srcEnd) unreachable();
+
+      let exponentNegative = false;
+      let exponentCode = load<u16>(srcStart);
+      if (exponentCode == 45 || exponentCode == 43) {
+        exponentNegative = exponentCode == 45;
+        srcStart += 2;
+        if (srcStart >= srcEnd) unreachable();
+        exponentCode = load<u16>(srcStart);
+      }
+
+      let exponent = <u32>exponentCode - 48;
+      if (exponent > 9) unreachable();
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const digit = <u32>load<u16>(srcStart) - 48;
+        if (digit > 9) break;
+        exponent = exponent * 10 + digit;
+        srcStart += 2;
+      }
+
+      const power = pow10Fast(exponent);
+      value = exponentNegative ? value / power : value * power;
+    }
+  }
+
+  if (negative) value = -value;
+
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return <T>value;
+  // @ts-ignore
+  return <T>(<f32>value);
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloatField<T extends number>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  let negative = false;
+  if (load<u16>(srcStart) == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) unreachable();
+  }
+
+  let value: f64 = 0.0;
+  let seenDigit = false;
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    const digit = <u32>code - 48;
+    if (digit > 9) break;
+    value = value * 10.0 + <f64>digit;
+    seenDigit = true;
+    srcStart += 2;
+  }
+
+  if (srcStart < srcEnd && load<u16>(srcStart) == 46) {
+    srcStart += 2;
+    let fraction: u64 = 0;
+    let digits: u32 = 0;
+    while (srcStart < srcEnd) {
+      const code = load<u16>(srcStart);
+      const digit = <u32>code - 48;
+      if (digit > 9) break;
+      fraction = fraction * 10 + digit;
+      digits += 1;
+      seenDigit = true;
+      srcStart += 2;
+    }
+    if (digits != 0) value += <f64>fraction / pow10Fast(digits);
+  }
+
+  if (!seenDigit) unreachable();
+
+  if (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == 101 || code == 69) {
+      srcStart += 2;
+      if (srcStart >= srcEnd) unreachable();
+
+      let exponentNegative = false;
+      let exponentCode = load<u16>(srcStart);
+      if (exponentCode == 45 || exponentCode == 43) {
+        exponentNegative = exponentCode == 45;
+        srcStart += 2;
+        if (srcStart >= srcEnd) unreachable();
+        exponentCode = load<u16>(srcStart);
+      }
+
+      let exponent = <u32>exponentCode - 48;
+      if (exponent > 9) unreachable();
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        const digit = <u32>code - 48;
+        if (digit > 9) break;
+        exponent = exponent * 10 + digit;
+        srcStart += 2;
+      }
+
+      const power = pow10Fast(exponent);
+      value = exponentNegative ? value / power : value * power;
+    }
+  }
+
+  if (negative) value = -value;
+
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, <f32>value);
+  } else {
+    store<f64>(fieldPtr, value);
+  }
+
+  return srcStart;
+}

package/assembly/deserialize/helpers/uint.ts

@@ -0,0 +1,12 @@
+export function deserializeUintScan<T extends number>(src: usize, dst: usize): usize {
+  let digit = <T>load<u16>(src) - 48;
+  if (digit > 9) abort("Found invalid digit");
+  let val = digit;
+  src += 2;
+  while ((digit = <u32>load<u16>(src) - 48) < 10) {
+    val = val * 10 + digit;
+    src += 2;
+  }
+  store<T>(dst, val);
+  return src;
+}