json-as 0.9.29 → 1.0.0-alpha.2

package/.github/workflows/nodejs.yml

@@ -19,8 +19,5 @@ jobs:
       - name: Install Dependencies
         run: bun install
 
-      - name: Build Tests
-        run: bun run pretest
-
       - name: Run Tests
         run: bun run test

package/.prettierrc.json

@@ -1,6 +1,7 @@
 {
+  "pluginSearchDirs": ["node_modules"],
+  "plugins": ["assemblyscript-prettier"],
   "singleQuote": false,
   "printWidth": 65536,
-  "pluginSearchDirs": ["node_modules"],
-  "plugins": ["assemblyscript-prettier"]
+  "tabWidth": 2
 }

package/CHANGELOG

@@ -0,0 +1,24 @@
+# Change Log
+
+## UNRELEASED
+
+## 2025-01-20 - 1.0.0-alpha.2
+
+- fix: disable SIMD in generated transform code by default
+- fix: re-add as-bs dependency so that it will not break in non-local environments
+- fix: remove AS201 'conversion from type usize to i32' warning
+- fix: add as-bs to peer dependencies so only one version is installed
+- fix: point as-bs imports to submodule
+- fix: remove submodule in favor of static module
+- fix: bs.ensureSize would not grow and thus cause memory faults
+- fix: bs.ensureSize triggering unintentionally
+
+## 2025-01-20 - 1.0.0-alpha.1
+
+- feat: finish implementation of arbitrary data serialization and deserialization using JSON.Value
+- feat: reinstate usage of `JSON.Box<T>()` to support nullable primitive types
+- feat: eliminate the need to import the `JSON` namespace when defining a schema
+- 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

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Jairus Tanaka <jairus.v.tanaka@outlook.com>
+Copyright (c) 2025 Jairus Tanaka <me@jairus.dev>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -6,29 +6,29 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v0.9.29
+    AssemblyScript - v1.0.0-alpha.2
   </pre>
 </h5>
 
 ## Installation
 
 ```bash
-npm install json-as visitor-as
+npm install json-as@1.0.0-alpha.2
 ```
 
 Add the `--transform` to your `asc` command (e.g. in package.json)
 
 ```bash
---transform json-as/transform
+--transform json-as
 ```
 
 Alternatively, add it to your `asconfig.json`
 
-```json
+```
 {
   // ...
   "options": {
-    "transform": ["json-as/transform"]
+    "transform": ["json-as"]
   }
 }
 ```
@@ -38,7 +38,7 @@ If you'd like to see the code that the transform generates, run with `JSON_DEBUG
 ## Usage
 
 ```js
-import { JSON } from "json-as/assembly";
+import { JSON } from "json-as";
 
 // @json or @serializable work here
 @json
@@ -55,7 +55,8 @@ class Player {
   lastName!: string;
   lastActive!: i32[];
   // Drop in a code block, function, or expression that evaluates to a boolean
-  @omitif("this.age < 18")
+  @omitif((age) => age < 18)
+  @omitif('this.age <= 0')
   age!: i32;
   @omitnull()
   pos!: Vec3 | null;
@@ -110,8 +111,23 @@ const serialized = JSON.stringify(arr);
 const parsed = JSON.parse<Base[]>(serialized);
 ```
 
+You can also add it to your `asconfig.json`
+
+```json
+{
+  // ...
+  "options": {
+    "transform": ["json-as/transform"]
+  }
+}
+```
+
 If you use this project in your codebase, consider dropping a [star](https://github.com/JairusSW/as-json). I would really appreciate it!
 
+## Notes
+
+If you want a feature, drop an issue (and again, maybe a star). I'll likely add it in less than 7 days.
+
 ## Contact
 
 - [Email](mailto:me@jairus.dev)

package/as-test.config.json

@@ -6,7 +6,7 @@
     "coverage": false
   },
   "buildOptions": {
-    "args": ["--transform ./transform"],
+    "args": ["--enable simd", "--runtime stub"],
     "target": "wasi"
   },
   "runOptions": {

package/asconfig.json

@@ -29,8 +29,8 @@
     }
   },
   "options": {
-    "transform": ["./transform", "as-test/transform"],
-    "disableWarning": [226]
+    "transform": [],
+    "disableWarning": []
   },
   "extends": "./node_modules/@assemblyscript/wasi-shim/asconfig.json"
 }

package/assembly/__benches__/misc.bench.ts

