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

package/CHANGELOG

@@ -1,5 +1,19 @@
 # Change Log
 
+## 2025-02-13 - 1.0.0-alpha.4
+
+- feat: reintroduce support for `Box<T>`-wrapped primitive types
+- tests: add extensive tests to all supported types
+- fix: 6-byte keys being recognized on deserialize
+- perf: take advantage of aligned memory to use a single 64-bit load on 6-byte keys
+- fix: `bs.proposeSize()` should increment `stackSize` by `size` instead of setting it
+- fix: allow runtime to manage `bs.buffer`
+- fix: memory leaks in `bs` module
+- fix: add (possibly temporary) `JSON.Memory.shrink()` to shrink memory in `bs`
+- perf: prefer growing memory by `nextPowerOf2(size + 64)` for less reallocations
+- tests: add boolean tests to `Box<T>`
+- fix: serialization of non-growable data types should grow `bs.stackSize`
+
 ## 2025-01-31 - 1.0.0-alpha.3
 
 - fix: write to proper offset when deserializing string with \u0000-type escapes

package/README.md

@@ -1,30 +1,44 @@
 <h5 align="center">
   <pre>
 <span style="font-size: 0.8em;">     ██ ███████  ██████  ███    ██        █████  ███████
-     ██ ██      ██    ██ ████   ██       ██   ██ ██     
+     ██ ██      ██    ██ ████   ██       ██   ██ ██
      ██ ███████ ██    ██ ██ ██  ██ █████ ███████ ███████
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.0.0-alpha.3
+    AssemblyScript - v1.0.0-beta.1
   </pre>
 </h5>
 
