json-as 1.0.0-beta.16 → 1.0.0-beta.18

package/assembly/__benches__/vec3.bench.ts

@@ -0,0 +1,73 @@
+import { JSON } from "..";
+import { bs } from "../../modules/as-bs";
+import { bench } from "../custom/bench";
+
+
+@json
+class Vec3 {
+  public x!: i32;
+  public y!: i32;
+  public z!: i32;
+
+  @inline __SERIALIZE(ptr: usize): void {
+    bs.proposeSize(98);
+    store<u64>(bs.offset, 9570664606466171, 0); // {"x"
+    store<u16>(bs.offset, 58, 8); // :
+    bs.offset += 10;
+    JSON.__serialize<i32>(load<i32>(ptr, offsetof<this>("x")));
+    store<u64>(bs.offset, 9570668901433388, 0); // ,"y"
+    store<u16>(bs.offset, 58, 8); // :
+    bs.offset += 10;
+    JSON.__serialize<i32>(load<i32>(ptr, offsetof<this>("y")));
+    store<u64>(bs.offset, 9570673196400684, 0); // ,"z"
+    store<u16>(bs.offset, 58, 8); // :
+    bs.offset += 10;
+    JSON.__serialize<i32>(load<i32>(ptr, offsetof<this>("z")));
+    store<u16>(bs.offset, 125, 0); // }
+    bs.offset += 2;
+  }
+
+  @inline __INITIALIZE(): this {
+    return this;
+  }
+
+  @inline __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;
+  }
+}
+
+const v1: Vec3 = { x: 1, y: 2, z: 3 };
+const v2 = '{"x":1,"y":2,"z":3}';
+
+bench(
+  "Serialize Vec3",
+  () => {
+    JSON.stringify(v1);
+  },
+  16_000_00,
+);
+
+bench(
+  "Deserialize Vec3",
+  () => {
+    JSON.parse<Vec3>(v2);
+  },
+  16_000_00,
+);

package/assembly/__tests__/arbitrary.spec.ts

@@ -3,7 +3,7 @@ import { describe, expect } from "./lib";
 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("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}');
@@ -11,9 +11,9 @@ describe("Should serialize arbitrary types", () => {
 });
 
 describe("Should deserialize arbitrary types", () => {
-  expect(JSON.parse<JSON.Value>("\"hello world\"").get<string>()).toBe("hello world");
+  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__/array.spec.ts

@@ -59,8 +59,8 @@ describe("Should serialize object arrays", () => {
 });
 
 describe("Should deserialize integer arrays", () => {
-  expect(JSON.stringify(JSON.parse<u32[]>("[0,100,101]"))).toBe('[0,100,101]');
-  expect(JSON.stringify(JSON.parse<u64[]>("[0,100,101]"))).toBe('[0,100,101]');
+  expect(JSON.stringify(JSON.parse<u32[]>("[0,100,101]"))).toBe("[0,100,101]");
+  expect(JSON.stringify(JSON.parse<u64[]>("[0,100,101]"))).toBe("[0,100,101]");
   expect(JSON.stringify(JSON.parse<i32[]>("[0,100,101,-100,-101]"))).toBe("[0,100,101,-100,-101]");
   expect(JSON.stringify(JSON.parse<i64[]>("[0,100,101,-100,-101]"))).toBe("[0,100,101,-100,-101]");
 });
@@ -76,7 +76,7 @@ describe("Should deserialize boolean arrays", () => {
 });
 
 describe("Should deserialize string arrays", () => {
-  expect(JSON.stringify(JSON.parse<string[]>("[\"string \\\"with random spa\\nces and \\nnewlines\\n\\n\\n\"]"))).toBe("[\"string \\\"with random spa\\nces and \\nnewlines\\n\\n\\n\"]");
+  expect(JSON.stringify(JSON.parse<string[]>('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]'))).toBe('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]');
 });
 
 describe("Should deserialize nested integer arrays", () => {
@@ -93,13 +93,10 @@ describe("Should deserialize nested boolean arrays", () => {
 });
 
 describe("Should deserialize object arrays", () => {
-  expect(
-    JSON.stringify(JSON.parse<Vec3[]>(
-      '[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]'
-    )
-  )).toBe('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]');
+  expect(JSON.stringify(JSON.parse<Vec3[]>('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]'))).toBe('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]');
 });
 
+
 @json
 class Vec3 {
   x: f64 = 0.0;

package/assembly/__tests__/box.spec.ts

@@ -2,36 +2,26 @@ import { JSON } from "..";
 import { describe, expect } from "./lib";
 
 describe("Should serialize JSON.Box<T>", () => {
-  expect(JSON.stringify<JSON.Box<i32> | null>(null))
-    .toBe("null");
+  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>(0))).toBe("0");
 
-  expect(JSON.stringify<JSON.Box<i32> | null>(new JSON.Box<i32>(1)))
-    .toBe("1");
+  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>(false))).toBe("false");
 
-  expect(JSON.stringify<JSON.Box<boolean> | null>(new JSON.Box<boolean>(true)))
-    .toBe("true");
+  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>("null") == null).toString()).toBe("true");
 
-  expect(JSON.parse<JSON.Box<i32> | null>("0")!.value.toString())
-    .toBe("0");
+  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<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>("false")!.value.toString()).toBe("false");
 
-  expect(JSON.parse<JSON.Box<boolean> | null>("true")!.value.toString())
-    .toBe("true");
+  expect(JSON.parse<JSON.Box<boolean> | null>("true")!.value.toString()).toBe("true");
 });

