json-as 1.0.0-alpha.4 → 1.0.0-beta.1

package/README.md

@@ -1,41 +1,44 @@
 <h5 align="center">
   <pre>
 <span style="font-size: 0.8em;">     ██ ███████  ██████  ███    ██        █████  ███████
-     ██ ██      ██    ██ ████   ██       ██   ██ ██     
+     ██ ██      ██    ██ ████   ██       ██   ██ ██
      ██ ███████ ██    ██ ██ ██  ██ █████ ███████ ███████
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.0.0-alpha.4
+    AssemblyScript - v1.0.0-beta.1
   </pre>
 </h5>
 
-## Contents
- - [About](#about)
- - [Installation](#installation)
- - [Usage](#usage)
- - [Examples](#examples)
- - [Performance](#performance)
- - [License](#license)
- - [Contact](#contact)
+## 📚 Contents
 
-## About
+- [About](#-about)
+- [Installation](#-installation)
+- [Usage](#-usage)
+- [Examples](#examples)
+- [Performance](#-performance)
+- [License](#-license)
+- [Contact](#-contact)
 
-## Installation
+## 📝 About
+
+JSON is the de-facto serialization format of modern web applications, but its serialization and deserialization remain a significant performance bottleneck, especially at scale. Traditional parsing approaches are computationally expensive, adding unnecessary overhead to both clients and servers. This library is designed to mitigate this by leveraging SIMD acceleration and highly optimized transformations.
+
+## 💾 Installation
 
 ```bash
-npm install json-as@1.0.0-alpha.3
+npm install json-as@1.0.0-beta.1
 ```
 
 Add the `--transform` to your `asc` command (e.g. in package.json)
 
 ```bash
---transform json-as
+--transform json-as/transform
 ```
 
 Alternatively, add it to your `asconfig.json`
 
-```
+```json
 {
   // ...
   "options": {
@@ -46,7 +49,7 @@ Alternatively, add it to your `asconfig.json`
 
 If you'd like to see the code that the transform generates, run with `JSON_DEBUG=true`
 
-## Usage
+## 🪄 Usage
 
 ```js
 import { JSON } from "json-as";
@@ -75,7 +78,7 @@ class Player {
 const player: Player = {
   firstName: "Jairus",
   lastName: "Tanaka",
-  lastActive: [2, 7, 2025],
+  lastActive: [2, 13, 2025],
   age: 18,
   pos: {
     x: 3.4,
@@ -86,56 +89,58 @@ const player: Player = {
 };
 
 const serialized = JSON.stringify<Player>(player);
-const parsed = JSON.parse<Player>(serialized);
+const deserialized = JSON.parse<Player>(serialized);
 
-console.log("Serialized: " + serialized);
-console.log("Parsed: " + JSON.stringify(parsed));
+console.log("Serialized    " + serialized);
+console.log("Deserialized  " + JSON.stringify(deserialized));
 ```
 
 ## Examples
 
-Classes can even have inheritance. Here's a nasty example
+## ⚡ Performance
 
-```js
-@json
-class Base {}
+The `json-as` library has been optimized to achieve near-gigabyte-per-second JSON processing speeds through SIMD acceleration and highly efficient transformations. Below are some key performance benchmarks to give you an idea of how it performs.
 
-@json
-class Vec1 extends Base {
-  x: f32 = 1.0;
-}
-@json
-class Vec2 extends Vec1 {
-  y: f32 = 2.0;
-}
-@json
-class Vec3 extends Vec2 {
-  z: f32 = 3.0;
-}
+### Raw Performance
 
-const arr: Base[] = [
-  new Vec1(),
-  new Vec2(),
-  new Vec3()
-];
+Simple
 
-const serialized = JSON.stringify(arr);
-// [{"x":1.0},{"x":1.0,"y":2.0},{"y":2.0,"x":1.0,"z":3.0}]
-const parsed = JSON.parse<Base[]>(serialized);
-```
+| Test Case          | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
+|--------------------|-----------------------|-------------------------|----------------------|------------------------|
+| Vector3 Object     | 32,642,320 ops/s      | 9,736,272 ops/s         | 1,240 MB/s           | 369 MB/s               |
+| Alphabet String    | 4,928,856 ops/s       | 7,567,360 ops/s         | 975 MB/s             | 1,498 MB/s             |
+| Small JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Medium JSON Object | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Large JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
 
-You can also add it to your `asconfig.json`
+SIMD
 
-```json
-{
-  // ...
-  "options": {
-    "transform": ["json-as/transform"]
-  }
-}
-```
+| Test Case          | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
+|--------------------|-----------------------|-------------------------|----------------------|------------------------|
+| Vector3 Object     | 32,642,320 ops/s      | 9,736,272 ops/s         | 1,240 MB/s           | 369 MB/s               |
+| Alphabet String    | 20,368,584 ops/s      | 28,467,424 ops/s        | 3,910 MB/s           | 5,636 MB/s             |
+| Small JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Medium JSON Object | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Large JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+
+JavaScript
+
+| Test Case          | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
+|--------------------|-----------------------|-------------------------|----------------------|------------------------|
+| Vector3 Object     | 2,548,013 ops/s       | 1,942,440 ops/s         | 97 MB/s              | 73 MB/s                |
+| Alphabet String    | 3,221,556 ops/s       | 2,716,617 ops/s         | 624 MB/s             | 537 MB/s               |
+| Small JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Medium JSON Object | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Large JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+
+### Real-World Usage
+
+| Scenario           | JSON Size (kb) | Serialization Time (ops/s) | Deserialization Time (ops/s) | Throughput (GB/s) |
+|--------------------|----------------|----------------------------|------------------------------|-------------------|
+| Web API Response   | [Fill Value]   | [Fill Value]               | [Fill Value]                 | [Fill Value]      |
+| Database Entry     | [Fill Value]   | [Fill Value]               | [Fill Value]                 | [Fill Value]      |
+| File Parsing       | [Fill Value]   | [Fill Value]               | [Fill Value]                 | [Fill Value]      |
 
-If you use this project in your codebase, consider dropping a [star](https://github.com/JairusSW/as-json). I would really appreciate it!
 
 ## 📃 License
 

package/assembly/__benches__/misc.bench.ts

@@ -0,0 +1,48 @@
+import { bench } from "as-bench/assembly";
+import { JSON } from "..";
+import { Vec3 } from "./schemas";
+import { bs } from "../../modules/as-bs/assembly";
+import { serializeString_SIMD } from "../serialize/simd/string";
+import { serializeString } from "../serialize/simple/string";
+import { deserializeString } from "../deserialize/simple/string";
+import { bytes } from "../util";
+import { deserializeString_SIMD } from "../deserialize/simd/string";
+
+const vec: Vec3 = {
+  x: 1,
+  y: 2,
+  z: 3
+}
+
+bs.ensureSize(4096);
+// bench("Serialize Vector3", () => {
+//   JSON.stringify(vec);
+// });
+
+// bench("Deserialize Vector3", () => {
+//   JSON.parse<Vec3>('{"x":1,"y":2,"z":3}');
+// });
+
+// bench("Serialize String SIMD", () => {
+//   serializeString_SIMD("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\:;\"'?/>.<,'\"}");
+//   bs.offset = changetype<usize>(bs.buffer);
+//   bs.stackSize = 0;
+// });
+
+// bench("Serialize String", () => {
+//   serializeString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\:;\"'?/>.<,'\"}");
+//   bs.offset = changetype<usize>(bs.buffer);
+//   bs.stackSize = 0;
+// });
+
+const src = '"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\\\:;\\"\'?/>.<,\'\\"}"';
+const srcStart = changetype<usize>(src);
+const srcEnd = srcStart + bytes(src);
+const out = changetype<usize>(new ArrayBuffer(256));
+bench("Deserialize String", () => {
+  deserializeString(srcStart, srcEnd, out);
+});
+
+bench("Deserialize String SIMD", () => {
+  deserializeString_SIMD(srcStart, srcEnd, out);
+})

package/assembly/__benches__/schemas.ts

@@ -0,0 +1,25 @@
+import { JSON } from "..";
+
+@json
+export class Vec3 {
+  public x!: i32;
+  public y!: i32;
+  public z!: i32;
+  __DESERIALIZE(keyStart: usize, keyEnd: usize, valStart: usize, valEnd: usize, ptr: usize): void {
+    switch (load<u16>(keyStart)) {
+      case 120: { // x
+        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("x"));
+        return;
+      }
+      case 121: { // y
+        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("y"));
+        return;
+      }
+      case 122: { // z
+        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("z"));
+        return;
+      }
+    }
+    return;
+  }
+}

package/assembly/__tests__/arbitrary.spec.ts

@@ -0,0 +1,19 @@
+import { JSON } from "..";
+import { describe, expect } from "../../modules/test/assembly";
+import { Vec3 } from "./types";
+
+describe("Should serialize arbitrary types", () => {
+  expect(JSON.stringify(JSON.Value.from("hello world"))).toBe("\"hello world\"");
+  expect(JSON.stringify(JSON.Value.from(0))).toBe("0");
+  expect(JSON.stringify(JSON.Value.from(true))).toBe("true");
+  expect(JSON.stringify(JSON.Value.from(new Vec3()))).toBe('{"x":1.0,"y":2.0,"z":3.0}');
+  expect(JSON.stringify([JSON.Value.from("string"), JSON.Value.from(true), JSON.Value.from(3.14), JSON.Value.from(new Vec3())])).toBe('["string",true,3.14,{"x":1.0,"y":2.0,"z":3.0}]');
+});
+
+describe("Should deserialize arbitrary types", () => {
+  expect(JSON.parse<JSON.Value>("\"hello world\"").get<string>()).toBe("hello world");
+  expect(JSON.parse<JSON.Value>("0.0").toString()).toBe("0.0");
+  expect(JSON.parse<JSON.Value>("true").toString()).toBe("true");
+  expect(JSON.stringify(JSON.parse<JSON.Value>('{"x":1.0,"y":2.0,"z":3.0}'))).toBe('{"x":1.0,"y":2.0,"z":3.0}');
+  expect(JSON.stringify(JSON.parse<JSON.Value[]>('["string",true,3.14,{"x":1.0,"y":2.0,"z":3.0},[1.0,2.0,3,true]]'))).toBe('["string",true,3.14,{"x":1.0,"y":2.0,"z":3.0},[1.0,2.0,3.0,true]]');
+});

package/assembly/__tests__/types.ts

@@ -61,9 +61,9 @@ export class Map4 {
 
 @json
 export class Vec3 {
-  x: f64;
-  y: f64;
-  z: f64;
+  x: f64 = 1.0;
+  y: f64 = 2.0;
+  z: f64 = 3.0;
 
   static shouldIgnore: string = "should not be serialized";
 }

package/assembly/deserialize/simd/string.ts

@@ -10,7 +10,7 @@ const SPLAT_92 = i16x8.splat(92); /* \ */
  * @returns number of bytes written
  */
 // todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
-export function deserializeString_SIMD(src: string, srcStart: usize, srcEnd: usize, dst: usize): usize {
+export function deserializeString_SIMD(srcStart: usize, srcEnd: usize, dst: usize): usize {
   let src_ptr = srcStart + 2;
   let dst_ptr = changetype<usize>(dst);
 

package/assembly/deserialize/simple/arbitrary.ts

@@ -2,8 +2,8 @@ import { JSON } from "../..";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
 import { deserializeFloat } from "./float";
-import { deserializeObject } from "./object";
 import { deserializeString } from "./string";
+import { deserializeObject } from "./object";
 
 export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value {
   const firstChar = load<u16>(srcStart);

package/assembly/deserialize/simple/array/arbitrary.ts

@@ -1,45 +1,66 @@
 import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, CHAR_F, CHAR_N, CHAR_T, COMMA, QUOTE } from "../../../custom/chars";
 import { JSON } from "../../../";
 import { isSpace } from "util/string";
+import { ptrToStr } from "../../../util/ptrToStr";
 
-export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value[] {
-  const out = dst ? changetype<T>(dst) : instantiate<T>();
+export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value[] {
+  const out = dst ? changetype<JSON.Value[]>(dst) : instantiate<JSON.Value[]>();
   let lastIndex: usize = 0;
   let depth: u32 = 0;
+  // if (load<u16>(srcStart) != BRACKET_LEFT)
+  srcStart += 2;
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
-    if (code == QUOTE) {
+    // console.log("code: " + String.fromCharCode(code));
+    if (code == BRACE_LEFT) {
       lastIndex = srcStart;
+      depth++;
       srcStart += 2;
       while (srcStart < srcEnd) {
         const code = load<u16>(srcStart);
-        if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
-          while (isSpace(load<u16>((srcStart += 2)))) {
-            /* empty */
+        if (code == BRACE_RIGHT) {
+          if (--depth == 0) {
+            // @ts-ignore: type
+            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
+            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
+            break;
           }
-          // console.log("Value (string): " + ptrToStr(lastIndex, srcStart));
+        } else if (code == BRACE_LEFT) depth++;
+        srcStart += 2;
+      }
+    } else if (code == QUOTE) {
+      lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          // console.log("Value (string): " + ptrToStr(lastIndex, srcStart + 2));
           // @ts-ignore: exists
-          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
+          srcStart += 2;
           break;
         }
         srcStart += 2;
       }
+      // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
     } else if (code - 48 <= 9 || code == 45) {
+      // console.log("trigger int")
       lastIndex = srcStart;
       srcStart += 2;
       while (srcStart < srcEnd) {
         const code = load<u16>(srcStart);
-        if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
           // @ts-ignore: type
-          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart));
           // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
-          while (isSpace(load<u16>((srcStart += 2)))) {
-            /* empty */
-          }
           break;
         }
         srcStart += 2;
       }
+      // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
     } else if (code == BRACE_LEFT) {
       lastIndex = srcStart;
       depth++;
@@ -49,7 +70,7 @@ export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize,
         if (code == BRACE_RIGHT) {
           if (--depth == 0) {
             // @ts-ignore: type
-            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart));
             // console.log("Value (object): " + ptrToStr(lastIndex, srcStart));
             while (isSpace(load<u16>((srcStart += 2)))) {
               /* empty */
@@ -68,7 +89,7 @@ export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize,
         if (code == BRACKET_RIGHT) {
           if (--depth == 0) {
             // @ts-ignore: type
-            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart));
             // console.log("Value (array): " + ptrToStr(lastIndex, srcStart));
             while (isSpace(load<u16>((srcStart += 2)))) {
               /* empty */
@@ -81,25 +102,27 @@ export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize,
     } else if (code == CHAR_T) {
       if (load<u64>(srcStart) == 28429475166421108) {
         // @ts-ignore: type
-        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 8)));
+        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 8)));
         // console.log("Value (bool): " + ptrToStr(srcStart - 8, srcStart));
-        while (isSpace(load<u16>((srcStart += 2)))) {
-          /* empty */
-        }
+        // while (isSpace(load<u16>((srcStart += 2)))) {
+        //   /* empty */
+        // }
+        // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
       }
     } else if (code == CHAR_F) {
       if (load<u64>(srcStart, 2) == 28429466576093281) {
         // @ts-ignore: type
-        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 10)));
+        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 10)));
         // console.log("Value (bool): " + ptrToStr(srcStart - 10, srcStart));
-        while (isSpace(load<u16>((srcStart += 2)))) {
-          /* empty */
-        }
+        // while (isSpace(load<u16>((srcStart += 2)))) {
+        //   /* empty */
+        // }
+        // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
       }
     } else if (code == CHAR_N) {
       if (load<u64>(srcStart) == 30399761348886638) {
         // @ts-ignore: type
-        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 8)));
+        out.push(JSON.__deserialize<JSON.Value>(lastIndex, (srcStart += 8)));
         // console.log("Value (null): " + ptrToStr(srcStart - 8, srcStart));
         while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */

package/assembly/deserialize/simple/array/{object.ts → struct.ts}

@@ -1,7 +1,7 @@
 import { BRACE_LEFT, BRACE_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 
-export function deserializeObjectArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+export function deserializeStructArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
   const out = dst ? changetype<T>(dst) : instantiate<T>();
   let lastIndex: usize = 0;
   let depth: u32 = 0;

package/assembly/deserialize/simple/array.ts

@@ -5,7 +5,7 @@ import { deserializeBooleanArray } from "./array/bool";
 import { deserializeFloatArray } from "./array/float";
 import { deserializeIntegerArray } from "./array/integer";
 import { deserializeMapArray } from "./array/map";
-import { deserializeObjectArray } from "./array/object";
+import { deserializeStructArray } from "./array/struct";
 import { deserializeStringArray } from "./array/string";
 
 // @ts-ignore: Decorator valid here
@@ -28,21 +28,16 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
     const type = changetype<nonnull<valueof<T>>>(0);
     if (type instanceof JSON.Value) {
       // @ts-ignore: type
-      return deserializeArbitraryArray<T>(srcStart, srcEnd, dst);
+      return deserializeArbitraryArray(srcStart, srcEnd, dst);
     } else if (type instanceof Map) {
       // @ts-ignore: type
       return deserializeMapArray<T>(srcStart, srcEnd, dst);
       // @ts-ignore: defined by transform
     } else if (isDefined(type.__DESERIALIZE)) {
-      return deserializeObjectArray<T>(srcStart, srcEnd, dst);
+      return deserializeStructArray<T>(srcStart, srcEnd, dst);
     }
     throw new Error("Could not parse array of type " + nameof<T>() + "!");
   } else {
     throw new Error("Could not parse array of type " + nameof<T>() + "!");
   }
-}
-
-function isMap<T>(): boolean {
-  let type: T = changetype<T>(0);
-  return type instanceof Map;
-}
+}

package/assembly/deserialize/simple/integer.ts

@@ -1,5 +1,6 @@
 import { atoi } from "../../util/atoi";
 
-export function deserializeInteger<T>(srcStart: usize, srcEnd: usize): T {
+// @ts-ignore: inline
+@inline export function deserializeInteger<T>(srcStart: usize, srcEnd: usize): T {
   return atoi<T>(srcStart, srcEnd);
 }

package/assembly/deserialize/simple/map.ts

@@ -76,7 +76,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         srcStart += 2;
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
-          if (((code ^ BRACE_RIGHT) | (code ^ BRACKET_RIGHT)) == 32) {
+          if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
               // @ts-ignore: type
               out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));

package/assembly/deserialize/simple/object.ts

@@ -2,9 +2,10 @@ import { JSON } from "../..";
 import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T } from "../../custom/chars";
 import { isSpace } from "../../util";
 import { ptrToStr } from "../../util/ptrToStr";
+import { deserializeArbitrary } from "./arbitrary";
 
-export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || __new(offsetof<T>(), idof<T>()));
+export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): JSON.Obj {
+  const out = new JSON.Obj();
 
   let keyStart: usize = 0;
   let keyEnd: usize = 0;
@@ -22,7 +23,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
         if (isKey) {
           keyStart = lastIndex;
           keyEnd = srcStart;
-          // console.log("Key: " + ptrToStr(lastIndex, srcStart));
+          // console.log("Key: " + ptrToStr(keyStart, keyEnd));
           // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
           srcStart += 2;
           // while (isSpace((code = load<u16>((srcStart += 2))))) {
@@ -46,8 +47,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
           const code = load<u16>(srcStart);
           if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
             // console.log("Value (string): " + ptrToStr(lastIndex, srcStart + 2));
-            // @ts-ignore: exists
-            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart + 2, dst);
+            out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart + 2, dst));
             // while (isSpace(load<u16>(srcStart))) srcStart += 2;
             srcStart += 4;
             // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
@@ -63,8 +63,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
           const code = load<u16>(srcStart);
           if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
             // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
-            // @ts-ignore: exists
-            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart, dst);
+            out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart, dst));
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -84,8 +83,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
           if (code == BRACE_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-              // @ts-ignore: exists
-              out.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), dst);
+              out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 2, dst));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>(srcStart))) {
@@ -105,8 +103,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
           if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
-              // @ts-ignore: exists
-              out.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), dst);
+              out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 2, dst));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>((srcStart += 2)))) {
@@ -120,8 +117,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
       } else if (code == CHAR_T) {
         if (load<u64>(srcStart) == 28429475166421108) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
-          // @ts-ignore: exists
-          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), dst);
+          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 8, dst));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -132,8 +128,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
       } else if (code == CHAR_F) {
         if (load<u64>(srcStart, 2) == 28429466576093281) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
-          // @ts-ignore: exists
-          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 10), dst);
+          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 10, dst));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -144,8 +139,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
       } else if (code == CHAR_N) {
         if (load<u64>(srcStart) == 30399761348886638) {
           // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
-          // @ts-ignore: exists
-          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), dst);
+          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 8, dst));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */
           // }