json-as 1.3.1 → 1.3.3

package/assembly/deserialize/simple/set.ts

@@ -1,39 +1,66 @@
 import { JSON } from "../..";
-import { BACK_SLASH, BRACKET_LEFT, BRACKET_RIGHT, BRACE_LEFT, BRACE_RIGHT, CHAR_F, CHAR_N, CHAR_T, COMMA, QUOTE } from "../../custom/chars";
-import { isSpace, atoi, isUnescapedQuote, scanStringEnd } from "../../util";
+import { BRACKET_LEFT, BRACKET_RIGHT, BRACE_LEFT, BRACE_RIGHT, CHAR_F, CHAR_T, COMMA, QUOTE } from "../../custom/chars";
+import { isSpace, atoi, scanStringEnd } from "../../util";
 
-export function deserializeSet<T extends Set<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+// @ts-expect-error: Decorator valid here
+@inline function scanSetElementEnd(srcStart: usize, srcEnd: usize): usize {
+  const first = load<u16>(srcStart);
 
-  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
-  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  if (first == QUOTE) {
+    const end = scanStringEnd(srcStart, srcEnd);
+    return end < srcEnd ? end + 2 : 0;
+  }
 
-  if (srcStart >= srcEnd) 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 set");
-  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT) throw new Error("Expected ']' at end of set");
+  if (first == BRACE_LEFT || first == BRACKET_LEFT) {
+    let depth: i32 = 1;
+    let ptr = srcStart + 2;
+
+    while (ptr < srcEnd) {
+      const code = load<u16>(ptr);
+      if (code == QUOTE) {
+        ptr = scanStringEnd(ptr, srcEnd);
+        if (ptr >= srcEnd) return 0;
+      } else if (code == BRACE_LEFT || code == BRACKET_LEFT) {
+        depth++;
+      } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
+        if (--depth == 0) return ptr + 2;
+      }
+      ptr += 2;
+    }
+
+    return 0;
+  }
+
+  let ptr = srcStart;
+  while (ptr < srcEnd) {
+    const code = load<u16>(ptr);
+    if (code == COMMA || code == BRACKET_RIGHT) return ptr;
+    ptr += 2;
+  }
+
+  return 0;
+}
+
+function deserializeSetDirect<T extends Set<any>>(srcStart: usize, srcEnd: usize, out: nonnull<T>, allowWhitespace: bool = false): usize {
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Expected '[' at start of set");
 
   srcStart += 2;
+  if (allowWhitespace) while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (srcStart >= srcEnd) throw new Error("Unterminated set");
+  if (load<u16>(srcStart) == BRACKET_RIGHT) return srcStart + 2;
 
-  while (srcStart < srcEnd - 2) {
-    let code = load<u16>(srcStart);
-    while (isSpace(code)) code = load<u16>((srcStart += 2));
+  while (srcStart < srcEnd) {
+    if (allowWhitespace) while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    const code = load<u16>(srcStart);
 
     // @ts-ignore: type
     if (isString<indexof<T>>()) {
-      if (code == QUOTE) {
-        const lastIndex = srcStart;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const c = load<u16>(srcStart);
-          if (c == QUOTE && isUnescapedQuote(srcStart)) {
-            // @ts-ignore: type
-            out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart + 2));
-            srcStart += 2;
-            break;
-          }
-          srcStart += 2;
-        }
-      }
+      if (code != QUOTE) break;
+      const end = scanStringEnd(srcStart, srcEnd);
+      if (end >= srcEnd) break;
+      // @ts-ignore: type
+      out.add(JSON.__deserialize<indexof<T>>(srcStart, end + 2));
+      srcStart = end + 2;
       // @ts-ignore: type
     } else if (isBoolean<indexof<T>>()) {
       if (code == CHAR_T) {
@@ -44,126 +71,84 @@ export function deserializeSet<T extends Set<any>>(srcStart: usize, srcEnd: usiz
         // @ts-ignore: type
         out.add(<indexof<T>>false);
         srcStart += 10;
+      } else {
+        break;
       }
       // @ts-ignore: type
     } else if (isInteger<indexof<T>>()) {
-      if (code - 48 <= 9 || code == 45) {
-        const lastIndex = srcStart;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const c = load<u16>(srcStart);
-          if (c == COMMA || c == BRACKET_RIGHT || isSpace(c)) {
-            // @ts-ignore: type
-            out.add(atoi<indexof<T>>(lastIndex, srcStart));
-            break;
-          }
-          srcStart += 2;
-        }
+      if (code - 48 > 9 && code != 45) break;
+      let ptr = srcStart + 2;
+      while (ptr < srcEnd) {
+        const next = load<u16>(ptr);
+        if (next == COMMA || next == BRACKET_RIGHT || (allowWhitespace && isSpace(next))) break;
+        ptr += 2;
       }
       // @ts-ignore: type
+      out.add(atoi<indexof<T>>(srcStart, ptr));
+      srcStart = ptr;
+      // @ts-ignore: type
     } else if (isFloat<indexof<T>>()) {
-      if (code - 48 <= 9 || code == 45) {
-        const lastIndex = srcStart;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const c = load<u16>(srcStart);
-          if (c == COMMA || c == BRACKET_RIGHT || isSpace(c)) {
-            // @ts-ignore: type
-            out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart));
-            break;
-          }
-          srcStart += 2;
-        }
+      if (code - 48 > 9 && code != 45) break;
+      let ptr = srcStart + 2;
+      while (ptr < srcEnd) {
+        const next = load<u16>(ptr);
+        if (next == COMMA || next == BRACKET_RIGHT || (allowWhitespace && isSpace(next))) break;
+        ptr += 2;
       }
       // @ts-ignore: type
