json-as 1.0.3 → 1.0.5

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "npm" # Set to npm since you're using npm
+    directory: "/" # Location of package manifests, assuming package.json is at the root
+    schedule:
+      interval: "weekly" # Frequency of updates: "daily", "weekly", or "monthly"

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Change Log
 
+## 2025-05-11 - 1.0.5
+
+- feat: add sanity checks for badly formatted strings
+- fix: [#120](https://github.com/JairusSW/json-as/issues/120) handle empty `JSON.Obj` serialization
+- feat: add SIMD optimization if SIMD is enabled by user
+- fix: handle structs with nullable array as property [#123](https://github.com/JairusSW/json-as/pull/123)
+- fix: struct serialization from writing to incorrect parts of memory when parsing nested structs [#125](https://github.com/JairusSW/json-as/pull/125)
+- chore: add two new contributors
+
+## 2025-04-07 - 1.0.4
+
+- fix: paths must be resolved as POSIX in order to be valid TypeScript imports [#116](https://github.com/JairusSW/json-as/issues/116)
+
 ## 2025-03-24 - 1.0.3
 
 - fix: make transform windows-compatible [#119](https://github.com/JairusSW/json-as/issues/119?reload=1)
@@ -150,4 +163,4 @@
 - feat: reduce memory usage so that it is viable for low-memory environments
 - feat: write to a central buffer and reduce memory overhead
 - feat: rewrite the transform to properly resolve schemas and link them together
-- feat: pre-allocate and compute the minimum size of a schema to avoid memory out of range errors
+- feat: pre-allocate and compute the minimum size of a schema to avoid memory out of range errors

package/README.md

@@ -6,7 +6,7 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.0.3
+    AssemblyScript - v1.0.5
   </pre>
 </h5>
 
@@ -62,13 +62,14 @@ Alternatively, add it to your `asconfig.json`
 }
 ```
 
-If you'd like to see the code that the transform generates, run with `JSON_DEBUG=true`
+If you'd like to see the code that the transform generates, run the build step with `DEBUG=true`
 
 ## 🪄 Usage
 
 ```typescript
 import { JSON } from "json-as";
 
+
 @json
 class Vec3 {
   x: f32 = 0.0;
@@ -76,8 +77,10 @@ class Vec3 {
   z: f32 = 0.0;
 }
 
+
 @json
 class Player {
+
   @alias("first name")
   firstName!: string;
   lastName!: string;
@@ -85,6 +88,7 @@ class Player {
   // 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;
@@ -101,7 +105,7 @@ const player: Player = {
     z: 8.3,
   },
   isVerified: true,
-}
+};
 
 const serialized = JSON.stringify<Player>(player);
 const deserialized = JSON.parse<Player>(serialized);
@@ -121,9 +125,11 @@ This library allows selective omission of fields during serialization using the
 This decorator excludes a field from serialization entirely.
 
 ```typescript
+
 @json
 class Example {
   name!: string;
+
   @omit
   SSN!: string;
 }
@@ -140,9 +146,11 @@ console.log(JSON.stringify(obj)); // { "name": "Jairus" }
 This decorator omits a field only if its value is null.
 
 ```typescript
+
 @json
 class Example {
   name!: string;
+
   @omitnull()
   optionalField!: string | null;
 }
@@ -159,9 +167,11 @@ console.log(JSON.stringify(obj)); // { "name": "Jairus" }
 This decorator omits a field based on a custom predicate function.
 
 ```typescript
+
 @json
 class Example {
   name!: string;
+
   @omitif((self: Example) => self.age <= 18)
   age!: number;
 }
@@ -186,6 +196,7 @@ AssemblyScript doesn't support using nullable primitive types, so instead, json-
 For example, this schema won't compile in AssemblyScript:
 
 ```typescript
+
 @json
 class Person {
   name!: string;
@@ -196,6 +207,7 @@ class Person {
 Instead, use `JSON.Box` to allow nullable primitives:
 
 ```typescript
+
 @json
 class Person {
   name: string;
@@ -239,11 +251,12 @@ When dealing with an object with an unknown structure, use the `JSON.Obj` type
 const obj = JSON.parse<JSON.Obj>('{"a":3.14,"b":true,"c":[1,2,3],"d":{"x":1,"y":2,"z":3}}');
 
 console.log("Keys: " + obj.keys().join(" ")); // a b c d
-console.log("Values: " +
-  obj
-    .values()
-    .map<string>((v) => JSON.stringify(v))
-    .join(" "),
+console.log(
+  "Values: " +
+    obj
+      .values()
+      .map<string>((v) => JSON.stringify(v))
+      .join(" "),
 ); // 3.14 true [1,2,3] {"x":1,"y":2,"z":3}
 
 const y = obj.get("d")!.get<JSON.Obj>().get("y")!;
@@ -257,6 +270,7 @@ More often, objects will be completely statically typed except for one or two va
 In such cases, `JSON.Value` can be used to handle fields that may hold different types at runtime.
 
 ```typescript
+
 @json
 class DynamicObj {
   id: i32 = 0;
@@ -313,6 +327,7 @@ Here's an example of creating a custom data type called `Point` which serializes
 ```typescript
 import { bytes } from "json-as/assembly/util";
 
+
 @json
 class Point {
   x: f64 = 0.0;
@@ -322,11 +337,13 @@ class Point {
     this.y = y;
   }
 
+
   @serializer
   serializer(self: Point): string {
     return `(${self.x},${self.y})`;
   }
 
+
   @deserializer
   deserializer(data: string): Point {
     const dataSize = bytes(data);
@@ -403,6 +420,7 @@ These benchmarks compare this library to JavaScript's native `JSON.stringify` an
 - JSON-AS consistently outperforms JavaScript's native implementation.
 
 - **Serialization Speed:**
+
   - JSON-AS achieves speeds up to `2,133 MB/s`, significantly faster than JavaScript's peak of `1,416 MB/s`.
   - Large objects see the biggest improvement, with JSON-AS at `2,074 MB/s` vs. JavaScript’s `749.7 MB/s`.
 
@@ -457,4 +475,4 @@ Please send all issues to [GitHub Issues](https://github.com/JairusSW/json-as/is
 - **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/json-as)
 - **Website:** Visit my official website at [jairus.dev](https://jairus.dev/)
-- **Discord:** Contact me at [My Discord](https://discord.com/users/600700584038760448) or on the [AssemblyScript Discord Server](https://discord.gg/assemblyscript/)
+- **Discord:** Contact me at [My Discord](https://discord.com/users/600700584038760448) or on the [AssemblyScript Discord Server](https://discord.gg/assemblyscript/)

package/SECURITY.md

@@ -0,0 +1,32 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.x.x   | Active Development |
+| 0.9.x   | Maintainence       |
+| <=0.8.x | Unsupported        |
+
+## Reporting a Vulnerability
+
+If you believe you have discovered a security vulnerability in this project, please report it as soon as possible. Follow the steps below to report a vulnerability:
+
+1. **Report via GitHub Issues**: Please submit your vulnerability report via the [GitHub Issues](https://github.com/JairusSW/json-as/issues) page. If you prefer, you can also send an email directly to [me@jairus.dev](mailto:me@jairus.dev).
+
+2. **Provide Details**: Include as much detail as possible, including the steps to reproduce, what you believe the impact is, and any suggested remediation if applicable.
+
+3. **Acknowledgment**: Once your report is received, we will acknowledge it within 48 hours. You will then receive an update on the progress of the investigation and a timeline for a potential fix.
+
+4. **Resolution Timeline**:
+
+   - Critical vulnerabilities will be prioritized, and we aim to issue a patch within 7 business days.
+   - Non-critical vulnerabilities will be evaluated and addressed in the next stable release.
+   - If the vulnerability is accepted, a fix will be issued, and a security advisory will be published.
+   - If the vulnerability is declined, you will be notified of the decision with an explanation.
+
+5. **Confidentiality**: Please do not disclose the vulnerability to the public or other parties until the issue has been addressed. This helps ensure that users of the project are not at risk before a patch is available.
+
+6. **Credits**: If your report leads to a fix, we will credit your contribution in the release notes, if you are comfortable with that.
+
+Thank you for helping us keep this project secure!

package/assembly/__benches__/large.bench.ts

@@ -8,6 +8,7 @@ class Vec3 {
   public y!: i32;
   public z!: i32;
 
+
   @inline __SERIALIZE(ptr: usize): void {
     bs.proposeSize(98);
     store<u64>(bs.offset, 9570664606466171, 0); // {"x"
@@ -26,10 +27,12 @@ class Vec3 {
     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: {

package/assembly/__benches__/vec3.bench.ts

@@ -8,6 +8,7 @@ class Vec3 {
   public y!: i32;
   public z!: i32;
 
+
   @inline __SERIALIZE(ptr: usize): void {
     bs.proposeSize(98);
     store<u64>(bs.offset, 9570664606466171, 0); // {"x"
@@ -26,10 +27,12 @@ class Vec3 {
     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: {

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,12 @@ 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 +26,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__/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__/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,26 +53,24 @@ 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 deserialize structs with nullable properties", () => {
-  expect(
-    JSON.stringify(JSON.parse<NullableObj>('{"bar":{"value":"test"}}'))
-  ).toBe('{"bar":{"value":"test"}}');
+  expect(JSON.stringify(JSON.parse<NullableObj>('{"bar":{"value":"test"}}'))).toBe('{"bar":{"value":"test"}}');
 
-  expect(
-    JSON.stringify(JSON.parse<NullableObj>('{"bar":null}'))
-  ).toBe('{"bar":null}');
-})
+  expect(JSON.stringify(JSON.parse<NullableObj>('{"bar":null}'))).toBe('{"bar":null}');
+});
+
+describe("Should deserialize structs with nullable arrays in properties", () => {
+  expect(JSON.stringify(JSON.parse<NullableArrayObj>('{"bars":[{"value":"test"}]}'))).toBe('{"bars":[{"value":"test"}]}');
+
+  expect(JSON.stringify(JSON.parse<NullableArrayObj>('{"bars":null}'))).toBe('{"bars":null}');
+});
 
 // describe("Should serialize Suite struct", () => {
 
@@ -118,33 +116,45 @@ class Player {
 
 @json
 class ObjWithStrangeKey<T> {
+
   @alias('a\\\t"\x02b`c')
   data!: T;
 }
 
+
 @json
 class ObjectWithFloat {
   f!: f64;
 }
 
+
 @json
 class OmitIf {
   x: i32 = 1;
 
+
   @omitif("this.y == -1")
   y: i32 = -1;
   z: i32 = 1;
 
+
   @omitnull()
   foo: string | null = null;
 }
 
+
 @json
 class NullableObj {
   bar: Bar | null = null;
 }
 
+@json
+class NullableArrayObj {
+  bars: Bar[] | null = null;
+}
+
+
 @json
 class Bar {
   value: string = "";
-}
+}

package/assembly/deserialize/simd/string.ts

@@ -1,8 +1,6 @@
 import { BACK_SLASH } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
 
-const SPLAT_92 = i16x8.splat(92); /* \ */
-
 /**
  * Deserializes strings back into into their original form using SIMD operations
  * @param src string to deserialize
@@ -11,6 +9,7 @@ const SPLAT_92 = i16x8.splat(92); /* \ */
  */
 // todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
 export function deserializeString_SIMD(srcStart: usize, srcEnd: usize, dst: usize): usize {
+  const SPLAT_92 = i16x8.splat(92); /* \ */
   let src_ptr = srcStart + 2;
   let dst_ptr = changetype<usize>(dst);
 

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

@@ -4,4 +4,4 @@
   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;
-}
+}