json-as 1.0.0-beta.9 → 1.0.1

package/assembly/deserialize/simple/map.ts

@@ -1,154 +1,172 @@
 import { JSON } from "../..";
 import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
 import { isSpace } from "../../util";
+import { ptrToStr } from "../../util/ptrToStr";
 
 export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<T>(dst || __new(offsetof<T>(), idof<T>()));
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
   // @ts-ignore: type
   if (!isString<indexof<T>>() && !isInteger<indexof<T>>() && !isFloat<indexof<T>>()) throw new Error("Map key must also be a valid JSON key!");
 
-  const srcPtr = srcStart;
-  let key: string | null = null;
+  let keyStart: usize = 0;
+  let keyEnd: usize = 0;
   let isKey = false;
   let depth = 0;
-  let lastIndex = 0;
+  let lastIndex: usize = 0;
 
-  // while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
-  // while (srcEnd > srcStart && isSpace(load<u16>(srcEnd))) srcEnd -= 2;
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
 
+  if (srcStart - srcEnd == 0)
+    throw new Error("Input string had zero length or was all whitespace");
+  if (load<u16>(srcStart) != BRACE_LEFT) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
+  if (load<u16>(srcEnd - 2) != BRACE_RIGHT) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
+
+  srcStart += 2;
   while (srcStart < srcEnd) {
     let code = load<u16>(srcStart); // while (isSpace(code)) code = load<u16>(srcStart += 2);
-    if (key == null) {
+    if (keyStart == 0) {
       if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
         if (isKey) {
-          key = sliceTo(lastIndex, srcStart);
-          while (isSpace((code = load<u16>((srcStart += 2))))) {
-            /* empty */
-          }
-          if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcStart - srcPtr).toString());
+          keyStart = lastIndex;
+          keyEnd = srcStart;
+          // console.log("Key: " + ptrToStr(lastIndex, srcStart));
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
+          while (isSpace((code = load<u16>((srcStart += 2))))) { }
+          if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
           isKey = false;
         } else {
-          isKey = true;
+          // console.log("Got key start");
+          isKey = true; // i don't like this
           lastIndex = srcStart + 2;
         }
       }
       // isKey = !isKey;
       srcStart += 2;
     } else {
-      // @ts-ignore: type
-      if (isString<valueof<T>>() && code == QUOTE) {
+      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: type
-            out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
-            key = null;
+            out.set(ptrToStr(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart + 2));
+            // while (isSpace(load<u16>(srcStart))) srcStart += 2;
+            srcStart += 4;
+            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+            keyStart = 0;
             break;
           }
           srcStart += 2;
         }
-        // @ts-ignore: type
-      } else if ((!isBoolean<valueof<T>>() && isInteger<valueof<T>>() && code - 48 <= 9) || code == 45) {
+      } else if (code - 48 <= 9 || code == 45) {
         lastIndex = srcStart;
         srcStart += 2;
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
-          if (code == COMMA || isSpace(code) || code == BRACE_RIGHT) {
+          if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
+            // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
             // @ts-ignore: type
-            out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
-            while (isSpace(load<u16>((srcStart += 2)))) {
-              /* empty */
-            }
-            key = null;
+            out.set(ptrToStr(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            // while (isSpace(load<u16>((srcStart += 2)))) {
+            //   /* empty */
+            // }
+            srcStart += 2;
+            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+            keyStart = 0;
             break;
           }
           srcStart += 2;
         }
-        // @ts-ignore: type
-      } else if (isArray<valueof<T>>() && code == BRACKET_LEFT) {
+      } else if (code == BRACE_LEFT) {
         lastIndex = srcStart;
         depth++;
         srcStart += 2;
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
-          if (code == BRACKET_RIGHT) {
+          if (code == QUOTE) {
+            srcStart += 2;
+            while (!(load<u16>(srcStart) == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)) srcStart += 2;
+          } else if (code == BRACE_RIGHT) {
             if (--depth == 0) {
+              // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
               // @ts-ignore: type
-              out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
-              while (isSpace(load<u16>((srcStart += 2)))) {
-                /* empty */
-              }
-              key = null;
+              out.set(ptrToStr(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+              keyStart = 0;
+              // while (isSpace(load<u16>(srcStart))) {
+              //   /* empty */
+              // }
               break;
             }
-          } else if (code == BRACKET_LEFT) depth++;
+          } else if (code == BRACE_LEFT) depth++;
           srcStart += 2;
         }
-        // @ts-ignore: type
-      } else if (isDefined(changetype<nonnull<valueof<T>>>(0).__DESERIALIZE) && code == BRACE_LEFT) {
+      } else if (code == BRACKET_LEFT) {
         lastIndex = srcStart;
         depth++;
         srcStart += 2;
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
-          if (code == BRACE_RIGHT) {
+          if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
+              // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
               // @ts-ignore: type
-              out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
-              while (isSpace(load<u16>((srcStart += 2)))) {
-                /* empty */
-              }
-              key = null;
+              out.set(ptrToStr(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+              keyStart = 0;
+              // while (isSpace(load<u16>((srcStart += 2)))) {
+              //   /* empty */
+              // }
               break;
             }
-          } else if (code == BRACE_LEFT) depth++;
+          } else if (code == BRACKET_LEFT) depth++;
           srcStart += 2;
         }
-        // @ts-ignore: type
-      } else if (isBoolean<valueof<T>>() && code == CHAR_T) {
+      } else if (code == CHAR_T) {
         if (load<u64>(srcStart) == 28429475166421108) {
+          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
           // @ts-ignore: type
-          out.set(key, JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
-          while (isSpace(load<u16>((srcStart += 2)))) {
-            /* empty */
-          }
-          key = null;
+          out.set(ptrToStr(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          srcStart += 2;
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)) + "  " + (srcStart < srcEnd).toString());
+          keyStart = 0;
         }
-        // @ts-ignore: type
-      } else if (isBoolean<valueof<T>>() && code == CHAR_F) {
+      } else if (code == CHAR_F) {
         if (load<u64>(srcStart, 2) == 28429466576093281) {
+          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
           // @ts-ignore: type
-          out.set(key, JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 10)));
-          while (isSpace(load<u16>((srcStart += 2)))) {
-            /* empty */
-          }
-          key = null;
+          out.set(ptrToStr(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 10)));
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          srcStart += 2;
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+          keyStart = 0;
         }