+      out.add(JSON.__deserialize<indexof<T>>(srcStart, ptr));
+      srcStart = ptr;
+      // @ts-ignore: type
     } else if (isManaged<indexof<T>>() || isReference<indexof<T>>()) {
+      const end = scanSetElementEnd(srcStart, srcEnd);
+      if (!end) break;
       // @ts-ignore: type
-      const type = changetype<nonnull<indexof<T>>>(0);
-      if (code == BRACE_LEFT) {
-        // Object
-        const lastIndex = srcStart;
-        let depth: u32 = 1;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const c = load<u16>(srcStart);
-          if (c == QUOTE) {
-            srcStart = scanStringEnd(srcStart, srcEnd);
-            if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON set");
-          } else if (c == BRACE_RIGHT) {
-            if (--depth == 0) {
-              srcStart += 2;
-              // @ts-ignore: type
-              out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart));
-              break;
-            }
-          } else if (c == BRACE_LEFT) {
-            depth++;
-          }
-          srcStart += 2;
-        }
-      } else if (code == BRACKET_LEFT) {
-        // Nested array/set
-        const lastIndex = srcStart;
-        let depth: u32 = 1;
-        srcStart += 2;
-        while (srcStart < srcEnd) {
-          const c = load<u16>(srcStart);
-          if (c == BRACKET_RIGHT) {
-            if (--depth == 0) {
-              srcStart += 2;
-              // @ts-ignore: type
-              out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart));
-              break;
-            }
-          } else if (c == BRACKET_LEFT) {
-            depth++;
-          }
-          srcStart += 2;
-        }
-      } else if (type instanceof JSON.Raw) {
-        // Handle JSON.Raw
-        if (code == QUOTE) {
-          const lastIndex = srcStart;
-          srcStart += 2;
-          while (srcStart < srcEnd) {
-            const c = load<u16>(srcStart);
-            if (c == QUOTE && isUnescapedQuote(srcStart)) {
-              // @ts-ignore: type
-              out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart + 2));
-              srcStart += 2;
-              break;
-            }
-            srcStart += 2;
-          }
-        } else if (code - 48 <= 9 || code == 45) {
-          const lastIndex = srcStart;
-          srcStart += 2;
-          while (srcStart < srcEnd) {
-            const c = load<u16>(srcStart);
-            if (c == COMMA || c == BRACKET_RIGHT || isSpace(c)) {
-              // @ts-ignore: type
-              out.add(JSON.__deserialize<indexof<T>>(lastIndex, srcStart));
-              break;
-            }
-            srcStart += 2;
-          }
-        } else if (code == CHAR_T) {
-          // @ts-ignore: type
-          out.add(JSON.__deserialize<indexof<T>>(srcStart, srcStart + 8));
-          srcStart += 8;
-        } else if (code == CHAR_F) {
-          // @ts-ignore: type
-          out.add(JSON.__deserialize<indexof<T>>(srcStart, srcStart + 10));
-          srcStart += 10;
-        } else if (code == CHAR_N) {
-          // @ts-ignore: type
-          out.add(JSON.__deserialize<indexof<T>>(srcStart, srcStart + 8));
-          srcStart += 8;
-        }
-      }
+      out.add(JSON.__deserialize<indexof<T>>(srcStart, end));
+      srcStart = end;
+    } else {
+      break;
+    }
+
+    if (allowWhitespace) while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    const next = load<u16>(srcStart);
+    if (next == COMMA) {
+      srcStart += 2;
+      if (allowWhitespace) while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+      continue;
     }