@@ -1,34 +0,0 @@
-import { JSON } from "..";
-import { BRACE_LEFT, BRACKET_LEFT, CHAR_F, CHAR_T, QUOTE } from "../custom/chars";
-
-bench("Match Type (string)", () => {
-  blackbox<boolean>(matchType(blackbox<string>('"'), JSON.Types.String));
-});
-
-bench("Match Type (bool)", () => {
-  blackbox<boolean>(matchType(blackbox<string>("t"), JSON.Types.Bool));
-});
-
-bench("Match Type (array)", () => {
-  blackbox<boolean>(matchType(blackbox<string>("["), JSON.Types.Array));
-});
-
-bench("Match Type (struct)", () => {
-  blackbox<boolean>(matchType(blackbox<string>("{"), JSON.Types.Obj));
-});
-
-bench("Match Type (raw)", () => {
-  blackbox<boolean>(matchType(blackbox<string>('"'), JSON.Types.Raw));
-});
-
-
-@inline function matchType(data: string, type: JSON.Types): boolean {
-  const firstChar = load<u8>(changetype<usize>(data));
-  if (JSON.Types.String == type && firstChar == QUOTE) return true;
-  else if (JSON.Types.Bool == type && (firstChar == CHAR_T || firstChar == CHAR_F)) return true;
-  else if (JSON.Types.Array == type && firstChar == BRACKET_LEFT) return true;
-  else if (JSON.Types.Obj == type && firstChar == BRACE_LEFT) return true;
-  else if (type < 7 && type > 0 && firstChar < 58 && firstChar > 46) return true;
-  else if (JSON.Types.Raw == type) return true;
-  else return false;
-}

package/assembly/__tests__/bool.spec.ts

