json-as 1.0.0-alpha.3 → 1.0.0-beta.1

package/assembly/deserialize/simple/map.ts

@@ -76,7 +76,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         srcStart += 2;
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
-          if (((code ^ BRACE_RIGHT) | (code ^ BRACKET_RIGHT)) == 32) {
+          if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
               // @ts-ignore: type
               out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));

package/assembly/deserialize/simple/object.ts

@@ -1,8 +1,11 @@
+import { JSON } from "../..";
 import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T } from "../../custom/chars";
 import { isSpace } from "../../util";
+import { ptrToStr } from "../../util/ptrToStr";
+import { deserializeArbitrary } from "./arbitrary";
 
-export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || __new(offsetof<T>(), idof<T>()));
+export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): JSON.Obj {
+  const out = new JSON.Obj();
 
   let keyStart: usize = 0;
   let keyEnd: usize = 0;
@@ -20,7 +23,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
         if (isKey) {
           keyStart = lastIndex;
           keyEnd = srcStart;
-          // console.log("Key: " + ptrToStr(lastIndex, srcStart));
+          // console.log("Key: " + ptrToStr(keyStart, keyEnd));
           // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
           srcStart += 2;
           // while (isSpace((code = load<u16>((srcStart += 2))))) {
@@ -44,8 +47,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
           const code = load<u16>(srcStart);
           if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
             // console.log("Value (string): " + ptrToStr(lastIndex, srcStart + 2));
-            // @ts-ignore: exists
-            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart + 2, dst);
+            out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart + 2, dst));
             // while (isSpace(load<u16>(srcStart))) srcStart += 2;
             srcStart += 4;
             // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
@@ -60,9 +62,8 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
           if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
-            // @ts-ignore: exists
-            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart, dst);
             // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
+            out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart, dst));
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -82,8 +83,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
           if (code == BRACE_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-              // @ts-ignore: exists
-              out.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), dst);
+              out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 2, dst));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>(srcStart))) {
@@ -103,8 +103,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
           if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
-              // @ts-ignore: exists
-              out.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), dst);
+              out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 2, dst));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>((srcStart += 2)))) {
@@ -118,8 +117,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
       } else if (code == CHAR_T) {
         if (load<u64>(srcStart) == 28429475166421108) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
-          // @ts-ignore: exists
-          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), dst);
+          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 8, dst));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -130,8 +128,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
       } else if (code == CHAR_F) {
         if (load<u64>(srcStart, 2) == 28429466576093281) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
-          // @ts-ignore: exists
-          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 10), dst);
+          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 10, dst));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -142,8 +139,7 @@ export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize)
       } else if (code == CHAR_N) {
         if (load<u64>(srcStart) == 30399761348886638) {
           // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
-          // @ts-ignore: exists
-          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), dst);
+          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 8, dst));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */
           // }

package/assembly/deserialize/simple/struct.ts

@@ -0,0 +1,158 @@
+import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T } from "../../custom/chars";
+import { isSpace } from "../../util";
+
+export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<nonnull<T>>(dst || __new(offsetof<T>(), idof<T>()));
+
+  let keyStart: usize = 0;
+  let keyEnd: usize = 0;
+  let isKey = false;
+  let depth = 0;
+  let lastIndex: usize = 0;
+
+  // while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  // while (srcEnd > srcStart && isSpace(load<u16>(srcEnd))) srcEnd -= 2;
+  srcStart += 2;
+  while (srcStart < srcEnd) {
+    let code = load<u16>(srcStart); // while (isSpace(code)) code = load<u16>(srcStart += 2);
+    if (keyStart == 0) {
+      if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
+        if (isKey) {
+          keyStart = lastIndex;
+          keyEnd = srcStart;
+          // console.log("Key: " + ptrToStr(lastIndex, srcStart));
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
+          srcStart += 2;
+          // while (isSpace((code = load<u16>((srcStart += 2))))) {
+          //   /* empty */
+          // }
+          // if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcStart - srcPtr).toString());
+          isKey = false;
+        } else {
+          // console.log("Got key start");
+          isKey = true; // i don't like this
+          lastIndex = srcStart + 2;
+        }
+      }
+      // isKey = !isKey;
+      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) {
+            // console.log("Value (string): " + ptrToStr(lastIndex, srcStart + 2));
+            // @ts-ignore: exists
+            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart + 2, dst);
+            // while (isSpace(load<u16>(srcStart))) srcStart += 2;
+            srcStart += 4;
+            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+            keyStart = 0;
+            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)) {
+            // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
+            // @ts-ignore: exists
+            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart, dst);
+            // while (isSpace(load<u16>((srcStart += 2)))) {
+            //   /* empty */
+            // }
+            srcStart += 2;
+            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+            keyStart = 0;
+            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) {
+              // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
+              // @ts-ignore: exists
+              out.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), dst);
+              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+              keyStart = 0;
+              // while (isSpace(load<u16>(srcStart))) {
+              //   /* 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) {
+              // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
+              // @ts-ignore: exists
+              out.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), dst);
+              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+              keyStart = 0;
+              // 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) {
+          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
+          // @ts-ignore: exists
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), dst);
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          srcStart += 2;
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)) + "  " + (srcStart < srcEnd).toString());
+          keyStart = 0;
+        }
+      } else if (code == CHAR_F) {
+        if (load<u64>(srcStart, 2) == 28429466576093281) {
+          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
+          // @ts-ignore: exists
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 10), dst);
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          srcStart += 2;
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+          keyStart = 0;
+        }
+      } else if (code == CHAR_N) {
+        if (load<u64>(srcStart) == 30399761348886638) {
+          // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
+          // @ts-ignore: exists
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), dst);
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          /* empty */
+          // }
+          srcStart += 2;
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+          keyStart = 0;
+        }
+      }
+    }
+  }
+  return out;
+}