-    srcStart += 2;
+    if (next == BRACKET_RIGHT) return srcStart + 2;
+    break;
   }
 
+  throw new Error("Failed to parse JSON!");
+}
+
+export function deserializeSet<T extends Set<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+  out.clear();
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
+  if (srcStart >= srcEnd) throw new Error("Input string had zero length or was all whitespace");
+  const end = deserializeSetDirect<T>(srcStart, srcEnd, out, true);
+  if (end != srcEnd) throw new Error("Expected ']' at end of set");
   return out;
 }
+
+// @ts-expect-error: Decorator valid here
+@inline export function deserializeSetInto<T extends Set<any>>(srcStart: usize, srcEnd: usize, out: T): usize {
+  changetype<nonnull<T>>(out).clear();
+  return deserializeSetDirect<T>(srcStart, srcEnd, changetype<nonnull<T>>(out));
+}
+
+// @ts-expect-error: Decorator valid here
+@inline export function deserializeSetField<T extends Set<any>>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  let out = load<T>(dstObj, dstOffset);
+  if (!changetype<usize>(out)) {
+    out = changetype<T>(instantiate<T>());
+    store<T>(dstObj, out, dstOffset);
+  }
+  return deserializeSetInto<T>(srcStart, srcEnd, out);
+}

package/assembly/deserialize/simple/staticarray.ts

@@ -15,6 +15,7 @@ import { deserializeStaticArrayBoolean } from "./staticarray/bool";
 import { deserializeStaticArrayFloat } from "./staticarray/float";
 import { deserializeStaticArrayInteger } from "./staticarray/integer";
 import { deserializeStaticArrayString } from "./staticarray/string";
+import { scanValueEnd } from "../swar/array/shared";
 
 
 @inline function materializeStaticArray<T extends StaticArray<any>>(src: valueof<T>[], dst: usize): T {
@@ -63,10 +64,21 @@ export function deserializeStaticArray<T extends StaticArray<any>>(srcStart: usi
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
       return materializeStaticArray<T>(deserializeStructArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
       // @ts-ignore: supplied by transform
-    } else if (isDefined(type.__DESERIALIZE)) {
+    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
       return materializeStaticArray<T>(deserializeStructArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
     }
   }
 
   throw new Error("Could not parse static array of type " + nameof<T>() + "!");
 }
+
+
+@inline export function deserializeStaticArrayField<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const valueEnd = scanValueEnd(srcStart, srcEnd);
+  if (!valueEnd) throw new Error("Failed to parse JSON!");
+
+  const fieldPtr = dstObj + dstOffset;
+  const out = deserializeStaticArray<T>(srcStart, valueEnd, load<usize>(fieldPtr));
+  store<T>(fieldPtr, out);
+  return valueEnd;
+}