@@ -1,4 +1,4 @@
-import { JSON } from "json-as";
+import { JSON } from "../";
 import { describe, expect, run } from "as-test/assembly";
 
 describe("Should serialize booleans", () => {

package/assembly/__tests__/simd/string.spec.ts

@@ -0,0 +1,32 @@
+import { describe, expect, run } from "as-test/assembly";
+import { serializeString_SIMD } from "../../serialize/simd/string";
+import { deserializeString_SIMD } from "../../deserialize/simd/string";
+
+const out = changetype<usize>(new ArrayBuffer(512));
+
+const serialize_simd = (data: string): string => String.UTF16.decodeUnsafe(out, serializeString_SIMD(data, out));
+const deserialize_simd = (data: string): string => String.UTF16.decodeUnsafe(out, deserializeString_SIMD(data, out));
+describe("Should serialize strings", () => {
+  expect(serialize_simd("abcdefg")).toBe('"abcdefg"');
+
+  expect(serialize_simd('st"ring" w""ith quotes"')).toBe('"st\\"ring\\" w\\"\\"ith quotes\\""');
+
+  expect(serialize_simd('string "with random spa\nces and \nnewlines\n\n\n')).toBe('"string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"');
+
+  expect(serialize_simd('string with colon : comma , brace [ ] bracket { } and quote " and other quote "')).toBe('"string with colon : comma , brace [ ] bracket { } and quote \\" and other quote \\""');
+
+  expect(serialize_simd("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u000f\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f")).toBe('"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u000f\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f"');
+});
+
+describe("Should deserialize strings", () => {
+  expect(deserialize_simd('"abcdefg"')).toBe("abcdefg");
+  expect(deserialize_simd('"st\\"ring\\" w\\"\\"ith quotes\\""')).toBe('st"ring" w""ith quotes"');
+
+  expect(deserialize_simd('"string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"')).toBe('string "with random spa\nces and \nnewlines\n\n\n');
+
+  expect(deserialize_simd('"string with colon : comma , brace [ ] bracket { } and quote \\" and other quote \\""')).toBe('string with colon : comma , brace [ ] bracket { } and quote " and other quote "');
+
+  expect(deserialize_simd('"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u000f\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f"')).toBe("\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u000f\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f");
+});
+
+run();

package/assembly/custom/memory.ts

@@ -0,0 +1,25 @@
+import { BLOCK_MAXSIZE, OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { E_INVALIDLENGTH } from "util/error";
+
+// @ts-ignore: Decorator valid here
+@inline export function ensureCapacity<T>(obj: T, newSize: usize): usize {
+  const ptr = changetype<usize>(obj);
+  const oldCapacity = changetype<OBJECT>(ptr - TOTAL_OVERHEAD).rtSize;
+  if (newSize > oldCapacity) {
+    if (newSize > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);
+    const newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newSize);
+    const newObj = __renew(ptr, newCapacity);
+    return newObj;
+  }
+  return ptr;
+}
+
+// @ts-ignore: Decorator valid here
+@inline export function setCapacity<T>(obj: T, oldCapacity: usize, newCapacity: usize): usize {
+  const ptr = changetype<usize>(obj);
+  if (newCapacity > oldCapacity) {
+    if (newCapacity > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);
+    return __renew(ptr, newCapacity);
+  }
+  return ptr;
+}

package/assembly/custom/util.ts

@@ -1,78 +1,6 @@
 import { isSpace } from "util/string";
-import { BACK_SLASH, BRACE_LEFT, BRACKET_LEFT, CHAR_F, CHAR_T, QUOTE } from "./chars";
+import { BACK_SLASH, QUOTE } from "./chars";
 import { Sink } from "./sink";
-import { JSON } from "..";
-
-// @ts-ignore: Decorator
-export function isMap<T>(): bool {
-  let type = changetype<T>(0);
-  return type instanceof Map;
-}
-
-// @ts-ignore: Decorator
-@inline export function unsafeCharCodeAt(data: string, pos: i32): i32 {
-  return load<u16>(changetype<usize>(data) + ((<usize>pos) << 1));
-}
-
-// @ts-ignore: Decorator
-@inline export function removeWhitespace(data: string): string {
-  const result = new Sink();
-  let instr = false;
-  for (let i = 0; i < data.length; i++) {
-    const char = unsafeCharCodeAt(data, i);
-    if (instr === false && char === QUOTE) instr = true;
-    else if (instr === true && char === QUOTE && unsafeCharCodeAt(data, i - 1) !== BACK_SLASH) instr = false;
-
-    if (instr === false) {
-      if (!isSpace(char)) result.write(data.charAt(i));
-    } else {
-      result.write(data.charAt(i));
-    }
-  }
-  return result.toString();
-}
-
-// @ts-ignore: Decorator
-@inline export function escapeChar(char: string): string {
-  switch (unsafeCharCodeAt(char, 0)) {
-    case 0x22:
-      return '\\"';
-    case 0x5c:
-      return "\\\\";
-    case 0x08:
-      return "\\b";
-    case 0x0a:
-      return "\\n";
-    case 0x0d:
-      return "\\r";
-    case 0x09:
-      return "\\t";
-    case 0x0c:
-      return "\\f";
-    case 0x0b:
-      return "\\u000b";
-    default:
-      return char;
-  }
-}
-
-/**
- * A terrible function which finds the depth of a certain array.
- * Suffers no overhead besides function calling and a if/else.
- * @returns depth of array
- */
-
-// @ts-ignore: Decorator
-export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
-  if (!isArray<T>()) {
-    return 0;
-  } else if (isArray<valueof<T>>()) {
-    depth++;
-    return getArrayDepth<valueof<T>>(depth);
-  } else {
-    return depth;
-  }
-}
 
 /** Scientific Notation Integer Parsing - SNIP
  * This is absolutely the fastest algorithm I could think of while adding full support for Scientific Notation
@@ -94,8 +22,8 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
 @inline export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u32 = 0): T {
   if (isSigned<T>()) {
     const firstChar: u32 = load<u16>(changetype<usize>(str));
-    if (firstChar === 48) return 0 as T;
-    const isNegative = firstChar === 45; // Check if the number is negative
+    if (firstChar == 48) return 0 as T;
+    const isNegative = firstChar == 45; // Check if the number is negative
     let val: T = 0 as T;
     if (len == 0) len = u32(str.length << 1);
     if (isNegative) {
@@ -199,7 +127,7 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
     }
   } else {
     const firstChar: u32 = load<u16>(changetype<usize>(str));
-    if (firstChar === 48) return 0 as T;
+    if (firstChar == 48) return 0 as T;
     let val: T = 0 as T;
     if (len == 0) len = u32(str.length << 1);
     if (len >= 4) {
@@ -262,7 +190,7 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
   if (!end) end = start + u32(str.length << 1);
   if (isSigned<T>()) {
     // Negative path
-    if (load<u16>(changetype<usize>(str) + <usize>start) === 45) {
+    if (load<u16>(changetype<usize>(str) + <usize>start) == 45) {
       start += 2;
       for (; start < end; start += 2) {
         val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
@@ -296,14 +224,14 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
   let val: T = 0;
   let offset = 0;
   let firstChar = load<u16>(changetype<usize>(str) + <usize>offset);
-  if (firstChar === 45) {
+  if (firstChar == 45) {
     offset = 2;
   }
   for (; offset < str.length << 1; offset += 2) {
     const char = load<u16>(changetype<usize>(str) + <usize>offset);
-    if (char === 101 || char === 69) {
+    if (char == 101 || char == 69) {
       const char = load<u16>(changetype<usize>(str) + <usize>(offset += 2));
-      if (char === 45) {
+      if (char == 45) {
         // @ts-ignore
         val /= sciNote<T>(__atoi_fast<T>(str, (offset += 2)));
         // @ts-ignore
@@ -319,7 +247,7 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
     val = (val << 1) + (val << 3) + (char - 48);
     // We use load because in this case, there is no need to have bounds-checking
   }
-  if (firstChar === 45) {
+  if (firstChar == 45) {
     val = -val as T;
   }
   return val;
@@ -342,17 +270,6 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
   return res;
 }
 
-// @ts-ignore
-@inline function equalsSlice(p1_data: string, p1_start: i32, p1_end: i32, p2_data: string, p2_start: i32, p2_end: i32): boolean {
-  const p1_len = p1_end - p1_start;
-  const p2_len = p2_end - p2_start;
-  if (p1_len != p2_len) return false;
-  if (p1_len == 2) {
-    return load<u16>(changetype<usize>(p1_data) + p1_start) == load<u16>(changetype<usize>(p2_data) + p2_start);
-  }
-  return memory.compare(changetype<usize>(p1_data) + p1_start, changetype<usize>(p2_data) + p2_start, p1_len) === 0;
-}
-
 // @ts-ignore
 @inline export function containsCodePoint(str: string, code: u32, start: i32, end: i32): bool {
   for (let i = start; i <= end; i++) {
@@ -390,3 +307,8 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
     }
   }
 }
+
+// @ts-ignore: Decorator valid here
+@inline export function nextPowerOf2(n: u32): u32 {
+  return 1 << (32 - clz(n - 1));
+}

package/assembly/deserialize/simd/string.ts

@@ -0,0 +1,103 @@
+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
+ * @param dst buffer to write to
+ * @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 {
+  let src_ptr = srcStart + 2;
+  let dst_ptr = changetype<usize>(dst);
+
+  const src_end = srcEnd - 2;
+  const src_end_15 = src_end - 15;
+
+  while (src_ptr < src_end_15) {
+    const block = v128.load(src_ptr);
+    v128.store(dst_ptr, block);
+
+    const backslash_indices = i16x8.eq(block, SPLAT_92);
+    let mask = i16x8.bitmask(backslash_indices);
+
+    while (mask != 0) {
+      const lane_index = ctz(mask) << 1;
+      const dst_offset = dst_ptr + lane_index;
+      const src_offset = src_ptr + lane_index;
+      const code = load<u16>(src_offset, 2);
+
+      mask &= mask - 1;
+      if (code == 117 && load<u32>(src_offset, 4) == 3145776) {
+        const block = load<u32>(src_offset, 8);
+        const codeA = block & 0xffff;
+        const codeB = (block >> 16) & 0xffff;
+        const escapedA = load<u8>(ESCAPE_HEX_TABLE + codeA);
+        const escapedB = load<u8>(ESCAPE_HEX_TABLE + codeB);
+        const escaped = (escapedA << 4) + escapedB;
+        // console.log("Escaped:");
+        // console.log("  a: " + escapedA.toString())
+        // console.log("  b: " + escapedB.toString());
+        // console.log("  c: " + escaped.toString());
+        // console.log("  o: " + (dst_ptr - dst).toString());
+        // console.log("  d: " + (dst_offset - dst).toString())
+        // console.log("  l: " + (lane_index).toString())
+        store<u16>(dst_offset, escaped);
+        v128.store(dst_offset, v128.load(src_offset, 4), 2);
+        if (lane_index >= 6) {
+          const bytes_left = lane_index - 4;
+          src_ptr += bytes_left;
+          dst_ptr += bytes_left;
+          // console.log("  e: " + (bytes_left).toString())
+        }
+        dst_ptr -= 10;
+      } else {
+        const escaped = load<u8>(DESERIALIZE_ESCAPE_TABLE + code);
+        store<u16>(dst_offset, escaped);
+        v128.store(dst_offset, v128.load(src_offset, 4), 2);
+        // console.log("Escaped:");
+        if (lane_index == 14) {
+          src_ptr += 2;
+        } else {
+          dst_ptr -= 2;
+        }
+      }
+    }
+
+    src_ptr += 16;
+    dst_ptr += 16;
+
+    // console.log("src: " + (src_ptr - changetype<usize>(src)).toString());
+    // console.log("dst: " + (dst_ptr - dst).toString());
+  }
+  while (src_ptr < src_end) {
+    let code = load<u16>(src_ptr);
+    if (code == BACK_SLASH) {
+      code = load<u16>(DESERIALIZE_ESCAPE_TABLE + load<u8>(src_ptr, 2));
+      if (code == 117 && load<u32>(src_ptr, 4) == 3145776) {
+        const block = load<u32>(src_ptr, 8);
+        const codeA = block & 0xffff;
+        const codeB = (block >> 16) & 0xffff;
+        const escapedA = load<u8>(ESCAPE_HEX_TABLE + codeA);
+        const escapedB = load<u8>(ESCAPE_HEX_TABLE + codeB);
+        const escaped = (escapedA << 4) + escapedB;
+        store<u16>(dst_ptr, escaped);
+        dst_ptr += 2;
+        src_ptr += 12;
+      } else {
+        store<u16>(dst_ptr, code);
+        dst_ptr += 2;
+        src_ptr += 4;
+      }
+    } else {
+      store<u16>(dst_ptr, code);
+      dst_ptr += 2;
+      src_ptr += 2;
+    }
+  }
+
+  return dst_ptr - dst;
+}

package/assembly/deserialize/simple/arbitrary.ts

@@ -0,0 +1,17 @@
+import { JSON } from "../..";
+import { deserializeArray } from "./array";
+import { deserializeBoolean } from "./bool";
+import { deserializeFloat } from "./float";
+import { deserializeObject } from "./object";
+import { deserializeString } from "./string";
+
+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));
+  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 == 116 || firstChar == 102) return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
+  return unreachable();
+}

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

@@ -0,0 +1,113 @@
+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";
+
+export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value[] {
+  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  let lastIndex: usize = 0;
+  let depth: u32 = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    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));
+          // @ts-ignore: exists
+          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          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 == BRACE_RIGHT || isSpace(code)) {
+          // @ts-ignore: type
+          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
+          while (isSpace(load<u16>((srcStart += 2)))) {
+            /* empty */
+          }
+          break;
+        }
+        srcStart += 2;
+      }
+    } else if (code == BRACE_LEFT) {
+      lastIndex = srcStart;
+      depth++;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == BRACE_RIGHT) {
+          if (--depth == 0) {
+            // @ts-ignore: type
+            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart));
+            while (isSpace(load<u16>((srcStart += 2)))) {
+              /* empty */
+            }
+            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 == BRACKET_RIGHT) {
+          if (--depth == 0) {
+            // @ts-ignore: type
+            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            // console.log("Value (array): " + ptrToStr(lastIndex, srcStart));
+            while (isSpace(load<u16>((srcStart += 2)))) {
+              /* empty */
+            }
+            break;
+          }
+        } else if (code == BRACKET_LEFT) depth++;
+        srcStart += 2;
+      }
+    } else if (code == CHAR_T) {
+      if (load<u64>(srcStart) == 28429475166421108) {
+        // @ts-ignore: type
+        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 8)));
+        // console.log("Value (bool): " + ptrToStr(srcStart - 8, srcStart));
+        while (isSpace(load<u16>((srcStart += 2)))) {
+          /* empty */
+        }
+      }
+    } else if (code == CHAR_F) {
+      if (load<u64>(srcStart, 2) == 28429466576093281) {
+        // @ts-ignore: type
+        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 10)));
+        // console.log("Value (bool): " + ptrToStr(srcStart - 10, srcStart));
+        while (isSpace(load<u16>((srcStart += 2)))) {
+          /* empty */
+        }
+      }
+    } else if (code == CHAR_N) {
+      if (load<u64>(srcStart) == 30399761348886638) {
+        // @ts-ignore: type
+        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 8)));
+        // console.log("Value (null): " + ptrToStr(srcStart - 8, srcStart));
+        while (isSpace(load<u16>((srcStart += 2)))) {
+          /* empty */
+        }
+      }
+    }
+    srcStart += 2;
+  }
+  // @ts-ignore: type
+  return out;
+}

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

@@ -0,0 +1,18 @@
+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>();
+  let lastIndex: usize = 0;
+  let depth: u32 = 0;
+  while (srcStart < srcEnd) {
+    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));
+    }
+    srcStart += 2;
+  }
+  return out;
+}