package/assembly/index.ts

@@ -7,7 +7,7 @@ import { serializeMap } from "./serialize/simple/map";
 import { deserializeBoolean } from "./deserialize/simple/bool";
 import { deserializeArray } from "./deserialize/simple/array";
 import { deserializeFloat } from "./deserialize/simple/float";
-import { deserializeObject } from "./deserialize/simple/object";
+import { deserializeStruct } from "./deserialize/simple/struct";
 import { deserializeMap } from "./deserialize/simple/map";
 import { deserializeDate } from "./deserialize/simple/date";
 import { deserializeInteger } from "./deserialize/simple/integer";
@@ -20,9 +20,13 @@ import { dtoa_buffered, itoa_buffered } from "util/number";
 import { serializeBool } from "./serialize/simple/bool";
 import { serializeInteger } from "./serialize/simple/integer";
 import { serializeFloat } from "./serialize/simple/float";
-import { serializeObject } from "./serialize/simple/object";
+import { serializeStruct } from "./serialize/simple/struct";
 import { ptrToStr } from "./util/ptrToStr";
-import { bytes } from "./util";
+import { atoi, bytes } from "./util";
+import { deserializeArbitrary } from "./deserialize/simple/arbitrary";
+import { SERIALIZE_ESCAPE_TABLE } from "./globals/tables";
+import { serializeObject } from "./serialize/simple/object";
+import { deserializeObject } from "./deserialize/simple/object";
 
 export type Raw = string;
 
