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

package/assembly/__tests__/arbitrary.spec.ts

@@ -0,0 +1,19 @@
+import { JSON } from "..";
+import { describe, expect } from "./lib";
+import { Vec3 } from "./types";
+
+describe("Should serialize arbitrary types", () => {
+  expect(JSON.stringify(JSON.Value.from("hello world"))).toBe("\"hello world\"");
+  expect(JSON.stringify(JSON.Value.from(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__/array.spec.ts

@@ -1,5 +1,5 @@
 import { JSON } from "..";
-import { describe, expect } from "../../modules/test/assembly";
+import { describe, expect } from "./lib";
 
 describe("Should serialize integer arrays", () => {
   expect(JSON.stringify<u32[]>([0, 100, 101])).toBe("[0,100,101]");
@@ -58,6 +58,47 @@ 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 {

package/assembly/__tests__/bool.spec.ts

@@ -1,5 +1,5 @@
 import { JSON } from "..";
-import { describe, expect } from "../../modules/test/assembly";
+import { describe, expect } from "./lib";
 
 describe("Should serialize booleans", () => {
   expect(JSON.stringify<bool>(true)).toBe("true");

package/assembly/__tests__/box.spec.ts

@@ -1,5 +1,5 @@
 import { JSON } from "..";
-import { describe, expect } from "../../modules/test/assembly";
+import { describe, expect } from "./lib";
 
 describe("Should serialize JSON.Box<T>", () => {
   expect(JSON.stringify<JSON.Box<i32> | null>(null))

package/assembly/__tests__/custom.spec.ts

@@ -0,0 +1,42 @@
+import { JSON } from "..";
+import { describe, expect } from "./lib";
+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__/date.spec.ts

@@ -1,5 +1,5 @@
 import { JSON } from "..";
-import { describe, expect } from "../../modules/test/assembly";
+import { describe, expect } from "./lib";
 
 describe("Should serialize Date", () => {
   expect(JSON.stringify<Date>(new Date(0)))

package/assembly/__tests__/float.spec.ts

@@ -1,5 +1,5 @@
 import { JSON } from "..";
-import { describe, expect } from "../../modules/test/assembly";
+import { describe, expect } from "./lib";
 
 describe("Should serialize floats", () => {
   expect(JSON.stringify<f64>(7.23)).toBe("7.23");
@@ -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__/integer.spec.ts

@@ -1,5 +1,5 @@
 import { JSON } from "..";
-import { describe, expect } from "../../modules/test/assembly";
+import { describe, expect } from "./lib";
 
 describe("Should serialize integers", () => {
   expect(JSON.stringify(0)).toBe("0");

package/assembly/__tests__/null.spec.ts

@@ -1,5 +1,5 @@
 import { JSON } from "..";
-import { describe, expect } from "../../modules/test/assembly";
+import { describe, expect } from "./lib";
 
 describe("Should serialize null", () => {
   expect(JSON.stringify(null)).toBe("null");

package/assembly/__tests__/raw.spec.ts

@@ -0,0 +1,23 @@
+import { JSON } from "..";
+import { describe, expect } from "./lib";
+
+describe("Should serialize JSON.Raw", () => {
+  expect(JSON.stringify<JSON.Raw>(JSON.Raw.from('{"x":1.0,"y":2.0,"z":3.0}'))).toBe('{"x":1.0,"y":2.0,"z":3.0}');
+});
+
+describe("Should deserialize JSON.Raw", () => {
+  expect(JSON.parse<JSON.Raw>('{"x":1.0,"y":2.0,"z":3.0}').toString()).toBe('{"x":1.0,"y":2.0,"z":3.0}');
+});
+
+describe("Should serialize Map<string, JSON.Raw>", () => {
+  const m1 = new Map<string, JSON.Raw>();
+  m1.set("hello", new JSON.Raw("\"world\""));
+  m1.set("pos", new JSON.Raw("{\"x\":1.0,\"y\":2.0,\"z\":3.0}"));
+
+  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__/string.spec.ts

@@ -1,5 +1,5 @@
 import { JSON } from "..";
-import { describe, expect } from "../../modules/test/assembly";
+import { describe, expect } from "./lib";
 
 describe("Should serialize strings", () => {
   expect(JSON.stringify("abcdefg")).toBe('"abcdefg"');

package/assembly/__tests__/{obj.spec.ts → struct.spec.ts}

@@ -1,7 +1,7 @@
 import { JSON } from "..";
-import { describe, expect } from "../../modules/test/assembly";
+import { describe, expect } from "./lib";
 
-describe("Should serialize objects", () => {
+describe("Should serialize structs", () => {
   expect(
     JSON.stringify<Vec3>({
       x: 3.4,
@@ -38,7 +38,7 @@ describe("Should serialize objects", () => {
   expect(JSON.stringify<ObjWithStrangeKey<string>>({ data: "foo" })).toBe('{"a\\\\\\t\\"\\u0002b`c":"foo"}');
 });
 
-describe("Should serialize objects with inheritance", () => {
+describe("Should serialize structs with inheritance", () => {
   const obj = new DerivedObject("1", "2");
 
   expect(JSON.stringify(obj)).toBe('{"a":"1","b":"2"}');
@@ -52,6 +52,21 @@ describe("Should ignore properties decorated with @omit", () => {
   ).toBe('{"y":1,"x":1,"z":1}');
 });
 
+describe("Should deserialize structs", () => {
+  expect(
+    JSON.stringify(JSON.parse<Vec3>('{"x":3.4,"y":1.2,"z":8.3}')),
+  ).toBe('{"x":3.4,"y":1.2,"z":8.3}');
+});
+
+describe("Should deserialize structs with whitespace", () => {
+  expect(
+    JSON.stringify(JSON.parse<Vec3>('    {  "x"  :  3.4  ,  "y"  :  1.2    ,  "z"   :  8.3   }   ')),
+  ).toBe('{"x":3.4,"y":1.2,"z":8.3}');
+});
+
+// describe("Should serialize Suite struct", () => {
+
+// });
 
 @json
 class BaseObject {
@@ -99,7 +114,6 @@ class ObjWithString {
 
 @json
 class ObjWithStrangeKey<T> {
-
   @alias('a\\\t"\x02b`c')
   data!: T;
 }

package/assembly/__tests__/test.spec.ts

@@ -1,5 +1,5 @@
 import { JSON } from "../";
-import { describe, expect } from "../../modules/test/assembly/index";
+import { describe, expect } from "./lib";
 import { DerivedObject, Null, ObjWithStrangeKey, ObjectWithFloat, OmitIf, Player, Vec3 } from "./types";
 
 // describe("Should serialize objects", () => {

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/as-bs.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Central buffer namespace for managing memory operations.
+ */
+declare namespace bs {
+  /** Current buffer pointer. */
+  export let buffer: ArrayBuffer;
+
+  /** Current offset within the buffer. */
+  export let offset: usize;
+
+  /** Proposed size of output. */
+  export let stackSize: usize;
+
+  /**
+   * Ensures the buffer size is at least the proposed size.
+   * If necessary, reallocates the buffer to the exact new size.
+   * @param size - The size to propose.
+   */
+  export function ensureSize(size: u32): void;
+
+  /**
+   * Proposes that the buffer size should be at least the given size.
+   * If necessary, reallocates the buffer to the exact new size.
+   * @param size - The size to propose.
+   */
+  export function proposeSize(size: u32): void;
+
+  /**
+   * Increases the proposed size by nextPowerOf2(n + 64) if necessary.
+   * If necessary, reallocates the buffer to the exact new size.
+   * @param size - The size to grow by.
+   */
+  export function growSize(size: u32): void;
+
+  /**
+   * Resizes the buffer to the specified size.
+   * @param newSize - The new buffer size.
+   */
+  export function resize(newSize: u32): void;
+
+  /**
+   * Copies the buffer's content to a new object of a specified type.
+   * @returns The new object containing the buffer's content.
+   */
+  export function out<T>(): T;
+
+  /**
+   * Copies the buffer's content to a given destination pointer.
+   * @param dst - The destination pointer.
+   * @returns The destination pointer cast to the specified type.
+   */
+  export function outTo<T>(dst: usize): T;
+}

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

@@ -2,44 +2,64 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, CHAR_
 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>();
+export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: usize): 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)
+  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 +69,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 +88,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 +101,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/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

@@ -3,7 +3,7 @@ import { COMMA, BRACE_RIGHT, 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);

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

@@ -2,7 +2,7 @@ import { atoi, isSpace } from "../../../util";
 import { COMMA, BRACKET_RIGHT } from "../../../custom/chars";
 
 export function deserializeIntegerArray<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out: T = 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);

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

@@ -2,7 +2,7 @@ import { BRACE_LEFT, BRACE_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 
 export function deserializeMapArray<T extends Map<any, any>[]>(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) {

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

@@ -2,8 +2,8 @@ import { JSON } from "../../..";
 import { BACK_SLASH, QUOTE } from "../../../custom/chars";
 
 export function deserializeStringArray(srcStart: usize, srcEnd: usize, dst: usize): string[] {
-  const out = dst ? changetype<string[]>(dst) : new Array<string>();
-  let lastPos = 2;
+  const out = changetype<string[]>(dst || changetype<usize>(instantiate<string[]>()));
+  let lastPos: usize = 2;
   let inString = false;
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
@@ -12,7 +12,7 @@ export function deserializeStringArray(srcStart: usize, srcEnd: usize, dst: usiz
         inString = true;
         lastPos = srcStart;
       } else if (load<u16>(srcStart - 2) != BACK_SLASH) {
-        out.push(JSON.__deserialize<string>(lastPos, srcStart));
+        out.push(JSON.__deserialize<string>(lastPos, srcStart + 2));
         inString = false;
       }
     }

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

@@ -0,0 +1,29 @@
+import { BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../..";
+import { isSpace } from "util/string";
+
+export function deserializeStructArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+  let lastIndex: usize = 0;
+  let depth: u32 = 0;
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
+  if (srcStart - srcEnd == 0)
+    throw new Error("Input string had zero length or was all whitespace");
+
+  if (load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Expected '[' at start of object at position " + (srcEnd - srcStart).toString());
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT) throw new Error("Expected ']' at end of object at position " + (srcEnd - srcStart).toString());
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == BRACE_LEFT && depth++ == 0) {
+      lastIndex = srcStart;
+    } else if (code == BRACE_RIGHT && --depth == 0) {
+      out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart += 2));
+    }
+    srcStart += 2;
+  }
+  return out;
+}