package/assembly/__tests__/custom.spec.ts

@@ -2,6 +2,7 @@ import { JSON } from "..";
 import { describe, expect } from "./lib";
 import { bytes } from "../util";
 
+
 @json
 class Point {
   x: f64 = 0.0;
@@ -10,10 +11,14 @@ class Point {
     this.x = x;
     this.y = y;
   }
+
+
   @serializer
   serializer(self: Point): string {
     return `(${self.x},${self.y})`;
   }
+
+
   @deserializer
   deserializer(data: string): Point {
     const dataSize = bytes(data);
@@ -23,16 +28,12 @@ class Point {
     const x = data.slice(1, c);
     const y = data.slice(c + 1, data.length - 1);
 
-    return new Point(
-      f64.parse(x),
-      f64.parse(y)
-    );
+    return new Point(f64.parse(x), f64.parse(y));
   }
 }
 
-
 describe("Should serialize using custom serializers", () => {
-  expect(JSON.stringify<Point>(new Point(1,2))).toBe("(1.0,2.0)");
+  expect(JSON.stringify<Point>(new Point(1, 2))).toBe("(1.0,2.0)");
 });
 
 describe("Should deserialize using custom deserializers", () => {

package/assembly/__tests__/date.spec.ts

@@ -2,10 +2,8 @@ import { JSON } from "..";
 import { describe, expect } from "./lib";
 
 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"');
+  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", () => {
@@ -17,7 +15,7 @@ describe("Should deserialize booleans", () => {
   // 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");
@@ -34,5 +32,5 @@ describe("Should deserialize booleans", () => {
   expect(date2.getUTCHours().toString()).toBe("21");
   expect(date2.getUTCMinutes().toString()).toBe("28");
   expect(date2.getUTCSeconds().toString()).toBe("40");
-  expect(date2.getUTCMilliseconds().toString()).toBe("525");  
+  expect(date2.getUTCMilliseconds().toString()).toBe("525");
 });

package/assembly/__tests__/float.spec.ts

@@ -34,9 +34,9 @@ describe("Should deserialize floats", () => {
 
   expect(JSON.parse<f64>("0.000001").toString()).toBe("0.000001");
 
-  expect(JSON.parse<f64>("1e-7").toString()).toBe(1e-7.toString());
+  expect(JSON.parse<f64>("1e-7").toString()).toBe((1e-7).toString());
 
-  expect(JSON.parse<f64>("100000000000000000000.0").toString()).toBe(1e20.toString());
+  expect(JSON.parse<f64>("100000000000000000000.0").toString()).toBe((1e20).toString());
 
-  expect(JSON.parse<f64>("1e+21").toString()).toBe(1e21.toString());
+  expect(JSON.parse<f64>("1e+21").toString()).toBe((1e21).toString());
 });

package/assembly/__tests__/lib/index.ts

@@ -2,6 +2,10 @@ export function describe(description: string, routine: () => void): void {
   routine();
 }
 
+export function it(description: string, routine: () => void): void {
+  routine();
+}
+
 export function expect(left: string): Expectation {
   return new Expectation(left);
 }

package/assembly/__tests__/map.spec.ts

@@ -4,4 +4,4 @@ import { describe, expect } from "./lib";
 describe("Should deserialize complex objects", () => {
   const input = '{"a":{"b":{"c":[{"d":"random value 1"},{"e":["value 2","value 3"]}],"f":{"g":{"h":[1,2,3],"i":{"j":"nested value"}}}},"k":"simple value"},"l":[{"m":"another value","n":{"o":"deep nested","p":[{"q":"even deeper"},"final value"]}}],"r":null}';
   expect(JSON.stringify(JSON.parse<Map<string, JSON.Raw>>(input))).toBe(input);
-})
+});

package/assembly/__tests__/misc.spec.ts

@@ -0,0 +1,90 @@
+import { JSON } from "..";
+import { bytes } from "../util";
+import { describe, expect } from "./lib";
+
+
+@json
+class Obj {
+  public a: string = "hello";
+  public b: string = "world";
+  public c: string = '"\t\f\u0000\u0001';
+}
+
+
+@json
+class Vec3 {
+  x: f32 = 0.0;
+  y: f32 = 0.0;
+  z: f32 = 0.0;
+}
+
+
+@json
+class Player {
+
+  @alias("first name")
+  firstName!: string;
+  lastName!: string;
+  lastActive!: i32[];
+  // Drop in a code block, function, or expression that evaluates to a boolean
+  @omitif((self: Player) => self.age < 18)
+  age!: i32;
+
+
+  @omitnull()
+  pos!: Vec3 | null;
+  isVerified!: boolean;
+}
+
+
+@json
+class InnerObj<T> {
+  obj: T = instantiate<T>();
+}
+
+
+@json
+class ObjWithBracketString {
+  data: string = "";
+}
+
+describe("Should serialize special characters", () => {
+  expect(JSON.stringify("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u000f\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f")).toBe('"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u000f\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f"');
+});
+
+describe("Should serialize an object", () => {
+  const obj = new Obj();
+  expect(JSON.stringify(obj)).toBe('{"a":"hello","b":"world","c":"\\"\\t\\f\\u0000\\u0001"}');
+});
+
+describe("Should serialize a player instance", () => {
+  const player: Player = {
+    firstName: "Jairus",
+    lastName: "Tanaka",
+    lastActive: [2, 7, 2025],
+    age: 18,
+    pos: { x: 3.4, y: 1.2, z: 8.3 },
+    isVerified: true,
+  };
+  expect(JSON.stringify(player)).toBe('{"age":18,"pos":{"x":3.4,"y":1.2,"z":8.3},"first name":"Jairus","lastName":"Tanaka","lastActive":[2,7,2025],"isVerified":true}');
+});
+
+describe("Should parse JSON objects", () => {
+  expect(JSON.stringify(JSON.parse<JSON.Obj>('{"foo":"bar"}'))).toBe('{"foo":"bar"}');
+});
+
+describe("Should parse nested JSON objects", () => {
+  expect(JSON.stringify(JSON.parse<JSON.Obj>('{"x":1.5,"y":5.4,"z":9.8,"obj":{"foo":"bar"}}'))).toBe('{"x":1.5,"y":5.4,"z":9.8,"obj":{"foo":"bar"}}');
+});
+
+describe("Should parse an array with mixed types", () => {
+  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.0,true]]'))).toBe('["string",true,3.14,{"x":1.0,"y":2.0,"z":3.0},[1.0,2.0,3.0,true]]');
+});
+
+describe("Should parse and serialize a Vec3 instance", () => {
+  expect(JSON.stringify(JSON.parse<Vec3>('  {  "x"  :  3.4  ,  "y"   :   1.2    ,  "z"  :  8.3   }     '))).toBe('{"x":3.4,"y":1.2,"z":8.3}');
+});
+
+describe("Should parse an InnerObj containing an ObjWithBracketString", () => {
+  expect(JSON.stringify(JSON.parse<InnerObj<ObjWithBracketString>>('{"obj":{"data":"hello} world"}}'))).toBe('{"obj":{"data":"hello} world"}}');
+});

package/assembly/__tests__/raw.spec.ts

@@ -11,8 +11,8 @@ describe("Should deserialize JSON.Raw", () => {
 
 describe("Should serialize Map<string, JSON.Raw>", () => {
   const m1 = new Map<string, JSON.Raw>();
-  m1.set("hello", new JSON.Raw("\"world\""));
-  m1.set("pos", new JSON.Raw("{\"x\":1.0,\"y\":2.0,\"z\":3.0}"));
+  m1.set("hello", new JSON.Raw('"world"'));
+  m1.set("pos", new JSON.Raw('{"x":1.0,"y":2.0,"z":3.0}'));
 
   expect(JSON.stringify(m1)).toBe('{"hello":"world","pos":{"x":1.0,"y":2.0,"z":3.0}}');
 });
@@ -20,4 +20,4 @@ describe("Should serialize Map<string, JSON.Raw>", () => {
 describe("Should deserialize Map<string, JSON.Raw>", () => {
   const m1 = JSON.parse<Map<string, JSON.Raw>>('{"hello":"world","pos":{"x":1.0,"y":2.0,"z":3.0}}');
   expect(JSON.stringify(m1)).toBe('{"hello":"world","pos":{"x":1.0,"y":2.0,"z":3.0}}');
-});
+});

package/assembly/__tests__/struct.spec.ts

@@ -53,15 +53,11 @@ describe("Should ignore properties decorated with @omit", () => {
 });
 
 describe("Should deserialize structs", () => {
-  expect(
-    JSON.stringify(JSON.parse<Vec3>('{"x":3.4,"y":1.2,"z":8.3}')),
-  ).toBe('{"x":3.4,"y":1.2,"z":8.3}');
+  expect(JSON.stringify(JSON.parse<Vec3>('{"x":3.4,"y":1.2,"z":8.3}'))).toBe('{"x":3.4,"y":1.2,"z":8.3}');
 });
 
 describe("Should deserialize structs with whitespace", () => {
-  expect(
-    JSON.stringify(JSON.parse<Vec3>('    {  "x"  :  3.4  ,  "y"  :  1.2    ,  "z"   :  8.3   }   ')),
-  ).toBe('{"x":3.4,"y":1.2,"z":8.3}');
+  expect(JSON.stringify(JSON.parse<Vec3>('    {  "x"  :  3.4  ,  "y"  :  1.2    ,  "z"   :  8.3   }   '))).toBe('{"x":3.4,"y":1.2,"z":8.3}');
 });
 
 // describe("Should serialize Suite struct", () => {
@@ -114,6 +110,7 @@ class ObjWithString {
 
 @json
 class ObjWithStrangeKey<T> {
+
   @alias('a\\\t"\x02b`c')
   data!: T;
 }

package/assembly/custom/bench.ts

@@ -1,11 +1,18 @@
 export function bench(description: string, routine: () => void, ops: u64 = 1_000_000): void {
   console.log(" - Benchmarking " + description);
+  let warmup = ops >> 1;
+
+  while (warmup--) {
+    routine();
+  }
+
   const start = Date.now();
   let count = ops;
-  while (count != 0) {
+
+  while (count--) {
     routine();
-    count--;
   }
+
   const elapsed = Date.now() - start;
 
   let opsPerSecond = (ops * 1000) / elapsed;

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

@@ -10,8 +10,7 @@ export function deserializeStructArray<T extends unknown[]>(srcStart: usize, src
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
-  if (srcStart - srcEnd == 0)
-    throw new Error("Input string had zero length or was all whitespace");
+  if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
 
   if (load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Expected '[' at start of object at position " + (srcEnd - srcStart).toString());
   if (load<u16>(srcEnd - 2) != BRACKET_RIGHT) throw new Error("Expected ']' at end of object at position " + (srcEnd - srcStart).toString());
@@ -21,7 +20,7 @@ export function deserializeStructArray<T extends unknown[]>(srcStart: usize, src
     if (code == BRACE_LEFT && depth++ == 0) {
       lastIndex = srcStart;
     } else if (code == BRACE_RIGHT && --depth == 0) {
-      out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart += 2));
+      out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
     }
     srcStart += 2;
   }

package/assembly/deserialize/simple/array.ts

@@ -43,4 +43,4 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
   } else {
     throw new Error("Could not parse array of type " + nameof<T>() + "!");
   }
-}
+}

package/assembly/deserialize/simple/bool.ts

@@ -3,4 +3,4 @@ export function deserializeBoolean(srcStart: usize, srcEnd: usize): boolean {
   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/map.ts

@@ -17,8 +17,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
 
-  if (srcStart - srcEnd == 0)
-    throw new Error("Input string had zero length or was all whitespace");
+  if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
   if (load<u16>(srcStart) != BRACE_LEFT) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
   if (load<u16>(srcEnd - 2) != BRACE_RIGHT) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
 
@@ -32,7 +31,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
           keyEnd = srcStart;
           // console.log("Key: " + ptrToStr(lastIndex, srcStart));
           // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
-          while (isSpace((code = load<u16>((srcStart += 2))))) { }
+          while (isSpace((code = load<u16>((srcStart += 2))))) {}
           if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
           isKey = false;
         } else {
@@ -169,4 +168,4 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
     }
   }
   return out;
-}
+}

