json-as 1.0.0-beta.9 → 1.0.0

package/{CHANGELOG → CHANGELOG.md}

@@ -1,5 +1,46 @@
 # Change Log
 
+## 2025-03-09 - 1.0.0
+
+- fix: relative paths pointing through node_modules would create a second Source
+- feat: move behavior of `--lib` into transform itself
+- fix: object with an object as a value containing a rhs bracket or brace would exit early [3b33e94](https://github.com/JairusSW/json-as/commit/3b33e9414dc04779d22d65272863372fcd7af4a6)
+
+## 2025-03-04 - 1.0.0-beta.17
+
+- fix: forgot to build transform
+
+## 2025-03-04 - 1.0.0-beta.16
+
+- fix: isPrimitive should only trigger on actual primitives
+
+## 2025-03-04 - 1.0.0-beta.15
+
+- fix: deserialize custom should take in string
+
+## 2025-03-04 - 1.0.0-beta.14
+
+- fix: reference to nonexistent variable during custom deserialization layer 2
+
+## 2025-03-04 - 1.0.0-beta.13
+
+- fix: forgot to actually build the transform
+
+## 2025-03-04 - 1.0.0-beta.12
+
+- fix: build transform
+
+## 2025-03-04 - 1.0.0-beta.11
+
+- fix: wrongly assumed pointer types within arbitrary deserialization
+- fix: wrong pointer type being passed during map deserialization
+
+## 2025-03-04 - 1.0.0-beta.10
+
+- fix: transform not generating the right load operations for keys
+- fix: whitespace not working in objects or struct deserialization
+- fix: JSON.Raw not working when deserializing as Map<string, JSON.Raw>
+
 ## 2025-03-03 - 1.0.0-beta.9
 
 - rename: change libs folder to lib

package/README.md

@@ -6,7 +6,7 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.0.0-beta.9
+    AssemblyScript - v1.0.0
   </pre>
 </h5>
 
@@ -14,6 +14,20 @@
 
 JSON is the de-facto serialization format of modern web applications, but its serialization and deserialization remain a significant performance bottleneck, especially at scale. Traditional parsing approaches are computationally expensive, adding unnecessary overhead to both clients and servers. This library is designed to mitigate this by leveraging SIMD acceleration and highly optimized transformations.
 
+## 🚨 What's new in v1.0.0
+
+🔹Breaking changes to the way custom serializers/deserializers function (See Custom Serializers below)
+
+🔹Major performance improvements and addition of SIMD
+
+🔹Extremely low memory overhead compared to pre-1.x.x versions (great for serverless workloads)
+
+🔹Fixes to many major issues and newly discovered bugs
+
+🔹Full support for dynamic objects, arrays, and values
+
+🔹Full support for `JSON.Raw` type everywhere
+
 ## 📚 Contents
 
 - [Installation](#-installation)
@@ -31,22 +45,21 @@ JSON is the de-facto serialization format of modern web applications, but its se
 ## 💾 Installation
 
 ```bash
-npm install json-as@1.0.0-beta.9
+npm install json-as
 ```
 
 Add the `--transform` to your `asc` command (e.g. in package.json)
 
 ```bash
---transform json-as/transform --lib json-as/lib
+--transform json-as/transform
 ```
 
 Alternatively, add it to your `asconfig.json`
 
-```json
+```typescript
 {
   "options": {
-    "transform": ["json-as/transform"],
-    "lib": ["json-as/lib"]
+    "transform": ["json-as/transform"]
   }
 }
 ```
@@ -55,7 +68,7 @@ If you'd like to see the code that the transform generates, run with `JSON_DEBUG
 
 ## 🪄 Usage
 
-```js
+```typescript
 import { JSON } from "json-as";
 
 @json
@@ -82,15 +95,15 @@ class Player {
 const player: Player = {
   firstName: "Jairus",
   lastName: "Tanaka",
-  lastActive: [2, 13, 2025],
+  lastActive: [3, 9, 2025],
   age: 18,
   pos: {
     x: 3.4,
     y: 1.2,
-    z: 8.3
+    z: 8.3,
   },
-  isVerified: true
-};
+  isVerified: true,
+}
 
 const serialized = JSON.stringify<Player>(player);
 const deserialized = JSON.parse<Player>(serialized);
@@ -109,26 +122,26 @@ This library allows selective omission of fields during serialization using the
 
 This decorator excludes a field from serialization entirely.
 
-```js
+```typescript
 @json
 class Example {
   name!: string;
   @omit
-  secret!: string;
+  SSN!: string;
 }
 
 const obj = new Example();
-obj.name = "Visible";
-obj.secret = "Hidden";
+obj.name = "Jairus";
+obj.SSN = "123-45-6789";
 
-console.log(JSON.stringify(obj)); // { "name": "Visible" }
+console.log(JSON.stringify(obj)); // { "name": "Jairus" }
 ```
 
 **@omitnull**
 
 This decorator omits a field only if its value is null.
 
-```js
+```typescript
 @json
 class Example {
   name!: string;
@@ -137,30 +150,36 @@ class Example {
 }
 
 const obj = new Example();
-obj.name = "Present";
+obj.name = "Jairus";
 obj.optionalField = null;
 
-console.log(JSON.stringify(obj)); // { "name": "Present" }
+console.log(JSON.stringify(obj)); // { "name": "Jairus" }
+```
 
-@omitif((self: this) => condition)
+**@omitif((self: this) => condition)**
 
 This decorator omits a field based on a custom predicate function.
 
+```typescript
 @json
 class Example {
   name!: string;
-  @omitif((self: Example) => self.age < 18)
+  @omitif((self: Example) => self.age <= 18)
   age!: number;
 }
 
 const obj = new Example();
-obj.name = "John";
-obj.age = 16;
+obj.name = "Jairus";
+obj.age = 18;
+
+console.log(JSON.stringify(obj)); // { "name": "Jairus" }
+
+obj.age = 99;
 
-console.log(JSON.stringify(obj)); // { "name": "John" }
+console.log(JSON.stringify(obj)); // { "name": "Jairus", "age": 99 }
 ```
 
-If age were 18 or higher, it would be included in the serialization.
+If age were higher than 18, it would be included in the serialization.
 
 ### 🗳️ Using nullable primitives
 
@@ -168,7 +187,7 @@ AssemblyScript doesn't support using nullable primitive types, so instead, json-
 
 For example, this schema won't compile in AssemblyScript:
 
-```js
+```typescript
 @json
 class Person {
   name!: string;
@@ -178,7 +197,7 @@ class Person {
 
 Instead, use `JSON.Box` to allow nullable primitives:
 
-```js
+```typescript
 @json
 class Person {
   name: string;
@@ -188,11 +207,11 @@ class Person {
   }
 }
 
-const person = new Person("Bob");
-console.log(JSON.stringify(person)); // {"name":"Bob","age":null}
+const person = new Person("Jairus");
+console.log(JSON.stringify(person)); // {"name":"Jairus","age":null}
 
 person.age = new JSON.Box<i32>(18); // Set age to 18
-console.log(JSON.stringify(person)); // {"name":"Bob","age":18}
+console.log(JSON.stringify(person)); // {"name":"Jairus","age":18}
 ```
 
 ### 📤 Working with unknown or dynamic data
@@ -205,31 +224,31 @@ Here's a few examples:
 
 **Working with multi-type arrays**
 
-When dealing with arrays that have multiple types within them, eg. `["string",true,null,["array"]]`, use `JSON.Value[]`
+When dealing with arrays that have multiple types within them, eg. `["string",true,["array"]]`, use `JSON.Value[]`
 
-```js
-const a1 = JSON.parse<JSON.Value[]>('["string",true,null,["array"]]');
+```typescript
+const a = JSON.parse<JSON.Value[]>('["string",true,["array"]]');
 console.log(JSON.stringify(a[0])); // "string"
 console.log(JSON.stringify(a[1])); // true
-console.log(JSON.stringify(a[2])); // null
-console.log(JSON.stringify(a[3])); // ["array"]
+console.log(JSON.stringify(a[2])); // ["array"]
 ```
 
 **Working with unknown objects**
 
 When dealing with an object with an unknown structure, use the `JSON.Obj` type
 
-```js
-const o1 = JSON.parse<JSON.Obj>('{"a":3.14,"b":true,"c":[1,2,3],"d":{"x":1,"y":2,"z":3}}');
+```typescript
+const obj = JSON.parse<JSON.Obj>('{"a":3.14,"b":true,"c":[1,2,3],"d":{"x":1,"y":2,"z":3}}');
 
-console.log(o1.keys().join(" ")); // a b c d
-console.log(
-  o1.values()
-  .map<string>((v) => JSON.stringify(v))
-  .join(" ")
+console.log("Keys: " + obj.keys().join(" ")); // a b c d
+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 = o1.get("d").get<JSON.Obj>().get<i32>();
+const y = obj.get("d")!.get<JSON.Obj>().get("y")!;
 console.log('o1["d"]["y"] = ' + y.toString()); // o1["d"]["y"] = 2
 ```
 
@@ -239,7 +258,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.
 
-```js
+```typescript
 @json
 class DynamicObj {
   id: i32 = 0;
@@ -267,24 +286,22 @@ Sometimes its necessary to simply copy a string instead of serializing it.
 
 For example, the following data would typically be serialized as:
 
-```js
-const m1 = new Map<string, string>();
-m1.set('pos', '{"x":1.0,"y":2.0,"z":3.0}');
+```typescript
+const map = new Map<string, string>();
+map.set("pos", '{"x":1.0,"y":2.0,"z":3.0}');
 
-const a1 = JSON.stringify(m1);
-console.log("a1: " + a1);
+console.log(JSON.stringify(map));
 // {"pos":"{\"x\":1.0,\"y\":2.0,\"z\":3.0}"}
 // pos's value (Vec3) is contained within a string... ideally, it should be left alone
 ```
 
 If, instead, one wanted to insert Raw JSON into an existing schema/data structure, they could make use of the JSON.Raw type to do so:
 
-```js
-const m1 = new Map<string, JSON.Raw>();
-m1.set('pos', new JSON.Raw('{"x":1.0,"y":2.0,"z":3.0}'));
+```typescript
+const map = new Map<string, JSON.Raw>();
+map.set("pos", new JSON.Raw('{"x":1.0,"y":2.0,"z":3.0}'));
 
-const a1 = JSON.stringify(m1);
-console.log("a1: " + a1);
+console.log(JSON.stringify(map));
 // {"pos":{"x":1.0,"y":2.0,"z":3.0}}
 // Now its properly formatted JSON where pos's value is of type Vec3 not string!
 ```
@@ -295,7 +312,9 @@ This library supports custom serialization and deserialization methods, which ca
 
 Here's an example of creating a custom data type called `Point` which serializes to `(x,y)`
 
-```js
+```typescript
+import { bytes } from "json-as/assembly/util";
+
 @json
 class Point {
   x: f64 = 0.0;
@@ -319,12 +338,17 @@ 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));
   }
 }
+
+const obj = new Point(3.5, -9.2);
+
+const serialized = JSON.stringify<Point>(obj);
+const deserialized = JSON.parse<Point>(serialized);
+
+console.log("Serialized    " + serialized);
+console.log("Deserialized  " + JSON.stringify(deserialized));
 ```
 
 The serializer function converts a `Point` instance into a string format `(x,y)`.
@@ -333,7 +357,7 @@ The deserializer function parses the string `(x,y)` back into a `Point` instance
 
 These functions are then wrapped before being consumed by the json-as library:
 
-```js
+```typescript
 @inline __SERIALIZE_CUSTOM(ptr: usize): void {
   const data = this.serializer(changetype<Point>(ptr));
   const dataSize = data.length << 1;
@@ -352,45 +376,27 @@ This allows custom serialization while maintaining a generic interface for the l
 
 The `json-as` library has been optimized to achieve near-gigabyte-per-second JSON processing speeds through SIMD acceleration and highly efficient transformations. Below are some key performance benchmarks to give you an idea of how it performs.
 
-### Raw Performance
-
-Simple
-
-| Test Case          | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
-| ------------------ | --------------------- | ----------------------- | -------------------- | ---------------------- |
-| Vector3 Object     | 32,642,320 ops/s      | 9,736,272 ops/s         | 1,240 MB/s           | 369 MB/s               |
-| Alphabet String    | 4,928,856 ops/s       | 7,567,360 ops/s         | 975 MB/s             | 1,498 MB/s             |
-| Small JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
-| Medium JSON Object | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
-| Large JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
-
-SIMD
-
-| Test Case          | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
-| ------------------ | --------------------- | ----------------------- | -------------------- | ---------------------- |
-| Vector3 Object     | 32,642,320 ops/s      | 9,736,272 ops/s         | 1,240 MB/s           | 369 MB/s               |
-| Alphabet String    | 20,368,584 ops/s      | 28,467,424 ops/s        | 3,910 MB/s           | 5,636 MB/s             |
-| Small JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
-| Medium JSON Object | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
-| Large JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+Note: the AssemblyScript benches are run using a _bump allocator_ so that Garbage Collection does not interfere with results. Also note that ideally, I would use [d8](https://v8.dev/docs/d8), but until that is done, these results serve as a temporary performance comparison.
 
-JavaScript
+**Table 1** - _AssemblyScript_
 
-| Test Case          | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
-| ------------------ | --------------------- | ----------------------- | -------------------- | ---------------------- |
-| Vector3 Object     | 2,548,013 ops/s       | 1,942,440 ops/s         | 97 MB/s              | 73 MB/s                |
-| Alphabet String    | 3,221,556 ops/s       | 2,716,617 ops/s         | 624 MB/s             | 537 MB/s               |
-| Small JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
-| Medium JSON Object | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
-| Large JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Test Case       | Size       | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
+| --------------- | ---------- | --------------------- | ----------------------- | -------------------- | ---------------------- |
+| Vector3 Object  | 38 bytes   | 35,714,285 ops/s      | 35,435,552 ops/s        | 1,357 MB/s           | 1,348 MB/s             |
+| Alphabet String | 104 bytes  | 13,617,021 ops/s      | 18,390,804 ops/s        | 1,416 MB/s           | 1,986 MB/s             |
+| Small Object    | 88 bytes   | 24,242,424 ops/s      | 12,307,692 ops/s        | 2,133 MB/s           | 1,083 MB/s             |
+| Medium Object   | 494 bytes  | 4,060,913 ops/s       | 1,396,160 ops/s         | 2,006 MB/s           | 689.7 MB/s             |
+| Large Object    | 3374 bytes | 614,754 ops/s         | 132,802 ops/s           | 2,074 MB/s           | 448.0 MB/s             |
 
-### Real-World Usage
+**Table 2** - _JavaScript_
 
-| Scenario         | JSON Size (kb) | Serialization Time (ops/s) | Deserialization Time (ops/s) | Throughput (GB/s) |
-| ---------------- | -------------- | -------------------------- | ---------------------------- | ----------------- |
-| Web API Response | [Fill Value]   | [Fill Value]               | [Fill Value]                 | [Fill Value]      |
-| Database Entry   | [Fill Value]   | [Fill Value]               | [Fill Value]                 | [Fill Value]      |
-| File Parsing     | [Fill Value]   | [Fill Value]               | [Fill Value]                 | [Fill Value]      |
+| Test Case       | Size       | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
+| --------------- | ---------- | --------------------- | ----------------------- | -------------------- | ---------------------- |
+| Vector3 Object  | 38 bytes   | 8,791,209 ops/s       | 5,369,12 ops/s          | 357.4 MB/s           | 204.3 MB/s             |
+| Alphabet String | 104 bytes  | 13,793,103 ops/s      | 14,746,544 ops/s        | 1,416 MB/s           | 1,592 MB/s             |
+| Small Object    | 88 bytes   | 8,376,963 ops/s       | 4,968,944 ops/s         | 737.1 MB/s           | 437.2 MB/s             |
+| Medium Object   | 494 bytes  | 2,395,210 ops/s       | 1,381,693 ops/s         | 1,183 MB/s           | 682.5 MB/s             |
+| Large Object    | 3374 bytes | 222,222 ops/s         | 117,233 ops/s           | 749.7 MB/s           | 395.5 MB/s             |
 
 ## 📃 License
 
@@ -403,4 +409,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/assembly/__tests__/array.spec.ts

@@ -58,6 +58,48 @@ describe("Should serialize object arrays", () => {
   ).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}]');
+});
+
 @json
 class Vec3 {
   x: f64 = 0.0;

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")).toBe(1e-7);
+  expect(JSON.parse<f64>("1e-7").toString()).toBe(1e-7.toString());
 
-  // expect(JSON.parse<f64>("100000000000000000000.0").toString()).toBe(1e20);
+  expect(JSON.parse<f64>("100000000000000000000.0").toString()).toBe(1e20.toString());
 
-  // expect(JSON.parse<f64>("1e+21")).toBe(1e21);
+  expect(JSON.parse<f64>("1e+21").toString()).toBe(1e21.toString());
 });

package/assembly/__tests__/map.spec.ts

@@ -0,0 +1,7 @@
+import { JSON } from "..";
+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

@@ -17,8 +17,7 @@ describe("Should serialize Map<string, JSON.Raw>", () => {
   expect(JSON.stringify(m1)).toBe('{"hello":"world","pos":{"x":1.0,"y":2.0,"z":3.0}}');
 });
 
-// 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}}');
-// });
+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

@@ -64,9 +64,9 @@ describe("Should deserialize structs with whitespace", () => {
   ).toBe('{"x":3.4,"y":1.2,"z":8.3}');
 });
 
-describe("Should serialize Suite struct", () => {
+// describe("Should serialize Suite struct", () => {
 
-});
+// });
 
 @json
 class BaseObject {

package/assembly/deserialize/simple/arbitrary.ts

@@ -4,14 +4,18 @@ import { deserializeBoolean } from "./bool";
 import { deserializeFloat } from "./float";
 import { deserializeString } from "./string";
 import { deserializeObject } from "./object";
+import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";
 
 export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value {
   const firstChar = load<u16>(srcStart);
-  if (firstChar == 34) return JSON.Value.from(deserializeString(srcStart, srcEnd, dst));
-  else if (firstChar == 123) return JSON.Value.from(deserializeObject(srcStart, srcEnd, dst));
+  if (firstChar == QUOTE) return JSON.Value.from(deserializeString(srcStart, srcEnd, 0));
+  else if (firstChar == BRACE_LEFT) return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
   else if (firstChar - 48 <= 9 || firstChar == 45) return JSON.Value.from(deserializeFloat<f64>(srcStart, srcEnd));
-  else if (firstChar == 91) {
-    return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, dst));
+  else if (firstChar == BRACKET_LEFT) {
+    return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, 0));
   } else if (firstChar == 116 || firstChar == 102) return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
+  else if (firstChar == CHAR_N) {
+    return JSON.Value.from(null);
+  }
   return unreachable();
 }

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