@@ -36,6 +40,11 @@ export type Raw = string;
  * JSON Encoder/Decoder for AssemblyScript
  */
 export namespace JSON {
+  export namespace Memory {
+    export function shrink(): void {
+      bs.resize(64);
+    }
+  }
   /**
    * Serializes valid JSON data
    * ```js
@@ -44,7 +53,8 @@ export namespace JSON {
    * @param data T
    * @returns string
    */
-  export function stringify<T>(data: T, out: string | null = null): string {
+  // @ts-ignore: inline
+  @inline export function stringify<T>(data: T, out: string | null = null): string {
     if (isBoolean<T>()) {
       if (out) {
         if (<bool>data == true) {
@@ -107,9 +117,7 @@ export namespace JSON {
       serializeString(changetype<string>(data));
       return bs.out<string>();
       // @ts-ignore: Supplied by transform
-    } else if (isDefined(data.__SERIALIZE) && isDefined(data.__ALLOCATE)) {
-      // @ts-ignore
-      // data.__ALLOCATE();
+    } else if (isDefined(data.__SERIALIZE)) {
       // @ts-ignore
       data.__SERIALIZE(changetype<usize>(data));
       return bs.out<string>();
@@ -119,8 +127,8 @@ export namespace JSON {
 
       store<u16>(changetype<usize>(out), QUOTE);
       memory.copy(changetype<usize>(out) + 2, changetype<usize>(data.toISOString()), 48);
-      store<u16>(changetype<usize>(out), 50);
-      return out;
+      store<u16>(changetype<usize>(out), QUOTE, 50);
+      return changetype<string>(out);
     } else if (data instanceof Array) {
       // @ts-ignore
       serializeArray(changetype<nonnull<T>>(data));
@@ -132,6 +140,9 @@ export namespace JSON {
     } else if (data instanceof JSON.Value) {
       serializeArbitrary(data);
       return bs.out<string>();
+    } else if (data instanceof JSON.Obj) {
+      serializeObject(data);
+      return bs.out<string>();
     } else if (data instanceof JSON.Box) {
       return JSON.stringify(data.value);
     } else {
@@ -147,7 +158,8 @@ export namespace JSON {
    * @param data string
    * @returns T
    */
-  export function parse<T>(data: string): T {
+  // @ts-ignore: inline
+  @inline export function parse<T>(data: string): T {
     const dataSize = bytes(data);
     const dataPtr = changetype<usize>(data);
     if (isBoolean<T>()) {
@@ -156,7 +168,7 @@ export namespace JSON {
       return deserializeInteger<T>(dataPtr, dataPtr + dataSize);
     } else if (isFloat<T>()) {
       return deserializeFloat<T>(dataPtr, dataPtr + dataSize);
-    } else if (isNullable<T>() && data.length == 4 && data == "null") {
+    } else if (isNullable<T>() && dataSize == 8 && load<u64>(dataPtr) == 30399761348886638) {
       // @ts-ignore
       return null;
     } else if (isString<T>()) {
@@ -168,21 +180,27 @@ export namespace JSON {
     }
     let type: nonnull<T> = changetype<nonnull<T>>(0);
     // @ts-ignore: Defined by transform
-    if (isDefined(type.__DESERIALIZE) && isDefined(type.__INITIALIZE)) {
+    if (isDefined(type.__DESERIALIZE)) {
       const out = __new(offsetof<nonnull<T>>(), idof<nonnull<T>>());
+      // @ts-ignore: Defined by transform
+      if (isDefined(type.__INITIALIZE)) changetype<nonnull<T>>(out).__INITIALIZE();
       // @ts-ignore
-      changetype<nonnull<T>>(out).__INITIALIZE();
-      // @ts-ignore
-      return deserializeObject<nonnull<T>>(dataPtr, dataPtr + dataSize, out);
+      return deserializeStruct<nonnull<T>>(dataPtr, dataPtr + dataSize, out);
     } else if (type instanceof Map) {
       // @ts-ignore
       return deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize);
     } else if (type instanceof Date) {
       // @ts-ignore
       return deserializeDate(dataPtr, dataPtr + dataSize);
+    } else if (type instanceof JSON.Value) {
+      // @ts-ignore
+      return deserializeArbitrary(dataPtr, dataPtr + dataSize, 0);
+    } else if (type instanceof JSON.Obj) {
+      // @ts-ignore
+      return deserializeObject(dataPtr, dataPtr + dataSize, 0);
     } else if (type instanceof JSON.Box) {
       // @ts-ignore
-      return new JSON.Box(JSON.parse<indexof<T>>(data));
+      return new JSON.Box(parseBox(data, changetype<nonnull<T>>(0).value));
     } else {
       throw new Error(`Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
     }
@@ -254,7 +272,7 @@ export namespace JSON {
         this.type = JSON.Types.U64;
         store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof f32) {
-        this.type = JSON.Types.F64;
+        this.type = JSON.Types.F32;
         store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof f64) {
         this.type = JSON.Types.F64;
@@ -274,6 +292,9 @@ export namespace JSON {
         // @ts-ignore
         if (!JSON.Value.METHODS.has(idof<T>())) JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE.index);
         // @ts-ignore
+        store<usize>(changetype<usize>(this), changetype<usize>(value), STORAGE);
+      } else if (value instanceof JSON.Obj) {
+        this.type = JSON.Types.Object;
         store<T>(changetype<usize>(this), value, STORAGE);
         // @ts-ignore
       } else if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>()) {
@@ -305,6 +326,10 @@ export namespace JSON {
           return this.get<u32>().toString();
         case JSON.Types.U64:
           return this.get<u64>().toString();
+        case JSON.Types.F32:
+          return this.get<f32>().toString();
+        case JSON.Types.F64:
+          return this.get<f64>().toString();
         case JSON.Types.String:
           return '"' + this.get<string>() + '"';
         case JSON.Types.Bool:
@@ -326,20 +351,88 @@ export namespace JSON {
           out.write("]");
           return out.toString();
         }
+        case JSON.Types.Object: {
+          return JSON.stringify(this.get<JSON.Obj>());
+        }
         default: {
           const fn = JSON.Value.METHODS.get(this.type - JSON.Types.Struct);
           const value = this.get<usize>();
-          return call_indirect<string>(fn, 0, value);
+          call_indirect<void>(fn, 0, value);
+          return bs.out<string>();
         }
       }
     }
   }
 
+  export class Obj {
+    // When accessing stackSize, subtract 2
+    // @ts-ignore: type
+    private stackSize: u32 = 6;
+    // @ts-ignore: type
+    private storage: Map<string, JSON.Value> = new Map<string, JSON.Value>();
+
+    constructor() { }
+
+    // @ts-ignore: decorator
+    @inline get size(): i32 {
+      return this.storage.size;
+    }
+
+    // @ts-ignore: decorator
+    @inline set<T>(key: string, value: T): void {
+      if (!this.storage.has(key)) this.stackSize += bytes(key) + 8;
+      this.storage.set(key, JSON.Value.from<T>(value));
+    }
+
+    // @ts-ignore: decorator
+    @inline get(key: string): JSON.Value | null {
+      if (!this.storage.has(key)) return null;
+      return this.storage.get(key);
+    }
+
+    // @ts-ignore: decorator
+    @inline has(key: string): bool {
+      return this.storage.has(key);
+    }
+
+    // @ts-ignore: decorator
+    @inline delete(key: string): bool {
+      return this.storage.delete(key);
+    }
+
+    // @ts-ignore: decorator
+    @inline keys(): string[] {
+      return this.storage.keys();
+    }
+
+    // @ts-ignore: decorator
+    @inline values(): JSON.Value[] {
+      return this.storage.values();
+    }
+
+    // @ts-ignore: decorator
+    @inline toString(): string {
+      return JSON.stringify(this);
+    }
+
+    // @ts-ignore: decorator
+    @inline static from<T>(value: T): JSON.Obj {
+      if (value instanceof JSON.Obj) return value;
+      const out = changetype<JSON.Obj>(__new(offsetof<JSON.Obj>(), idof<JSON.Obj>()));
+
+      if (value instanceof Map) {
+
+      }
+      return out;
+    }
+  }
   /**
    * Box for primitive types
    */
   export class Box<T> {
-    constructor(public value: T) {}
+    constructor(public value: T) {
+      if (!isInteger<T>() && !isFloat<T>()) ERROR("JSON.Box should only hold primitive types!");
+    }
     /**
      * Creates a reference to a primitive type
      * This means that it can create a nullable primitive
@@ -353,9 +446,16 @@ export namespace JSON {
     @inline static from<T>(value: T): Box<T> {
       return new Box(value);
     }
+    toString(): string {
+      if (isNullable<this>() && changetype<usize>(this) == null) return "null";
+      // @ts-ignore: type
+      if (isDefined(this.value.toString)) return this.value.toString();
+      return "null";
+    }
   }
 
-  export function __serialize<T>(src: T): void {
+  // @ts-ignore: inline
+  @inline export function __serialize<T>(src: T): void {
     if (isBoolean<T>()) {
       serializeBool(src as bool);
     } else if (isInteger<T>() && nameof<T>() == "usize" && src == 0) {
@@ -378,7 +478,7 @@ export namespace JSON {
       // @ts-ignore: Supplied by transform
     } else if (isDefined(src.__SERIALIZE)) {
       // @ts-ignore
-      serializeObject(changetype<nonnull<T>>(src));
+      serializeStruct(changetype<nonnull<T>>(src));
     } else if (src instanceof Date) {
       // @ts-ignore
       serializeDate(changetype<nonnull<T>>(src));
@@ -390,18 +490,22 @@ export namespace JSON {
       serializeMap(changetype<nonnull<T>>(src));
     } else if (src instanceof JSON.Value) {
       serializeArbitrary(src);
+    } else if (src instanceof JSON.Obj) {
+      serializeObject(src);
     } else if (src instanceof JSON.Box) {
       __serialize(src.value);
     } else {
       throw new Error(`Could not serialize provided data. Make sure to add the correct decorators to classes.`);
     }
   }
-  export function __deserialize<T>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
+  
+  // @ts-ignore: inline
+  @inline export function __deserialize<T>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
     if (isBoolean<T>()) {
       // @ts-ignore: type
       return deserializeBoolean(srcStart, srcEnd);
     } else if (isInteger<T>()) {
-      return deserializeInteger<T>(srcStart, srcEnd);
+      return atoi<T>(srcStart, srcEnd);
     } else if (isFloat<T>()) {
       return deserializeFloat<T>(srcStart, srcEnd);
     } else if (isString<T>()) {
@@ -414,15 +518,30 @@ export namespace JSON {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
       // @ts-ignore: declared by transform
       if (isDefined(type.__DESERIALIZE)) {
-        return deserializeObject<T>(srcStart, srcEnd, dst);
+        return deserializeStruct<T>(srcStart, srcEnd, dst);
       } else if (type instanceof Map) {
         // @ts-ignore: type
         return deserializeMap<T>(srcStart, srcEnd, dst);
       } else if (type instanceof Date) {
         // @ts-ignore: type
         return deserializeDate(srcStart, srcEnd);
+      } else if (type instanceof JSON.Value) {
+        // @ts-ignore: type
+        return deserializeArbitrary(srcStart, srcEnd, 0);
+      } else if (type instanceof JSON.Box) {
+        // @ts-ignore: type
+        return new JSON.Box(deserializeBox(srcStart, srcEnd, dst, changetype<nonnull<T>>(0).value));
       }
     }
     throw new Error(`Could not deserialize data '${ptrToStr(srcStart, srcEnd).slice(0, 100)}' to type. Make sure to add the correct decorators to classes.`);
   }
 }
+
+// @ts-ignore: decorator
+@inline function parseBox<T>(data: string, ty: T): T {
+  return JSON.parse<T>(data);
+}
+
+function deserializeBox<T>(srcStart: usize, srcEnd: usize, dst: usize, ty: T): T {
+  return JSON.__deserialize<T>(srcStart, srcEnd, dst);
+}

package/assembly/serialize/simd/string.ts

@@ -18,7 +18,7 @@ export function serializeString_SIMD(src: string): void {
   const srcSize = changetype<OBJECT>(changetype<usize>(src) - TOTAL_OVERHEAD).rtSize;
   let srcStart = changetype<usize>(src);
   const srcEnd = srcStart + srcSize;
-  bs.ensureSize(srcSize + 4);
+  bs.proposeSize(srcSize + 4);
   const srcEnd16 = srcEnd - 15;
 
   store<u8>(changetype<usize>(bs.offset), 34); /* " */
@@ -45,13 +45,13 @@ export function serializeString_SIMD(src: string): void {
       mask &= mask - 1;
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.addSize(10);
+        bs.growSize(10);
         store<u64>(dst_offset, 13511005048209500);
         store<u32>(dst_offset, escaped, 8);
         v128.store(dst_offset, v128.load(src_offset, 2), 12);
         bs.offset += 10;
       } else {
-        bs.addSize(2);
+        bs.growSize(2);
         store<u32>(dst_offset, escaped);
         v128.store(dst_offset, v128.load(src_offset, 2), 4);
         bs.offset += 2;
@@ -84,7 +84,7 @@ export function serializeString_SIMD(src: string): void {
       mask &= mask - 1;
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.addSize(10);
+        bs.growSize(10);
         store<u64>(dst_offset, 13511005048209500);
         store<u32>(dst_offset, escaped, 8);
         while (lane_index < 6) {
@@ -93,7 +93,7 @@ export function serializeString_SIMD(src: string): void {
         }
         bs.offset += 10;
       } else {
-        bs.addSize(2);
+        bs.growSize(2);
         store<u32>(dst_offset, escaped);
 
         while (lane_index < 6) {
@@ -116,12 +116,12 @@ export function serializeString_SIMD(src: string): void {
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (codeA << 2));
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.addSize(10);
+        bs.growSize(10);
         store<u64>(bs.offset, 13511005048209500);
         store<u32>(bs.offset, escaped, 8);
         bs.offset += 12;
       } else {
-        bs.addSize(2);
+        bs.growSize(2);
         store<u32>(bs.offset, escaped);
         bs.offset += 4;
       }
@@ -134,12 +134,12 @@ export function serializeString_SIMD(src: string): void {
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (codeB << 2));
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.addSize(10);
+        bs.growSize(10);
         store<u64>(bs.offset, 13511005048209500);
         store<u32>(bs.offset, escaped, 8);
         bs.offset += 12;
       } else {
-        bs.addSize(2);
+        bs.growSize(2);
         store<u32>(bs.offset, escaped);
         bs.offset += 4;
       }
@@ -156,12 +156,12 @@ export function serializeString_SIMD(src: string): void {
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
 
       if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.addSize(10);
+        bs.growSize(10);
         store<u64>(bs.offset, 13511005048209500);
         store<u32>(bs.offset, escaped, 8);
         bs.offset += 12;
       } else {
-        bs.addSize(2);
+        bs.growSize(2);
         store<u32>(bs.offset, escaped);
         bs.offset += 4;
       }