-      } else if ((isNullable<T>() || nameof<T>() == "usize") && code == CHAR_N) {
+      } else if (code == CHAR_N) {
         if (load<u64>(srcStart) == 30399761348886638) {
+          // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
           // @ts-ignore: type
-          out.set(key, JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
-          while (isSpace(load<u16>((srcStart += 2)))) {
-            /* empty */
-          }
+          out.set(ptrToStr(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          /* empty */
+          // }
+          srcStart += 2;
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+          keyStart = 0;
         }
+      } else if (isSpace(code)) {
+        srcStart += 2;
       } else {
-        // @ts-ignore: type
-        throw new Error("Unexpected character " + String.fromCharCode(code) + " or type " + nameof<valueof<T>>() + " does not match found type!");
+        throw new Error("Unexpected character in JSON object '" + String.fromCharCode(code) + "' at position " + (srcEnd - srcStart).toString());
       }
     }
   }
   return out;
-}
-
-function sliceTo(srcStart: usize, srcEnd: usize): string {
-  const dstSize = srcEnd - srcStart;
-  const dst = __new(dstSize, idof<string>());
-  memory.copy(dst, srcStart, dstSize);
-  return changetype<string>(dst);
-}
+}

package/assembly/deserialize/simple/object.ts

@@ -1,11 +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 { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
 import { isSpace } from "../../util";
 import { ptrToStr } from "../../util/ptrToStr";
 import { deserializeArbitrary } from "./arbitrary";
 
 export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): JSON.Obj {
-  const out = new JSON.Obj();
+  const out = changetype<JSON.Obj>(dst || changetype<usize>(new JSON.Obj()));
 
   let keyStart: usize = 0;
   let keyEnd: usize = 0;
@@ -13,8 +13,14 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
   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;
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
+
+  if (srcStart - srcEnd == 0)
+    throw new Error("Input string had zero length or was all whitespace");
+  if (load<u16>(srcStart) != BRACE_LEFT) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
+  if (load<u16>(srcEnd - 2) != BRACE_RIGHT) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
+
   srcStart += 2;
   while (srcStart < srcEnd) {
     let code = load<u16>(srcStart); // while (isSpace(code)) code = load<u16>(srcStart += 2);
@@ -23,13 +29,10 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
         if (isKey) {
           keyStart = lastIndex;
           keyEnd = srcStart;
-          // console.log("Key: " + ptrToStr(keyStart, keyEnd));
+          // 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());
+          while (isSpace((code = load<u16>((srcStart += 2))))) { }
+          if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
           isKey = false;
         } else {
           // console.log("Got key start");
@@ -80,10 +83,13 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
         srcStart += 2;
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
-          if (code == BRACE_RIGHT) {
+          if (code == QUOTE) {
+            srcStart += 2;
+            while (!(load<u16>(srcStart) == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)) srcStart += 2;
+          } else if (code == BRACE_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-              out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(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,7 +109,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
-              out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(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)))) {
@@ -117,7 +123,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
       } else if (code == CHAR_T) {
         if (load<u64>(srcStart) == 28429475166421108) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
-          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 8, dst));
+          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(srcStart, (srcStart += 8), dst));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -128,7 +134,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
       } else if (code == CHAR_F) {
         if (load<u64>(srcStart, 2) == 28429466576093281) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
-          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 10, dst));
+          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(srcStart, (srcStart += 10), dst));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -139,7 +145,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
       } else if (code == CHAR_N) {
         if (load<u64>(srcStart) == 30399761348886638) {
           // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
-          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart += 8, dst));
+          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(srcStart, (srcStart += 8), dst));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */
           // }
