json-as 1.0.4 → 1.0.5

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # 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)
@@ -154,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.4
+    AssemblyScript - v1.0.5
   </pre>
 </h5>
 
@@ -69,6 +69,7 @@ If you'd like to see the code that the transform generates, run the build step w
 ```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

@@ -18,7 +18,8 @@ If you believe you have discovered a security vulnerability in this project, ple
 
 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**: 
+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.

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

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

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

package/assembly/deserialize/simple/struct.ts

@@ -16,8 +16,7 @@ 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 +30,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 {