@@ -4,7 +4,7 @@ import { isSpace } from "util/string";
 import { ptrToStr } from "../../../util/ptrToStr";
 
 export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value[] {
-  const out = dst ? changetype<JSON.Value[]>(dst) : instantiate<JSON.Value[]>();
+  const out = changetype<JSON.Value[]>(dst || changetype<usize>(instantiate<JSON.Value[]>()));
   let lastIndex: usize = 0;
   let depth: u32 = 0;
   // if (load<u16>(srcStart) != BRACKET_LEFT)
@@ -121,12 +121,12 @@ export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: u
       }
     } else if (code == CHAR_N) {
       if (load<u64>(srcStart) == 30399761348886638) {
+        console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
         // @ts-ignore: type
-        out.push(JSON.__deserialize<JSON.Value>(lastIndex, (srcStart += 8)));
-        // console.log("Value (null): " + ptrToStr(srcStart - 8, srcStart));
-        while (isSpace(load<u16>((srcStart += 2)))) {
-          /* empty */
-        }
+        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 8)));
+        // while (isSpace(load<u16>((srcStart += 2)))) {
+        //   /* empty */
+        // }
       }
     }
     srcStart += 2;

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

@@ -2,15 +2,16 @@ import { BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../../";
 
 export function deserializeArrayArray<T extends unknown[][]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
   let lastIndex: usize = 0;
   let depth: u32 = 0;
-  while (srcStart < srcEnd) {
+  srcStart += 2;
+  while (srcStart < srcEnd - 2) {
     const code = load<u16>(srcStart);
     if (code == BRACKET_LEFT && depth++ == 0) {
       lastIndex = srcStart;
     } else if (code == BRACKET_RIGHT && --depth == 0) {
-      out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+      out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart + 2));
     }
     srcStart += 2;
   }

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

@@ -1,17 +1,17 @@
-import { CHAR_E, CHAR_F, CHAR_T } from "../../../custom/chars";
-
 export function deserializeBooleanArray<T extends boolean[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+  srcStart += 2; // skip [
   while (srcStart < srcEnd) {
-    const code = load<u16>(srcStart);
-    if (code == CHAR_T && load<u16>(srcStart, 8) == CHAR_E) {
+    const block = load<u64>(srcStart);
+    if (block == 28429475166421108) {
       out.push(true);
       srcStart += 10;
-    } else if (code == CHAR_F && load<u16>(srcStart, 10) == CHAR_E) {
+    } else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101) {
       out.push(false);
       srcStart += 12;
+    } else {
+      srcStart += 2;
     }
-    srcStart += 2;
   }
   return out;
 }

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

@@ -1,9 +1,9 @@
 import { isSpace } from "../../../util";
-import { COMMA, BRACE_RIGHT, BRACKET_RIGHT } from "../../../custom/chars";
+import { COMMA, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 
 export function deserializeFloatArray<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
   let lastIndex: usize = 0;
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);