@@ -147,6 +153,10 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
           keyStart = 0;
         }
+      } else if (isSpace(code)) {
+        srcStart += 2;
+      } else {
+        throw new Error("Unexpected character in JSON object '" + String.fromCharCode(code) + "' at position " + (srcEnd - srcStart).toString());
       }
     }
   }

package/assembly/deserialize/simple/struct.ts

@@ -1,23 +1,29 @@
 import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
 import { isSpace } from "../../util";
+import { ptrToStr } from "../../util/ptrToStr";
 
 export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize): T {
   const out = changetype<nonnull<T>>(dst || __new(offsetof<T>(), idof<T>()));
 
+  // @ts-ignore: supplied by transform
+  if (isDefined(out.__INITIALIZE)) out.__INITIALIZE();
+
   let keyStart: usize = 0;
   let keyEnd: usize = 0;
   let isKey = false;
   let depth = 0;
   let lastIndex: usize = 0;
 
-  while (isSpace(load<u16>(srcStart))) srcStart += 2;
-  while (isSpace(load<u16>(srcEnd -= 2))) {};
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2; // would like to optimize this later
 
+  if (srcStart - srcEnd == 0)
+    throw new Error("Input string had zero length or was all whitespace");
   if (load<u16>(srcStart) != BRACE_LEFT) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
-  if (load<u16>(srcEnd) != BRACE_RIGHT) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
+  if (load<u16>(srcEnd - 2) != BRACE_RIGHT) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
 
   srcStart += 2;
-  while (srcStart <= srcEnd) {
+  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) {
@@ -26,7 +32,7 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
           keyEnd = srcStart;
           // console.log("Key: " + ptrToStr(lastIndex, srcStart));
           // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
-          while (isSpace((code = load<u16>((srcStart += 2))))) {}
+          while (isSpace((code = load<u16>((srcStart += 2))))) { }
           if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
           isKey = false;
         } else {
@@ -41,12 +47,12 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
       if (code == QUOTE) {
         lastIndex = srcStart;
         srcStart += 2;
-        while (srcStart <= srcEnd) {
+        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);
+            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart + 2, changetype<usize>(out));
             // while (isSpace(load<u16>(srcStart))) srcStart += 2;
             srcStart += 4;
             // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
@@ -58,12 +64,12 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
       } else if (code - 48 <= 9 || code == 45) {
         lastIndex = srcStart;
         srcStart += 2;
-        while (srcStart <= srcEnd) {
+        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);
+            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart, changetype<usize>(out));
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -78,13 +84,16 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
         lastIndex = srcStart;
         depth++;
         srcStart += 2;
-        while (srcStart <= srcEnd) {
+        while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
-          if (code == BRACE_RIGHT) {
+          if (code == QUOTE) {
+            srcStart += 2;
+            while (!(load<u16>(srcStart) == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)) srcStart += 2;
+          } else 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.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), changetype<usize>(out));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>(srcStart))) {
@@ -99,13 +108,16 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
         lastIndex = srcStart;
         depth++;
         srcStart += 2;
-        while (srcStart <= srcEnd) {
+        while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
-          if (code == BRACKET_RIGHT) {
+          if (code == QUOTE) {
+            srcStart += 2;
+            while (!(load<u16>(srcStart) == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)) srcStart += 2;
+          } else 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.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), changetype<usize>(out));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>((srcStart += 2)))) {
@@ -120,19 +132,19 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
         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.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), changetype<usize>(out));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
           srcStart += 2;