package/assembly/deserialize/simple/object.ts

@@ -16,8 +16,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
 
-  if (srcStart - srcEnd == 0)
-    throw new Error("Input string had zero length or was all whitespace");
+  if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
   if (load<u16>(srcStart) != BRACE_LEFT) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
   if (load<u16>(srcEnd - 2) != BRACE_RIGHT) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
 
@@ -31,7 +30,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           keyEnd = srcStart;
           // console.log("Key: " + ptrToStr(lastIndex, srcStart));
           // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
-          while (isSpace((code = load<u16>((srcStart += 2))))) { }
+          while (isSpace((code = load<u16>((srcStart += 2))))) {}
           if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
           isKey = false;
         } else {

package/assembly/deserialize/simple/raw.ts

@@ -3,4 +3,4 @@ import { ptrToStr } from "../../util/ptrToStr";
 
 export function deserializeRaw(srcStart: usize, srcEnd: usize): JSON.Raw {
   return JSON.Raw.from(ptrToStr(srcStart, srcEnd));
-}
+}

package/assembly/deserialize/simple/struct.ts

@@ -1,5 +1,6 @@
 import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
 import { isSpace } from "../../util";
+import { ptrToStr } from "../../util/ptrToStr";
 
 export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize): T {
   const out = changetype<nonnull<T>>(dst || __new(offsetof<T>(), idof<T>()));
@@ -16,8 +17,8 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
 
-  if (srcStart - srcEnd == 0)
-    throw new Error("Input string had zero length or was all whitespace");
+  if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
+
   if (load<u16>(srcStart) != BRACE_LEFT) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
   if (load<u16>(srcEnd - 2) != BRACE_RIGHT) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
 
@@ -31,7 +32,7 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
           keyEnd = srcStart;
           // console.log("Key: " + ptrToStr(lastIndex, srcStart));
           // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
-          while (isSpace((code = load<u16>((srcStart += 2))))) { }
+          while (isSpace((code = load<u16>((srcStart += 2))))) {}
           if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
           isKey = false;
         } else {
@@ -109,7 +110,10 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
         srcStart += 2;
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
-          if (code == BRACKET_RIGHT) {
+          if (code == QUOTE) {
+            srcStart += 2;
+            while (!(load<u16>(srcStart) == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)) srcStart += 2;
+          } else if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
               // @ts-ignore: exists
@@ -150,7 +154,7 @@ export function deserializeStruct<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));
+          // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8).replaceAll(" ", "-"));
           // @ts-ignore: exists
           out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), changetype<usize>(out));
           // while (isSpace(load<u16>((srcStart += 2)))) {

