json-as 1.1.14 → 1.1.15-preview.2

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## UNRELEASED
+
+- feat: add `.as<T>()` method to `JSON.Value`
+- chore: remove all references to `__SERIALIZE_CUSTOM`
+- feat: add support for `StaticArray` serialization
+- feat: support `JSON.Raw` in array types
+- tests: add tests for `JSON.Raw[]`
+- tests: properly support nulls (in testing lib)
+
 ## 2025-05-29 - 1.1.14
 
 - fix: hotfix schema resolver

package/README.md

@@ -6,7 +6,7 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.1.14
+    AssemblyScript - v1.1.15-preview.2
   </pre>
 </h6>
 
@@ -23,6 +23,7 @@ JSON is the de-facto serialization format of modern web applications, but its se
   - [Nullable Primitives](#️-using-nullable-primitives)
   - [Unknown or Dynamic Data](#-working-with-unknown-or-dynamic-data)
   - [Using Raw JSON Strings](#️-using-raw-json-strings)
+  - [Using Enums](#️-working-with-enums)
   - [Custom Serializers](#️-using-custom-serializers-or-deserializers)
 - [Performance](#-performance)
 - [Debugging](#-debugging)
@@ -302,6 +303,23 @@ console.log(JSON.stringify(map));
 // Now its properly formatted JSON where pos's value is of type Vec3 not string!
 ```
 
+### 📝 Working with enums
+
+By default, enums arn't supported by `json-as`. However, you can use a workaround:
+
+```typescript
+namespace Foo {
+  export const bar = "a";
+  export const baz = "b";
+  export const gob = "c";
+}
+
+type Foo = string;
+
+const serialized = JSON.stringify<Foo>(Foo.bar);
+// "a"
+```
+
 ### ⚒️ Using custom serializers or deserializers
 
 This library supports custom serialization and deserialization methods, which can be defined using the `@serializer` and `@deserializer` decorators.

package/assembly/__tests__/array.spec.ts

@@ -1,174 +1,145 @@
 import { JSON } from "..";
 import { describe, expect } from "./lib";
 
-// describe("Should serialize integer arrays", () => {
-//   expect(JSON.stringify<u32[]>([0, 100, 101])).toBe("[0,100,101]");
-
-//   expect(JSON.stringify<u64[]>([0, 100, 101])).toBe("[0,100,101]");
-
-//   expect(JSON.stringify<i32[]>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
-
-//   expect(JSON.stringify<i64[]>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
-// });
-
-// describe("Should serialize float arrays", () => {
-//   expect(JSON.stringify<f64[]>([7.23, 10e2, 10e2, 123456e-5, 123456e-5, 0.0, 7.23])).toBe("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]");
-
-//   expect(JSON.stringify<f64[]>([1e21, 1e22, 1e-7, 1e-8, 1e-9])).toBe("[1e+21,1e+22,1e-7,1e-8,1e-9]");
-// });
-
-// describe("Should serialize boolean arrays", () => {
-//   expect(JSON.stringify<bool[]>([true, false])).toBe("[true,false]");
-
-//   expect(JSON.stringify<boolean[]>([true, false])).toBe("[true,false]");
-// });
-
-// describe("Should serialize string arrays", () => {
-//   expect(JSON.stringify<string[]>(['string "with random spa\nces and \nnewlines\n\n\n'])).toBe('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]');
-// });
-
-// describe("Should serialize nested integer arrays", () => {
-//   expect(JSON.stringify<i64[][]>([[100, 101], [-100, -101], [0]])).toBe("[[100,101],[-100,-101],[0]]");
-// });
-
-// describe("Should serialize nested float arrays", () => {
-//   expect(JSON.stringify<f64[][]>([[7.23], [10e2], [10e2], [123456e-5], [123456e-5], [0.0], [7.23]])).toBe("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]");
-// });
-
-// describe("Should serialize nested boolean arrays", () => {
-//   expect(JSON.stringify<bool[][]>([[true], [false]])).toBe("[[true],[false]]");
-
-//   expect(JSON.stringify<boolean[][]>([[true], [false]])).toBe("[[true],[false]]");
-// });
-
-// describe("Should serialize object arrays", () => {
-//   expect(
-//     JSON.stringify<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}]');
-// });
-
-// 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<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]");
-// });
-
-// describe("Should deserialize float arrays", () => {
-//   expect(JSON.stringify(JSON.parse<f64[]>("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]"))).toBe("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]");
-//   expect(JSON.stringify(JSON.parse<f64[]>("[1e+21,1e+22,1e-7,1e-8,1e-9]"))).toBe("[1e+21,1e+22,1e-7,1e-8,1e-9]");
-// });
-
-// describe("Should deserialize boolean arrays", () => {
-//   expect(JSON.stringify(JSON.parse<bool[]>("[true,false]"))).toBe("[true,false]");
-//   expect(JSON.stringify(JSON.parse<boolean[]>("[true,false]"))).toBe("[true,false]");
-// });
-
-// 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"]');
-// });
-
-// describe("Should deserialize nested integer arrays", () => {
-//   expect(JSON.stringify(JSON.parse<i64[][]>("[[100,101],[-100,-101],[0]]"))).toBe("[[100,101],[-100,-101],[0]]");
-// });
-
-// describe("Should deserialize nested float arrays", () => {
-//   expect(JSON.stringify(JSON.parse<f64[][]>("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]"))).toBe("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]");
-// });
-
-// describe("Should deserialize nested boolean arrays", () => {
-//   expect(JSON.stringify(JSON.parse<bool[][]>("[[true],[false]]"))).toBe("[[true],[false]]");
-//   expect(JSON.stringify(JSON.parse<boolean[][]>("[[true],[false]]"))).toBe("[[true],[false]]");
-// });
+describe("Should serialize integer arrays", () => {
+  expect(JSON.stringify<u32[]>([0, 100, 101])).toBe("[0,100,101]");
+
+  expect(JSON.stringify<u64[]>([0, 100, 101])).toBe("[0,100,101]");
+
+  expect(JSON.stringify<i32[]>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
+
+  expect(JSON.stringify<i64[]>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
+});
+
+describe("Should serialize float arrays", () => {
+  expect(JSON.stringify<f64[]>([7.23, 10e2, 10e2, 123456e-5, 123456e-5, 0.0, 7.23])).toBe("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]");
+
+  expect(JSON.stringify<f64[]>([1e21, 1e22, 1e-7, 1e-8, 1e-9])).toBe("[1e+21,1e+22,1e-7,1e-8,1e-9]");
+});
+
+describe("Should serialize boolean arrays", () => {
+  expect(JSON.stringify<bool[]>([true, false])).toBe("[true,false]");
+
+  expect(JSON.stringify<boolean[]>([true, false])).toBe("[true,false]");
+});
+
+describe("Should serialize string arrays", () => {
+  expect(JSON.stringify<string[]>(['string "with random spa\nces and \nnewlines\n\n\n'])).toBe('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]');
+});
+
+describe("Should serialize nested integer arrays", () => {
+  expect(JSON.stringify<i64[][]>([[100, 101], [-100, -101], [0]])).toBe("[[100,101],[-100,-101],[0]]");
+});
+
+describe("Should serialize nested float arrays", () => {
+  expect(JSON.stringify<f64[][]>([[7.23], [10e2], [10e2], [123456e-5], [123456e-5], [0.0], [7.23]])).toBe("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]");
+});
+
+describe("Should serialize nested boolean arrays", () => {
+  expect(JSON.stringify<bool[][]>([[true], [false]])).toBe("[[true],[false]]");
+
+  expect(JSON.stringify<boolean[][]>([[true], [false]])).toBe("[[true],[false]]");
+});
+
+describe("Should serialize object arrays", () => {
+  expect(
+    JSON.stringify<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}]');
+});
+
+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<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]");
+});
+
+describe("Should deserialize float arrays", () => {
+  expect(JSON.stringify(JSON.parse<f64[]>("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]"))).toBe("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]");
+  expect(JSON.stringify(JSON.parse<f64[]>("[1e+21,1e+22,1e-7,1e-8,1e-9]"))).toBe("[1e+21,1e+22,1e-7,1e-8,1e-9]");
+});
+
+describe("Should deserialize boolean arrays", () => {
+  expect(JSON.stringify(JSON.parse<bool[]>("[true,false]"))).toBe("[true,false]");
+  expect(JSON.stringify(JSON.parse<boolean[]>("[true,false]"))).toBe("[true,false]");
+});
+
+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"]');
+});
+
+describe("Should deserialize nested integer arrays", () => {
+  expect(JSON.stringify(JSON.parse<i64[][]>("[[100,101],[-100,-101],[0]]"))).toBe("[[100,101],[-100,-101],[0]]");
+});
+
+describe("Should deserialize nested float arrays", () => {
+  expect(JSON.stringify(JSON.parse<f64[][]>("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]"))).toBe("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]");
+});
+
+describe("Should deserialize nested boolean arrays", () => {
+  expect(JSON.stringify(JSON.parse<bool[][]>("[[true],[false]]"))).toBe("[[true],[false]]");
+  expect(JSON.stringify(JSON.parse<boolean[][]>("[[true],[false]]"))).toBe("[[true],[false]]");
+});
 
 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}]');
 });
 
+describe("Should deserialize raw arrays", () => {
+  const r1 = JSON.parse<JSON.Raw[]>('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]');
+  expect(r1[0].toString()).toBe('{"x":3.4,"y":1.2,"z":8.3}');
+  expect(r1[1].toString()).toBe('{"x":3.4,"y":-2.1,"z":9.3}');
+
+  const r2 = JSON.parse<JSON.Raw[][]>('[[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}],[{"x":0.1,"y":-7.3,"z":4.5}]]');
+  expect(r2[0][0].toString()).toBe('{"x":3.4,"y":1.2,"z":8.3}');
+  expect(r2[0][1].toString()).toBe('{"x":3.4,"y":-2.1,"z":9.3}');
+  expect(r2[1][0].toString()).toBe('{"x":0.1,"y":-7.3,"z":4.5}');
+
+  const r3 = JSON.parse<JSON.Raw[]>("[1,2,3,4,5]");
+  expect(r3[0]).toBe(1);
+  expect(r3[1]).toBe(2);
+  expect(r3[2]).toBe(3);
+  expect(r3[3]).toBe(4);
+  expect(r3[4]).toBe(5);
+
+  const r4 = JSON.parse<JSON.Raw[][]>("[[1,2,3,4,5],[6,7,8,9,10]]");
+  expect(r4[0][0]).toBe(1);
+  expect(r4[0][1]).toBe(2);
+  expect(r4[0][2]).toBe(3);
+  expect(r4[0][3]).toBe(4);
+  expect(r4[0][4]).toBe(5);
+
+  expect(r4[1][0]).toBe(6);
+  expect(r4[1][1]).toBe(7);
+  expect(r4[1][2]).toBe(8);
+  expect(r4[1][3]).toBe(9);
+  expect(r4[1][4]).toBe(10);
+
+  const r5 = JSON.parse<JSON.Raw[]>('[{"x":3.4,"y":1.2,"z":8.3},[1,2,3,4,5],"12345",true,false,null,[[]]]');
+  expect(r5[0].toString()).toBe('{"x":3.4,"y":1.2,"z":8.3}');
+  expect(r5[1].toString()).toBe("[1,2,3,4,5]");
+  expect(r5[2]).toBe('"12345"');
+  expect(r5[3]).toBe(true);
+  expect(r5[4]).toBe(false);
+  expect(r5[5]).toBe(null);
+  expect(r5[6].toString()).toBe("[[]]");
+});
+
 
 @json
 class Vec3 {
   x: f64 = 0.0;
   y: f64 = 0.0;
   z: f64 = 0.0;
-  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {
-    let keyStart: usize = 0;
-    let keyEnd: usize = 0;
-    let isKey = false;
-    let lastIndex: usize = 0;
-
-    while (srcStart < srcEnd && JSON.Util.isSpace(load<u16>(srcStart))) srcStart += 2;
-    while (srcEnd > srcStart && JSON.Util.isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
-    if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
-    if (load<u16>(srcStart) != 123) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
-    if (load<u16>(srcEnd - 2) != 125) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
-    srcStart += 2;
-
-    while (srcStart < srcEnd) {
-      let code = load<u16>(srcStart);
-      while (JSON.Util.isSpace(code)) code = load<u16>((srcStart += 2));
-      if (keyStart == 0) {
-        if (code == 34 && load<u16>(srcStart - 2) !== 92) {
-          if (isKey) {
-            keyStart = lastIndex;
-            keyEnd = srcStart;
-            while (JSON.Util.isSpace((code = load<u16>((srcStart += 2))))) {}
-            if (code !== 58) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
-            isKey = false;
-          } else {
-            isKey = true;
-            lastIndex = srcStart + 2;
-          }
-        }
-        srcStart += 2;
-      } else {
-        if (code - 48 <= 9 || code == 45) {
-          lastIndex = srcStart;
-          srcStart += 2;
-          while (srcStart < srcEnd) {
-            const code = load<u16>(srcStart);
-            if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {
-              switch (<u32>keyEnd - <u32>keyStart) {
-                case 2: {
-                  const code16 = load<u16>(keyStart);
-                  if (code16 == 120) {
-                    // x
-                    store<f64>(changetype<usize>(out), JSON.__deserialize<f64>(lastIndex, srcStart), offsetof<this>("x"));
-                    keyStart = 0;
-                    break;
-                  } else if (code16 == 121) {
-                    // y
-                    store<f64>(changetype<usize>(out), JSON.__deserialize<f64>(lastIndex, srcStart), offsetof<this>("y"));
-                    keyStart = 0;
-                    break;
-                  } else if (code16 == 122) {
-                    // z
-                    store<f64>(changetype<usize>(out), JSON.__deserialize<f64>(lastIndex, srcStart), offsetof<this>("z"));
-                    keyStart = 0;
-                    break;
-                  }
-                }
-              }
-              break;
-            }
-            srcStart += 2;
-          }
-        } else {
-          srcStart += 2;
-        }
-      }
-    }
-    return out;
-  }
 }

package/assembly/__tests__/generics.spec.ts

@@ -1,40 +1,49 @@
 import { JSON } from "..";
 import { describe, expect } from "./lib";
 
+
 @json
 class GenericTest<T> {
-    public foo: T;
+  public foo: T;
 
-    constructor(foo: T) {
-        this.foo = foo;
-    }
+  constructor(foo: T) {
+    this.foo = foo;
+  }
 }
 
+
 @json
 class Vec3 {
-    public x!: i32;
-    public y!: i32;
-    public z!: i32;
+  public x!: i32;
+  public y!: i32;
+  public z!: i32;
 }
 
 describe("Should serialize generics", () => {
-    expect(JSON.stringify(new GenericTest<string>("bar"))).toBe('{"foo":"bar"}');
-    expect(JSON.stringify(new GenericTest<i32>(42))).toBe('{"foo":42}');
-    expect(JSON.stringify(new GenericTest<boolean>(true))).toBe('{"foo":true}');
-    expect(JSON.stringify(new GenericTest<Vec3>({ x: 1, y: 2, z: 3 }))).toBe('{"foo":{"x":1,"y":2,"z":3}}');
-    expect(JSON.stringify(new GenericTest<string[]>(["item1", "item2"]))).toBe('{"foo":["item1","item2"]}');
-    expect(JSON.stringify(new GenericTest<Vec3[]>([{ x: 1, y: 2, z: 3 }, { x: 4, y: 5, z: 6 }]))).toBe('{"foo":[{"x":1,"y":2,"z":3},{"x":4,"y":5,"z":6}]}');
-    expect(JSON.stringify(new GenericTest<i32[]>([1, 2, 3]))).toBe('{"foo":[1,2,3]}');
-    expect(JSON.stringify(new GenericTest<boolean[]>([true, false, true]))).toBe('{"foo":[true,false,true]}');
+  expect(JSON.stringify(new GenericTest<string>("bar"))).toBe('{"foo":"bar"}');
+  expect(JSON.stringify(new GenericTest<i32>(42))).toBe('{"foo":42}');
+  expect(JSON.stringify(new GenericTest<boolean>(true))).toBe('{"foo":true}');
+  expect(JSON.stringify(new GenericTest<Vec3>({ x: 1, y: 2, z: 3 }))).toBe('{"foo":{"x":1,"y":2,"z":3}}');
+  expect(JSON.stringify(new GenericTest<string[]>(["item1", "item2"]))).toBe('{"foo":["item1","item2"]}');
+  expect(
+    JSON.stringify(
+      new GenericTest<Vec3[]>([
+        { x: 1, y: 2, z: 3 },
+        { x: 4, y: 5, z: 6 },
+      ]),
+    ),
+  ).toBe('{"foo":[{"x":1,"y":2,"z":3},{"x":4,"y":5,"z":6}]}');
+  expect(JSON.stringify(new GenericTest<i32[]>([1, 2, 3]))).toBe('{"foo":[1,2,3]}');
+  expect(JSON.stringify(new GenericTest<boolean[]>([true, false, true]))).toBe('{"foo":[true,false,true]}');
 });
 
 describe("Should deserialize generics", () => {
-    expect(JSON.parse<GenericTest<string>>('{"foo":"bar"}').foo).toBe("bar");
-    expect(JSON.parse<GenericTest<i32>>('{"foo":42}').foo.toString()).toBe("42");
-    expect(JSON.parse<GenericTest<boolean>>('{"foo":true}').foo).toBe(true);
-    expect(JSON.stringify(JSON.parse<GenericTest<Vec3>>('{"foo":{"x":1,"y":2,"z":3}}'))).toBe('{"foo":{"x":1,"y":2,"z":3}}');
-    expect(JSON.stringify(JSON.parse<GenericTest<string[]>>('{"foo":["item1","item2"]}'))).toBe('{"foo":["item1","item2"]}');
-    expect(JSON.stringify(JSON.parse<GenericTest<Vec3[]>>('{"foo":[{"x":1,"y":2,"z":3},{"x":4,"y":5,"z":6}]}'))).toBe('{"foo":[{"x":1,"y":2,"z":3},{"x":4,"y":5,"z":6}]}');
-    expect(JSON.stringify(JSON.parse<GenericTest<i32[]>>('{"foo":[1,2,3]}'))).toBe('{"foo":[1,2,3]}');
-    expect(JSON.stringify(JSON.parse<GenericTest<boolean[]>>('{"foo":[true,false,true]}'))).toBe('{"foo":[true,false,true]}');
+  expect(JSON.parse<GenericTest<string>>('{"foo":"bar"}').foo).toBe("bar");
+  expect(JSON.parse<GenericTest<i32>>('{"foo":42}').foo.toString()).toBe("42");
+  expect(JSON.parse<GenericTest<boolean>>('{"foo":true}').foo).toBe(true);
+  expect(JSON.stringify(JSON.parse<GenericTest<Vec3>>('{"foo":{"x":1,"y":2,"z":3}}'))).toBe('{"foo":{"x":1,"y":2,"z":3}}');
+  expect(JSON.stringify(JSON.parse<GenericTest<string[]>>('{"foo":["item1","item2"]}'))).toBe('{"foo":["item1","item2"]}');
+  expect(JSON.stringify(JSON.parse<GenericTest<Vec3[]>>('{"foo":[{"x":1,"y":2,"z":3},{"x":4,"y":5,"z":6}]}'))).toBe('{"foo":[{"x":1,"y":2,"z":3},{"x":4,"y":5,"z":6}]}');
+  expect(JSON.stringify(JSON.parse<GenericTest<i32[]>>('{"foo":[1,2,3]}'))).toBe('{"foo":[1,2,3]}');
+  expect(JSON.stringify(JSON.parse<GenericTest<boolean[]>>('{"foo":[true,false,true]}'))).toBe('{"foo":[true,false,true]}');
 });

package/assembly/__tests__/lib/index.ts

@@ -13,7 +13,7 @@ export function expect<T>(left: T): Expectation {
   // @ts-ignore
   if (!isDefined(left.toString)) throw new Error("Expected left to have a toString method, but it does not.");
   // @ts-ignore
-  return new Expectation(left == null ? "null" : left.toString());
+  return new Expectation(isNull(left) ? "null" : left.toString());
 }
 
 class Expectation {
@@ -26,12 +26,16 @@ class Expectation {
     // @ts-ignore
     if (!isDefined(right.toString)) throw new Error("Expected right to have a toString method, but it does not.");
     // @ts-ignore
-    if (this.left != (right == null ? "null" : right.toString())) {
+    if (this.left != (isNull(right) ? "null" : right.toString())) {
       console.log("  " + currentDescription + "\n");
       // @ts-ignore
-      console.log("  (expected) -> " + (right == null ? "null" : right.toString()));
+      console.log("  (expected) -> " + (isNull(right) ? "null" : right.toString()));
       console.log("  (received) -> " + this.left);
       unreachable();
     }
   }
 }
+
+function isNull<T>(value: T): bool {
+  return (isInteger<T>() && !isSigned<T>() && nameof<T>() == "usize" && value == 0) || (isNullable<T>() && changetype<usize>(value) == <usize>0);
+}

package/assembly/__tests__/resolving.spec.ts

@@ -2,14 +2,20 @@ import { JSON } from "..";
 import { describe, expect } from "./lib";
 import { Vec3 } from "./types";
 
+
 @json
 class Player {
+
   @alias("first name")
   firstName!: string;
   lastName!: string;
   lastActive!: i32[];
+
+
   @omitif((self: Player) => self.age < 18)
   age!: i32;
+
+
   @omitnull()
   pos!: Vec3 | null;
   isVerified!: boolean;
@@ -28,20 +34,22 @@ const player: Player = {
   isVerified: true,
 };
 
+
 @json
 class Foo {
-    bar: Bar = new Bar();
+  bar: Bar = new Bar();
 }
 
+
 @json
 class Bar {
-    baz: string = "buz"
+  baz: string = "buz";
 }
 
 describe("Should resolve imported schemas", () => {
-    expect(JSON.stringify(player)).toBe('{"age":18,"pos":{"x":3.4,"y":1.2,"z":8.3},"first name":"Jairus","lastName":"Tanaka","lastActive":[3,9,2025],"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":[3,9,2025],"isVerified":true}');
 });
 
 describe("Should resolve local schemas", () => {
-    expect(JSON.stringify(new Foo())).toBe('{"bar":{"baz":"buz"}}');
-});
+  expect(JSON.stringify(new Foo())).toBe('{"bar":{"baz":"buz"}}');
+});

package/assembly/__tests__/staticarray.spec.ts

@@ -0,0 +1,12 @@
+import { JSON } from "..";
+import { describe, expect } from "./lib";
+
+describe("Should serialize integer static arrays", () => {
+  expect(JSON.stringify<StaticArray<u32>>([0, 100, 101])).toBe("[0,100,101]");
+
+  expect(JSON.stringify<StaticArray<u64>>([0, 100, 101])).toBe("[0,100,101]");
+
+  expect(JSON.stringify<StaticArray<i32>>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
+
+  expect(JSON.stringify<StaticArray<i64>>([0, 100, 101, -100, -101])).toBe("[0,100,101,-100,-101]");
+});

package/assembly/__tests__/types.spec.ts

@@ -7,6 +7,7 @@ type StringAlias2 = StringAlias1;
 type StringAlias3 = StringAlias2;
 type StringAlias4 = StringAlias3;
 
+
 @json
 class Alias {
   public foo: StringAlias4 = "";
@@ -18,9 +19,9 @@ class Alias {
 const alias = new Alias("bar");
 
 describe("Should serialize with type aliases", () => {
-    expect(JSON.stringify(alias)).toBe('{"foo":"bar"}');
+  expect(JSON.stringify(alias)).toBe('{"foo":"bar"}');
 });
 
 describe("Should deserialize with type aliases", () => {
-    expect(JSON.stringify(JSON.parse<Alias>('{"foo":"bar"}'))).toBe('{"foo":"bar"}');
+  expect(JSON.stringify(JSON.parse<Alias>('{"foo":"bar"}'))).toBe('{"foo":"bar"}');
 });

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

@@ -0,0 +1,106 @@
+import { isSpace } from "../../../util";
+import { COMMA, BRACKET_RIGHT, QUOTE, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BACK_SLASH, CHAR_T, CHAR_F, CHAR_N } from "../../../custom/chars";
+import { JSON } from "../../..";
+import { ptrToStr } from "../../../util/ptrToStr";
+
+export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize): JSON.Raw[] {
+  // console.log("data: " + ptrToStr(srcStart, srcEnd));
+  const out = changetype<JSON.Raw[]>(dst || changetype<usize>(instantiate<JSON.Raw[]>()));
+  let lastIndex: usize = 0;
+  let depth = 0;
+  srcStart += 2;
+  while (srcStart < srcEnd) {
+    let code = load<u16>(srcStart);
+    if (code == QUOTE) {
+      lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        code = load<u16>(srcStart);
+        if (code == QUOTE || isSpace(code)) {
+          // console.log("Value (string): " + ptrToStr(lastIndex, srcStart));
+          out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart + 2)));
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          srcStart += 4;
+          break;
+        }
+        srcStart += 2;
+      }
+    } else if (code - 48 <= 9 || code == 45) {
+      lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
+          // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
+          out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart)));
+          srcStart += 2;
+          break;
+        }
+        srcStart += 2;
+      }
+    } else if (code == BRACE_LEFT) {
+      lastIndex = srcStart;
+      depth++;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == QUOTE) {
+          srcStart += 2;
+          while (!(load<u16>(srcStart) == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)) srcStart += 2;
+        } else if (code == BRACE_RIGHT) {
+          if (--depth == 0) {
+            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
+            out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart + 2)));
+            srcStart += 4;
+            break;
+          }
+        } else if (code == BRACE_LEFT) depth++;
+        srcStart += 2;
+      }
+    } else if (code == BRACKET_LEFT) {
+      lastIndex = srcStart;
+      depth++;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        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));
+            out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart + 2)));
+            srcStart += 4;
+            break;
+          }
+        } else if (code == BRACKET_LEFT) depth++;
+        srcStart += 2;
+      }
+    } else if (code == CHAR_T) {
+      if (load<u64>(srcStart) == 28429475166421108) {
+        // console.log("Value (true): " + ptrToStr(srcStart, srcStart + 8));
+        out.push(JSON.Raw.from("true"));
+        srcStart += 10;
+      }
+    } else if (code == CHAR_F) {
+      if (load<u64>(srcStart, 2) == 28429466576093281) {
+        // console.log("Value (false): " + ptrToStr(srcStart, srcStart + 10));
+        out.push(JSON.Raw.from("false"));
+        srcStart += 12;
+      }
+    } else if (code == CHAR_N) {
+      if (load<u64>(srcStart) == 30399761348886638) {
+        // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
+        out.push(JSON.Raw.from("null"));
+        srcStart += 10;
+      }
+    } else if (isSpace(code)) {
+      srcStart += 2;
+    } else {
+      throw new Error("Unexpected character in JSON object '" + String.fromCharCode(code) + "' at position " + (srcEnd - srcStart).toString() + " " + ptrToStr(lastIndex, srcStart + 10));
+    }
+  }
+  return out;
+}