package/assembly/deserialize/simple/string.ts

@@ -1,4 +1,5 @@
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { __heap_base } from "memory";
 import { bs } from "../../../lib/as-bs";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
@@ -13,11 +14,13 @@ import { hex4_to_u16_swar } from "../../util/swar";
 
   const current = load<usize>(dstFieldPtr);
   let stringPtr: usize;
-  if (current != 0 && changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
-    stringPtr = current;
-  } else if (current != 0 && current != changetype<usize>("")) {
-    stringPtr = __renew(current, byteLength);
-    store<usize>(dstFieldPtr, stringPtr);
+  if (current >= __heap_base) {
+    if (changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
+      stringPtr = current;
+    } else {
+      stringPtr = __renew(current, byteLength);
+      store<usize>(dstFieldPtr, stringPtr);
+    }
   } else {
     stringPtr = __new(byteLength, idof<string>());
     store<usize>(dstFieldPtr, stringPtr);
@@ -65,7 +68,8 @@ import { hex4_to_u16_swar } from "../../util/swar";
 }
 
 // @ts-ignore: inline
-@inline export function deserializeStringField<T extends string | null>(srcStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
+@inline export function deserializeStringField<T extends string | null>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const dstFieldPtr = dstObj + dstOffset;
   if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) abort("Expected leading quote");
 
   const payloadStart = srcStart + 2;
@@ -82,18 +86,19 @@ import { hex4_to_u16_swar } from "../../util/swar";
       continue;
     }
 
-    const outStart = bs.offset - bs.buffer;
+    bs.offset = bs.buffer;
     bs.ensureSize(u32(srcEnd - payloadStart));
     const prefixLen = <u32>(srcStart - payloadStart);
     if (prefixLen != 0) {
-      memory.copy(bs.offset, payloadStart, prefixLen);
+      memory.copy(bs.buffer, payloadStart, prefixLen);
       bs.offset += prefixLen;
     }
 
     while (srcStart < srcEnd) {
       const block = load<u16>(srcStart);
       if (block == QUOTE) {
-        bs.toField(outStart, dstFieldPtr);
+        writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
+        bs.offset = bs.buffer;
         return srcStart + 2;
       }
 
@@ -118,7 +123,7 @@ import { hex4_to_u16_swar } from "../../util/swar";
       bs.offset += 2;
     }
 
-    bs.offset = bs.buffer + outStart;
+    bs.offset = bs.buffer;
     break;
   }
 

package/assembly/deserialize/simple/struct.ts

@@ -1,165 +1,17 @@
-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, isUnescapedQuote, scanStringEnd } from "../../util";
-
 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 (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 (keyStart == 0) {
-      if (code == QUOTE && isUnescapedQuote(srcStart)) {
-        if (isKey) {
-          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 {
-          // 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 = scanStringEnd(srcStart, srcEnd);
-        if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
-        // @ts-ignore: exists
-        out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart + 2, changetype<usize>(out));
-        srcStart += 2;
-        keyStart = 0;
-        continue;
-      } 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, changetype<usize>(out));
-            // 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 == QUOTE) {
-            srcStart = scanStringEnd(srcStart, srcEnd);
-            if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
-          } 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), changetype<usize>(out));
-              // 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 == QUOTE) {
-            srcStart = scanStringEnd(srcStart, srcEnd);
-            if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
-          } 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), changetype<usize>(out));
-              // 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), changetype<usize>(out));
-          // 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), changetype<usize>(out));
-          // 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), changetype<usize>(out));
-          // 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 {
-        throw new Error("Unexpected character in JSON object '" + String.fromCharCode(code) + "' at position " + (srcEnd - srcStart).toString());
-      }
-    }
+  // @ts-ignore: supplied by transform
+  if (isDefined(out.__DESERIALIZE_FAST)) {
+    // @ts-ignore: supplied by transform
+    out.__DESERIALIZE_FAST(srcStart, srcEnd, out);
+  } else if (isDefined(out.__DESERIALIZE_SLOW)) {
+    // @ts-ignore: supplied by transform
+    out.__DESERIALIZE_SLOW(srcStart, srcEnd, out);
+  } else {
+    throw new Error("Missing __DESERIALIZE_FAST/__DESERIALIZE_SLOW");
   }
   return out;
 }