-## Installation
+## 📚 Contents
+
+- [About](#-about)
+- [Installation](#-installation)
+- [Usage](#-usage)
+- [Examples](#examples)
+- [Performance](#-performance)
+- [License](#-license)
+- [Contact](#-contact)
+
+## 📝 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": {
@@ -35,12 +49,11 @@ 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";
 
-// @json or @serializable work here
 @json
 class Vec3 {
   x: f32 = 0.0;
@@ -55,8 +68,7 @@ class Player {
   lastName!: string;
   lastActive!: i32[];
   // Drop in a code block, function, or expression that evaluates to a boolean
-  @omitif((age) => age < 18)
-  @omitif('this.age <= 0')
+  @omitif((self: Player) => self.age < 18)
   age!: i32;
   @omitnull()
   pos!: Vec3 | null;
@@ -64,10 +76,10 @@ class Player {
 }
 
 const player: Player = {
-  firstName: "Emmet",
-  lastName: "West",
-  lastActive: [8, 27, 2022],
-  age: 23,
+  firstName: "Jairus",
+  lastName: "Tanaka",
+  lastActive: [2, 13, 2025],
+  age: 18,
   pos: {
     x: 3.4,
     y: 1.2,
@@ -76,64 +88,69 @@ const player: Player = {
   isVerified: true
 };
 
-const stringified = JSON.stringify<Player>(player);
+const serialized = JSON.stringify<Player>(player);
+const deserialized = JSON.parse<Player>(serialized);
 
-const parsed = JSON.parse<Player>(stringified);
+console.log("Serialized    " + serialized);
+console.log("Deserialized  " + JSON.stringify(deserialized));
 ```
 
-Classes can even have inheritance. Here's a nasty example
+## Examples
 
-```js
-@json
-class Base {}
+## ⚡ Performance
 
-@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;
-}
+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.
 
-const arr: Base[] = [
-  new Vec1(),
-  new Vec2(),
-  new Vec3()
-];
+### Raw Performance
 
-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);
-```
+Simple
 
-You can also add it to your `asconfig.json`
+| 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]           |
 
-```json
-{
-  // ...
-  "options": {
-    "transform": ["json-as/transform"]
-  }
-}
-```
+SIMD
+
+| 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
 
-If you use this project in your codebase, consider dropping a [star](https://github.com/JairusSW/as-json). I would really appreciate it!
+| 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]      |
 
-## Notes
 
-If you want a feature, drop an issue (and again, maybe a star). I'll likely add it in less than 7 days.
+## 📃 License
 
-## Contact
+This project is distributed under an open source license. You can view the full license using the following link: [License](./LICENSE)
 
-- [Email](mailto:me@jairus.dev)
-- [GitHub](https://github.com/JairusSW)
-- [Discord](discord.com/users/600700584038760448)
+## 📫 Contact
 
-## Issues
+Please send all issues to [GitHub Issues](https://github.com/JairusSW/as-json/issues) and to converse, please send me an email at [me@jairus.dev](mailto:me@jairus.dev)
 
-Please submit an issue to https://github.com/JairusSW/as-json/issues if you find anything wrong with this library
+- **Email:** Send me inquiries, questions, or requests at [me@jairus.dev](mailto:me@jairus.dev)
+- **GitHub:** Visit the official GitHub repository [Here](https://github.com/JairusSW/as-json)
+- **Website:** Visit my official website at [jairus.dev](https://jairus.dev/)
+- **Discord:** Converse with me on [My Discord](discord.com/users/600700584038760448) or on the [AssemblyScript Discord Server](https://discord.gg/assemblyscript/)

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__/box.spec.ts

@@ -0,0 +1,37 @@
+import { JSON } from "..";
+import { describe, expect } from "../../modules/test/assembly";
+
+describe("Should serialize JSON.Box<T>", () => {
+  expect(JSON.stringify<JSON.Box<i32> | null>(null))
+    .toBe("null");
+
+  expect(JSON.stringify<JSON.Box<i32> | null>(new JSON.Box<i32>(0)))
+    .toBe("0");
+
+  expect(JSON.stringify<JSON.Box<i32> | null>(new JSON.Box<i32>(1)))
+    .toBe("1");
+
+  expect(JSON.stringify<JSON.Box<boolean> | null>(new JSON.Box<boolean>(false)))
+    .toBe("false");
+
+  expect(JSON.stringify<JSON.Box<boolean> | null>(new JSON.Box<boolean>(true)))
+    .toBe("true");
+});
+
+// This is somewhat clumsy to use. Perhaps I can redesign it or use some transform to make it more transparent.
+describe("Should deserialize JSON.Box<T>", () => {
+  expect((JSON.parse<JSON.Box<i32> | null>("null") == null).toString())
+    .toBe("true");
+
+  expect(JSON.parse<JSON.Box<i32> | null>("0")!.value.toString())
+    .toBe("0");
+
+  expect(JSON.parse<JSON.Box<i32> | null>("1")!.value.toString())
+    .toBe("1");
+
+  expect(JSON.parse<JSON.Box<boolean> | null>("false")!.value.toString())
+    .toBe("false");
+
+  expect(JSON.parse<JSON.Box<boolean> | null>("true")!.value.toString())
+    .toBe("true");
+});

package/assembly/__tests__/date.spec.ts

@@ -0,0 +1,38 @@
+import { JSON } from "..";
+import { describe, expect } from "../../modules/test/assembly";
+
+describe("Should serialize Date", () => {
+  expect(JSON.stringify<Date>(new Date(0)))
+    .toBe('"1970-01-01T00:00:00.000Z"');
+  expect(JSON.stringify<Date>(new Date(1738618120525)))
+    .toBe('"2025-02-03T21:28:40.525Z"');
+});
+
+describe("Should deserialize booleans", () => {
+  // const date = JSON.parse<Date>('"2025-02-03T21:28:40.525Z"');
+  // console.log("Year: " + date.getUTCFullYear().toString());
+  // console.log("Month: " + date.getUTCMonth().toString());
+  // console.log("Day: " + date.getUTCDay().toString());
+  // console.log("Hours: " + date.getUTCHours().toString());
+  // console.log("Minutes: " + date.getUTCMinutes().toString());
+  // console.log("Seconds: " + date.getUTCSeconds().toString());
+  // console.log("Milliseconds: " + date.getUTCMilliseconds().toString());
+    
+  const date1 = JSON.parse<Date>('"1970-01-01T00:00:00.000Z"');
+  expect(date1.getUTCFullYear().toString()).toBe("1970");
+  expect(date1.getUTCMonth().toString()).toBe("0");
+  expect(date1.getUTCDay().toString()).toBe("4");
+  expect(date1.getUTCHours().toString()).toBe("0");
+  expect(date1.getUTCMinutes().toString()).toBe("0");
+  expect(date1.getUTCSeconds().toString()).toBe("0");
+  expect(date1.getUTCMilliseconds().toString()).toBe("0");
+
+  const date2 = JSON.parse<Date>('"2025-02-03T21:28:40.525Z"');
+  expect(date2.getUTCFullYear().toString()).toBe("2025");
+  expect(date2.getUTCMonth().toString()).toBe("1");
+  expect(date2.getUTCDay().toString()).toBe("1");
+  expect(date2.getUTCHours().toString()).toBe("21");
+  expect(date2.getUTCMinutes().toString()).toBe("28");
+  expect(date2.getUTCSeconds().toString()).toBe("40");
+  expect(date2.getUTCMilliseconds().toString()).toBe("525");  
+});

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/bool.ts

@@ -1,9 +1,6 @@
-import { CHAR_F, CHAR_T } from "../../custom/chars";
-
 export function deserializeBoolean(srcStart: usize, srcEnd: usize): boolean {
-  const srcSize = srcEnd - srcStart;
-  const firstChar = load<u16>(srcStart);
-  if (firstChar == CHAR_T && load<u64>(srcStart) == 28429475166421108) return true;
-  else if (firstChar == CHAR_F && load<u64>(srcSize, 2) == 28429466576093281) return false;
+  const block = load<u64>(srcStart);
+  if (block == 28429475166421108) return true;
+  else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101) return false;
   return false; //throw new Error(`Expected to find boolean, but found "${data.slice(0, 100)}" instead!`);
-}
+}

package/assembly/deserialize/simple/date.ts

@@ -2,10 +2,10 @@ import { ptrToStr } from "../../util/ptrToStr";
 
 export function deserializeDate(srcStart: usize, srcEnd: usize): Date {
   // Use AssemblyScript's date parser
-  const d = Date.fromString(ptrToStr(srcStart, srcEnd));
+  const d = Date.fromString(ptrToStr(srcStart + 2, srcEnd - 2));
 
   // Return a new object instead of the one that the parser returned.
-  // This may seem redundant, but addreses the issue when Date
+  // This may seem redundant, but it addresses the issue when Date
   // is globally aliased to wasi_Date (or some other superclass).
   return new Date(d.getTime());
 }

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);
 }