json-as 1.0.0-alpha.4 → 1.0.0-beta.2

package/.trunk/configs/.markdownlint.yaml

@@ -0,0 +1,2 @@
+# Prettier friendly markdownlint config (all formatting rules disabled)
+extends: markdownlint/style/prettier

package/.trunk/configs/.shellcheckrc

@@ -0,0 +1,7 @@
+enable=all
+source-path=SCRIPTDIR
+disable=SC2154
+
+# If you're having issues with shellcheck following source, disable the errors via:
+# disable=SC1090
+# disable=SC1091

package/.trunk/configs/.yamllint.yaml

@@ -0,0 +1,7 @@
+rules:
+  quoted-strings:
+    required: only-when-needed
+    extra-allowed: ["{|}"]
+  key-duplicates: {}
+  octal-values:
+    forbid-implicit-octal: true

package/.trunk/trunk.yaml

@@ -0,0 +1,36 @@
+# This file controls the behavior of Trunk: https://docs.trunk.io/cli
+# To learn more about the format of this file, see https://docs.trunk.io/reference/trunk-yaml
+version: 0.1
+cli:
+  version: 1.22.10
+# Trunk provides extensibility via plugins. (https://docs.trunk.io/plugins)
+plugins:
+  sources:
+    - id: trunk
+      ref: v1.6.7
+      uri: https://github.com/trunk-io/plugins
+# Many linters and tools depend on runtimes - configure them here. (https://docs.trunk.io/runtimes)
+runtimes:
+  enabled:
+    - go@1.21.0
+    - node@18.20.5
+    - python@3.10.8
+# This is the section where you manage your linters. (https://docs.trunk.io/check/configuration)
+lint:
+  enabled:
+    - actionlint@1.7.7
+    - checkov@3.2.374
+    - git-diff-check
+    - markdownlint@0.44.0
+    - prettier@3.5.2
+    - shellcheck@0.10.0
+    - shfmt@3.6.0
+    - trufflehog@3.88.12
+    - yamllint@1.35.1
+actions:
+  disabled:
+    - trunk-announce
+    - trunk-check-pre-push
+    - trunk-fmt-pre-commit
+  enabled:
+    - trunk-upgrade-available

package/CHANGELOG

@@ -1,5 +1,28 @@
 # Change Log
 