package/assembly/index.ts

@@ -1,4 +1,5 @@
 /// <reference path="./index.d.ts" />
+import { bs } from "../modules/as-bs";
 
 import { serializeString } from "./serialize/simple/string";
 import { serializeArray } from "./serialize/simple/array";
@@ -422,7 +423,7 @@ export namespace JSON {
     // @ts-ignore: type
     private storage: Map<string, JSON.Value> = new Map<string, JSON.Value>();
 
-    constructor() { }
+    constructor() {}
 
     // @ts-ignore: decorator
     @inline get size(): i32 {
@@ -472,7 +473,6 @@ export namespace JSON {
       const out = changetype<JSON.Obj>(__new(offsetof<JSON.Obj>(), idof<JSON.Obj>()));
 
       if (value instanceof Map) {
-
       }
       return out;
     }
@@ -574,6 +574,9 @@ export namespace JSON {
       return atoi<T>(srcStart, srcEnd);
     } else if (isFloat<T>()) {
       return deserializeFloat<T>(srcStart, srcEnd);
+    } else if (isNullable<T>() && srcEnd - srcStart == 8 && load<u64>(srcStart) == 30399761348886638) {
+      // @ts-ignore
+      return null;
     } else if (isString<T>()) {
       // @ts-ignore: type
       return deserializeString(srcStart, srcEnd, dst);
@@ -622,7 +625,13 @@ function deserializeBox<T>(srcStart: usize, srcEnd: usize, dst: usize, ty: T): T
   return JSON.__deserialize<T>(srcStart, srcEnd, dst);
 }
 
-export function toRaw(data: string): JSON.Raw { return new JSON.Raw(data) }
-export function fromRaw(data: JSON.Raw): string { return data.data }
+export function toRaw(data: string): JSON.Raw {
+  return new JSON.Raw(data);
+}
+export function fromRaw(data: JSON.Raw): string {
+  return data.data;
+}
 
-export function toBox<T>(data: T): JSON.Box<T> { return new JSON.Box<T>(data) }
+export function toBox<T>(data: T): JSON.Box<T> {
+  return new JSON.Box<T>(data);
+}

package/assembly/serialize/simple/arbitrary.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../modules/as-bs";
 import { JSON } from "../..";
 import { serializeArray } from "./array";
 import { serializeBool } from "./bool";

package/assembly/serialize/simple/array.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../modules/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
 

package/assembly/serialize/simple/bool.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../modules/as-bs";
 /**
  * Serialize a bool to type string
  * @param data data to serialize

package/assembly/serialize/simple/date.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../modules/as-bs";
 import { QUOTE } from "../../custom/chars";
 import { bytes } from "../../util/bytes";