-          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)) + "  " + (srcStart <= srcEnd).toString());
+          // 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);
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 10), changetype<usize>(out));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -144,7 +156,7 @@ export function deserializeStruct<T>(srcStart: usize, srcEnd: usize, dst: usize)
         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.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), changetype<usize>(out));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */
           // }

package/assembly/index.ts

@@ -1,5 +1,6 @@
 /// <reference path="./index.d.ts" />
 
+import { bs } from "../lib/as-bs";
 import { serializeString } from "./serialize/simple/string";
 import { serializeArray } from "./serialize/simple/array";
 import { serializeMap } from "./serialize/simple/map";
@@ -66,7 +67,7 @@ export namespace JSON {
         return out;
       }
       return data ? "true" : "false";
-    } else if (isInteger<T>() && nameof<T>() == "usize" && data == 0) {
+    } else if (isInteger<T>() && !isSigned<T>() && nameof<T>() == "usize" && data == 0) {
       if (out) {
         out = changetype<string>(__renew(changetype<usize>(out), 8));
         store<u64>(changetype<usize>(out), 30399761348886638);
@@ -233,11 +234,12 @@ export namespace JSON {
     U64 = 4,
     F32 = 5,
     F64 = 6,
-    Bool = 7,
-    String = 8,
-    Object = 9,
-    Array = 10,
-    Struct = 11,
+    Null = 7,
+    Bool = 8,
+    String = 9,
+    Object = 10,
+    Array = 12,
+    Struct = 13,
   }
 
   export class Raw {
@@ -297,6 +299,9 @@ export namespace JSON {
       if (isBoolean<T>()) {
         this.type = JSON.Types.Bool;
         store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (isInteger<T>() && !isSigned<T>() && changetype<usize>(value) == 0 && nameof<T>() == "usize") {
+        this.type = JSON.Types.Null;
+        store<usize>(changetype<usize>(this), 0, STORAGE);
       } else if (value instanceof u8 || value instanceof i8) {
         this.type = JSON.Types.U8;
         store<T>(changetype<usize>(this), value, STORAGE);
@@ -514,8 +519,7 @@ export namespace JSON {
     }
   }
 
-  // @ts-ignore: inline
-  @inline export function __serialize<T>(src: T): void {
+  export function __serialize<T>(src: T): void {
     if (isBoolean<T>()) {
       serializeBool(src as bool);
     } else if (isInteger<T>() && nameof<T>() == "usize" && src == 0) {
@@ -565,8 +569,7 @@ export namespace JSON {
     }
   }
 
-  // @ts-ignore: inline
-  @inline export function __deserialize<T>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
+  export function __deserialize<T>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
     if (isBoolean<T>()) {
       // @ts-ignore: type
       return deserializeBoolean(srcStart, srcEnd);
@@ -588,7 +591,7 @@ export namespace JSON {
         // @ts-ignore: Defined by transform
         if (isDefined(type.__INITIALIZE)) changetype<nonnull<T>>(out).__INITIALIZE();
         // @ts-ignore
-        return changetype<nonnull<T>>(out).__DESERIALIZE_CUSTOM(ptrToStr(dataPtr, dataPtr + dataSize));
+        return changetype<nonnull<T>>(out).__DESERIALIZE_CUSTOM(ptrToStr(srcStart, srcEnd));
         // @ts-ignore: Defined by transform
       } else if (isDefined(type.__DESERIALIZE)) {
         return deserializeStruct<T>(srcStart, srcEnd, dst);

package/assembly/serialize/simple/array.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
 

package/assembly/serialize/simple/bool.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 /**
  * Serialize a bool to type string
  * @param data data to serialize

package/assembly/serialize/simple/date.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { QUOTE } from "../../custom/chars";
 import { bytes } from "../../util/bytes";
 

package/assembly/serialize/simple/float.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { dtoa_buffered } from "util/number";
 
 export function serializeFloat<T extends number>(data: T): void {

package/assembly/serialize/simple/integer.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { itoa_buffered } from "util/number";
 
 export function serializeInteger<T extends number>(data: T): void {

package/assembly/serialize/simple/map.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { JSON } from "../..";
 import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
 

package/assembly/serialize/simple/object.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { JSON } from "../..";
 import { BRACE_LEFT, BRACE_RIGHT, QUOTE } from "../../custom/chars";
 import { bytes } from "../../util";

package/assembly/serialize/simple/raw.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { JSON } from "../..";
 import { bytes } from "../../util";
 

package/assembly/serialize/simple/string.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { _intTo16 } from "../../custom/util";
 import { bytes } from "../../util/bytes";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";