+## 2025-02-25 - 1.0.0-beta.2
+
+- feat: add support for custom serializers and deserializers [#110](https://github.com/JairusSW/as-json/pull/110)
+
+## 2025-02-22 - 1.0.0-beta.1
+
+- perf: add benchmarks for both AssemblyScript and JavaScript
+- docs: publish preliminary benchmark results
+- tests: ensure nested serialization works and add to tests
+- feat: finish arbitrary type implementation
+- feat: introduce `JSON.Obj` to handle objects effectively
+- feat: reimplement arbitrary array deserialization
+- fix: remove brace check on array deserialization
+- feat: introduce native support for `JSON.Obj` transformations
+- feat: implement arbitrary object serialization
+- fix: deserialization of booleans panics on `false`
+- fix: `bs.resize` should be type-safe
+- impl: add `JSON.Obj` type as prototype to handle arbitrary object structures
+- chore: rename static objects (schemas) to structs and name arbitrary objects as `obj`
+- tests: add proper tests for arbitrary types
+- fix: empty method generation using outdated function signature
+- docs: update readme to be more concise
+
 ## 2025-02-13 - 1.0.0-alpha.4
 
 - feat: reintroduce support for `Box<T>`-wrapped primitive types

package/README.md

@@ -6,47 +6,48 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.0.0-alpha.4
+    AssemblyScript - v1.0.0-beta.2
   </pre>
 </h5>
 
-## Contents
- - [About](#about)
- - [Installation](#installation)
- - [Usage](#usage)
- - [Examples](#examples)
- - [Performance](#performance)
- - [License](#license)
- - [Contact](#contact)
+## 📚 Contents
 
-## About
+- [About](#-about)
+- [Installation](#-installation)
+- [Usage](#-usage)
+- [Examples](#examples)
+- [Performance](#-performance)
+- [License](#-license)
+- [Contact](#-contact)
 
-## Installation
+## 📝 About
+
+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.
+
+## 💾 Installation
 
 ```bash
-npm install json-as@1.0.0-alpha.3
+npm install json-as@1.0.0-beta.2
 ```
 
 Add the `--transform` to your `asc` command (e.g. in package.json)
 
 ```bash
---transform json-as
+--transform json-as/transform
 ```
 
 Alternatively, add it to your `asconfig.json`
 
-```
+```json
 {
   // ...
-  "options": {
-    "transform": ["json-as/transform"]
-  }
+  "options": {"transform": ["json-as/transform"]}
 }
 ```
 
 If you'd like to see the code that the transform generates, run with `JSON_DEBUG=true`
 
-## Usage
+## 🪄 Usage
 
 ```js
 import { JSON } from "json-as";
@@ -75,7 +76,7 @@ class Player {
 const player: Player = {
   firstName: "Jairus",
   lastName: "Tanaka",
-  lastActive: [2, 7, 2025],
+  lastActive: [2, 13, 2025],
   age: 18,
   pos: {
     x: 3.4,
@@ -86,56 +87,57 @@ const player: Player = {
 };
 
 const serialized = JSON.stringify<Player>(player);
-const parsed = JSON.parse<Player>(serialized);
+const deserialized = JSON.parse<Player>(serialized);
 
-console.log("Serialized: " + serialized);
-console.log("Parsed: " + JSON.stringify(parsed));
+console.log("Serialized    " + serialized);
+console.log("Deserialized  " + JSON.stringify(deserialized));
 ```
 
 ## Examples
 
-Classes can even have inheritance. Here's a nasty example
+## ⚡ Performance
 
-```js
-@json
-class Base {}
+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.
 
-@json
-class Vec1 extends Base {
-  x: f32 = 1.0;
-}
-@json
-class Vec2 extends Vec1 {
-  y: f32 = 2.0;
-}
-@json
-class Vec3 extends Vec2 {
-  z: f32 = 3.0;
-}
+### Raw Performance
 
-const arr: Base[] = [
-  new Vec1(),
-  new Vec2(),
-  new Vec3()
-];
+Simple
 
-const serialized = JSON.stringify(arr);
-// [{"x":1.0},{"x":1.0,"y":2.0},{"y":2.0,"x":1.0,"z":3.0}]
-const parsed = JSON.parse<Base[]>(serialized);
-```
+| 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]           |
 
-You can also add it to your `asconfig.json`
+SIMD
 
-```json
-{
-  // ...
-  "options": {
-    "transform": ["json-as/transform"]
-  }
-}
-```
+| 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]           |
+
+JavaScript
+
+| 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]           |
+
+### Real-World Usage
 
-If you use this project in your codebase, consider dropping a [star](https://github.com/JairusSW/as-json). I would really appreciate it!
+| 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]      |
 
 ## 📃 License
 

package/assembly/__benches__/misc.bench.ts

@@ -0,0 +1,48 @@
+import { bench } from "as-bench/assembly";
+import { JSON } from "..";
+import { Vec3 } from "./schemas";
+import { bs } from "../../modules/as-bs/assembly";
+import { serializeString_SIMD } from "../serialize/simd/string";
+import { serializeString } from "../serialize/simple/string";
+import { deserializeString } from "../deserialize/simple/string";
+import { bytes } from "../util";
+import { deserializeString_SIMD } from "../deserialize/simd/string";
+
+const vec: Vec3 = {
+  x: 1,
+  y: 2,
+  z: 3
+}
+
+bs.ensureSize(4096);
+// bench("Serialize Vector3", () => {
+//   JSON.stringify(vec);
+// });
+
+// bench("Deserialize Vector3", () => {
+//   JSON.parse<Vec3>('{"x":1,"y":2,"z":3}');
+// });
+
+// bench("Serialize String SIMD", () => {
+//   serializeString_SIMD("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\:;\"'?/>.<,'\"}");
+//   bs.offset = changetype<usize>(bs.buffer);
+//   bs.stackSize = 0;
+// });
+
+// bench("Serialize String", () => {
+//   serializeString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\:;\"'?/>.<,'\"}");
+//   bs.offset = changetype<usize>(bs.buffer);
+//   bs.stackSize = 0;
+// });
+
+const src = '"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\\\:;\\"\'?/>.<,\'\\"}"';
+const srcStart = changetype<usize>(src);
+const srcEnd = srcStart + bytes(src);
+const out = changetype<usize>(new ArrayBuffer(256));
+bench("Deserialize String", () => {
+  deserializeString(srcStart, srcEnd, out);
+});
+
+bench("Deserialize String SIMD", () => {
+  deserializeString_SIMD(srcStart, srcEnd, out);
+})

package/assembly/__benches__/schemas.ts

@@ -0,0 +1,25 @@
+import { JSON } from "..";
+
+@json
+export class Vec3 {
+  public x!: i32;
+  public y!: i32;
+  public z!: i32;
+  __DESERIALIZE(keyStart: usize, keyEnd: usize, valStart: usize, valEnd: usize, ptr: usize): void {
+    switch (load<u16>(keyStart)) {
+      case 120: { // x
+        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("x"));
+        return;
+      }
+      case 121: { // y
+        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("y"));
+        return;
+      }
+      case 122: { // z
+        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("z"));
+        return;
+      }
+    }
+    return;
+  }
+}

package/assembly/__benches__/string.bench.ts

@@ -0,0 +1,24 @@
+import {JSON} from "..";
+import {Vec3} from "./schemas";
+import {bs} from "../../modules/as-bs/assembly";
+import {bench} from "../custom/bench";
+import {serializeString_SIMD} from "../serialize/simd/string";
+import {deserializeString_SIMD} from "../deserialize/simd/string";
+import {serializeString} from "../serialize/simple/string";
+import {deserializeString} from "../deserialize/simple/string";
+
+const vec: Vec3 = {x: 1, y: 2, z: 3};
+
+bs.ensureSize(4096);
+
+bench(
+  "Serialize String (Simple)",
+  () => {
+    serializeString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\:;\"'?/>.<,'\"}");
+  },
+  25_000_000
+);
+
+// bench("Deserialize String Simple", () => {
+//   deserializeString_SIMD("\"hello world\"")
+// });

package/assembly/__benches__/struct.bench.ts

@@ -0,0 +1,22 @@
+import {JSON} from "..";
+import {Vec3} from "./schemas";
+import {bs} from "../../modules/as-bs/assembly";
+import {bench} from "./bench";
+
+const vec: Vec3 = {x: 1, y: 2, z: 3};
+
+bs.ensureSize(4096);
+bench(
+  "Serialize Vector3",
+  () => {
+    // JSON.__serialize(vec);
+    // bs.offset = changetype<usize>(bs.buffer);
+    // bs.stackSize = 0;
+    JSON.stringify(vec);
+  },
+  25_000_000
+);
+
+// bench("Deserialize Vector3", () => {
+//   JSON.parse<Vec3>('{"x":1,"y":2,"z":3}');
+// });

package/assembly/__tests__/arbitrary.spec.ts

@@ -0,0 +1,19 @@
+import { JSON } from "..";
+import { describe, expect } from "../../modules/test/assembly";
+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(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}');
+  expect(JSON.stringify([JSON.Value.from("string"), JSON.Value.from(true), JSON.Value.from(3.14), JSON.Value.from(new Vec3())])).toBe('["string",true,3.14,{"x":1.0,"y":2.0,"z":3.0}]');
+});
+
+describe("Should deserialize arbitrary types", () => {
+  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__/custom.spec.ts

@@ -0,0 +1,42 @@
+import { JSON } from "..";
+import { describe, expect } from "../../modules/test/assembly";
+import { bytes } from "../util";
+
+@json
+class Point {
+  x: f64 = 0.0;
+  y: f64 = 0.0;
+  constructor(x: f64, y: f64) {
+    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);
+    if (dataSize <= 2) throw new Error("Could not deserialize provided data as type Point");
+
+    const c = data.indexOf(",");
+    const x = data.slice(1, c);
+    const y = data.slice(c + 1, data.length - 1);
+
+    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)");
+});
+
+describe("Should deserialize using custom deserializers", () => {
+  const p1 = JSON.parse<Point>("(1.0,2.0)");
+  expect(p1.x.toString()).toBe("1.0");
+  expect(p1.y.toString()).toBe("2.0");
+});

package/assembly/__tests__/types.ts

@@ -61,9 +61,9 @@ export class Map4 {
 
 @json
 export class Vec3 {
-  x: f64;
-  y: f64;
-  z: f64;
+  x: f64 = 1.0;
+  y: f64 = 2.0;
+  z: f64 = 3.0;
 
   static shouldIgnore: string = "should not be serialized";
 }

package/assembly/custom/bench.ts

@@ -0,0 +1,26 @@
+export function bench(description: string, routine: () => void, ops: u64 = 1_000_000): void {
+  console.log(" - Benchmarking " + description);
+  const start = Date.now();
+  let count = ops;
+  while (count != 0) {
+    routine();
+    count--;
+  }
+  const elapsed = Date.now() - start;
+
+  let opsPerSecond = (ops * 1000) / elapsed;
+
+  console.log(`   Completed benchmark in ${formatNumber(elapsed)}ms at ${formatNumber(opsPerSecond)} ops/s\n`);
+}
+
+function formatNumber(n: u64): string {
+  let str = n.toString();
+  let len = str.length;
+  let result = "";
+  let commaOffset = len % 3;
+  for (let i = 0; i < len; i++) {
+    if (i > 0 && (i - commaOffset) % 3 == 0) result += ",";
+    result += str.charAt(i);
+  }
+  return result;
+}

package/assembly/deserialize/simd/string.ts

@@ -10,7 +10,7 @@ const SPLAT_92 = i16x8.splat(92); /* \ */
  * @returns number of bytes written
  */
 // todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
-export function deserializeString_SIMD(src: string, srcStart: usize, srcEnd: usize, dst: usize): usize {
+export function deserializeString_SIMD(srcStart: usize, srcEnd: usize, dst: usize): usize {
   let src_ptr = srcStart + 2;
   let dst_ptr = changetype<usize>(dst);
 

package/assembly/deserialize/simple/arbitrary.ts

@@ -2,8 +2,8 @@ import { JSON } from "../..";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
 import { deserializeFloat } from "./float";
-import { deserializeObject } from "./object";
 import { deserializeString } from "./string";
+import { deserializeObject } from "./object";
 
 export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value {
   const firstChar = load<u16>(srcStart);

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

@@ -1,45 +1,66 @@
 import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, CHAR_F, CHAR_N, CHAR_T, COMMA, QUOTE } from "../../../custom/chars";
 import { JSON } from "../../../";
 import { isSpace } from "util/string";
+import { ptrToStr } from "../../../util/ptrToStr";
 
-export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value[] {
-  const out = dst ? changetype<T>(dst) : instantiate<T>();
+export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value[] {
+  const out = dst ? changetype<JSON.Value[]>(dst) : instantiate<JSON.Value[]>();
   let lastIndex: usize = 0;
   let depth: u32 = 0;
+  // if (load<u16>(srcStart) != BRACKET_LEFT)
+  srcStart += 2;
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
-    if (code == QUOTE) {
+    // console.log("code: " + String.fromCharCode(code));
+    if (code == BRACE_LEFT) {
       lastIndex = srcStart;
+      depth++;
       srcStart += 2;
       while (srcStart < srcEnd) {
         const code = load<u16>(srcStart);
-        if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
-          while (isSpace(load<u16>((srcStart += 2)))) {
-            /* empty */
+        if (code == BRACE_RIGHT) {
+          if (--depth == 0) {
+            // @ts-ignore: type
+            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
+            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
+            break;
           }
-          // console.log("Value (string): " + ptrToStr(lastIndex, srcStart));
+        } else if (code == BRACE_LEFT) depth++;
+        srcStart += 2;
+      }
+    } else if (code == QUOTE) {
+      lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          // console.log("Value (string): " + ptrToStr(lastIndex, srcStart + 2));
           // @ts-ignore: exists
-          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
+          srcStart += 2;
           break;
         }
         srcStart += 2;
       }
+      // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
     } else if (code - 48 <= 9 || code == 45) {
+      // console.log("trigger int")
       lastIndex = srcStart;
       srcStart += 2;
       while (srcStart < srcEnd) {
         const code = load<u16>(srcStart);
-        if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
           // @ts-ignore: type
-          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart));
           // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
-          while (isSpace(load<u16>((srcStart += 2)))) {
-            /* empty */
-          }
           break;
         }
         srcStart += 2;
       }
+      // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
     } else if (code == BRACE_LEFT) {
       lastIndex = srcStart;
       depth++;
@@ -49,7 +70,7 @@ export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize,
         if (code == BRACE_RIGHT) {
           if (--depth == 0) {
             // @ts-ignore: type
-            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart));
             // console.log("Value (object): " + ptrToStr(lastIndex, srcStart));
             while (isSpace(load<u16>((srcStart += 2)))) {
               /* empty */
@@ -68,7 +89,7 @@ export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize,
         if (code == BRACKET_RIGHT) {
           if (--depth == 0) {
             // @ts-ignore: type
-            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart));
             // console.log("Value (array): " + ptrToStr(lastIndex, srcStart));
             while (isSpace(load<u16>((srcStart += 2)))) {
               /* empty */
@@ -81,25 +102,27 @@ export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize,
     } else if (code == CHAR_T) {
       if (load<u64>(srcStart) == 28429475166421108) {
         // @ts-ignore: type
-        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 8)));
+        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 8)));
         // console.log("Value (bool): " + ptrToStr(srcStart - 8, srcStart));
-        while (isSpace(load<u16>((srcStart += 2)))) {
-          /* empty */
-        }
+        // while (isSpace(load<u16>((srcStart += 2)))) {
+        //   /* empty */
+        // }
+        // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
       }
     } else if (code == CHAR_F) {
       if (load<u64>(srcStart, 2) == 28429466576093281) {
         // @ts-ignore: type
-        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 10)));
+        out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 10)));
         // console.log("Value (bool): " + ptrToStr(srcStart - 10, srcStart));
-        while (isSpace(load<u16>((srcStart += 2)))) {
-          /* empty */
-        }
+        // while (isSpace(load<u16>((srcStart += 2)))) {
+        //   /* empty */
+        // }
+        // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
       }
     } else if (code == CHAR_N) {
       if (load<u64>(srcStart) == 30399761348886638) {
         // @ts-ignore: type
-        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 8)));
+        out.push(JSON.__deserialize<JSON.Value>(lastIndex, (srcStart += 8)));
         // console.log("Value (null): " + ptrToStr(srcStart - 8, srcStart));
         while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */

package/assembly/deserialize/simple/array/{object.ts → struct.ts}

@@ -1,7 +1,7 @@
 import { BRACE_LEFT, BRACE_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 
-export function deserializeObjectArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+export function deserializeStructArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
   const out = dst ? changetype<T>(dst) : instantiate<T>();
   let lastIndex: usize = 0;
   let depth: u32 = 0;