package/assembly/deserialize/simple/typedarray.ts

@@ -1,5 +1,5 @@
 import { COMMA, BRACKET_RIGHT } from "../../custom/chars";
-import { deserializeFloat } from "../index/float";
+import { deserializeFloat } from "./float";
 import { atoi, isSpace } from "../../util";
 
 

package/assembly/deserialize/{unsigned.ts → simple/unsigned.ts}

@@ -1,4 +1,4 @@
-import { atoi } from "../util/atoi";
+import { atoi } from "../../util/atoi";
 
 // @ts-ignore: inline
 @inline export function deserializeUnsigned<T>(srcStart: usize, srcEnd: usize): T {
@@ -6,7 +6,8 @@ import { atoi } from "../util/atoi";
 }
 
 // @ts-ignore: inline
-@inline export function deserializeUnsignedField<T extends number>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+@inline export function deserializeUnsignedField<T extends number>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const fieldPtr = dstObj + dstOffset;
   let digit = <u32>load<u16>(srcStart) - 48;
   if (digit > 9) unreachable();
 

package/assembly/deserialize/swar/array/array.ts

@@ -1,10 +1,10 @@
+import { JSON } from "../../..";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
-import { deserializeArrayField } from "../array";
-import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+import { deserializeFloatArrayInto } from "./float";
+import { ensureArrayField, scanValueEnd } from "./shared";
 
 
-@inline export function deserializeArrayArrayField<T extends unknown[][]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  const out = ensureArrayField<T>(fieldPtr);
+@inline export function deserializeArrayArrayInto<T extends unknown[][]>(srcStart: usize, srcEnd: usize, out: T): usize {
   let index = 0;
 
   do {
@@ -17,9 +17,39 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
     }
 
     while (srcStart < srcEnd) {
-      const slot = ensureArrayElementSlot<T>(out, index);
-      srcStart = deserializeArrayField<valueof<T>>(srcStart, srcEnd, slot);
-      if (!srcStart || srcStart >= srcEnd) break;
+      if (isFloat<valueof<valueof<T>>>()) {
+        let value: valueof<T>;
+        if (index < out.length) {
+          value = unchecked(out[index]);
+        } else {
+          value = changetype<valueof<T>>(instantiate<valueof<T>>());
+          out.push(value);
+        }
+        srcStart = deserializeFloatArrayInto<valueof<T>>(srcStart, srcEnd, value);
+        if (!srcStart || srcStart >= srcEnd) break;
+      } else if (isArray<valueof<valueof<T>>>()) {
+        let value: valueof<T>;
+        if (index < out.length) {
+          value = unchecked(out[index]);
+        } else {
+          value = changetype<valueof<T>>(instantiate<valueof<T>>());
+          out.push(value);
+        }
+        srcStart = deserializeArrayArrayInto<valueof<T>>(srcStart, srcEnd, value);
+        if (!srcStart || srcStart >= srcEnd) break;
+      } else {
+        const valueEnd = scanValueEnd(srcStart, srcEnd);
+        if (!valueEnd || valueEnd <= srcStart) break;
+
+        let valuePtr: usize = 0;
+        if (index < out.length) {
+          valuePtr = changetype<usize>(unchecked(out[index]));
+        }
+        const value = JSON.__deserialize<valueof<T>>(srcStart, valueEnd, valuePtr);
+        if (index < out.length) unchecked((out[index] = value));
+        else out.push(value);
+        srcStart = valueEnd;
+      }
 
       const code = load<u16>(srcStart);
       if (code == COMMA) {
@@ -37,3 +67,8 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
   throw new Error("Failed to parse JSON!");
 }
+
+
+@inline export function deserializeArrayArrayField<T extends unknown[][]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  return deserializeArrayArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+}