json-as 1.3.0 → 1.3.2

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,20 @@ 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,13 +1,40 @@
+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";
 import { hex4_to_u16_swar } from "../../util/swar";
 
+// @ts-ignore: inline
+@inline function writeStringToField(dstFieldPtr: usize, srcStart: usize, byteLength: u32): void {
+  if (byteLength == 0) {
+    store<usize>(dstFieldPtr, changetype<usize>(""));
+    return;
+  }
+
+  const current = load<usize>(dstFieldPtr);
+  let stringPtr: usize;
+  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);
+  }
+  memory.copy(stringPtr, srcStart, byteLength);
+}
+
 // @ts-ignore: inline
 @inline export function deserializeString(srcStart: usize, srcEnd: usize): string {
   // Strip quotes
   srcStart += 2;
   srcEnd -= 2;
-  bs.proposeSize(u32(srcEnd - srcStart));
+  const outStart = bs.offset - bs.buffer;
+  bs.ensureSize(u32(srcEnd - srcStart));
 
   while (srcStart < srcEnd) {
     const block = load<u16>(srcStart);
@@ -37,5 +64,69 @@ import { hex4_to_u16_swar } from "../../util/swar";
 
     bs.offset += 2;
   }
-  return bs.out<string>();
+  return bs.sliceOut<string>(outStart);
+}
+
+// @ts-ignore: inline
+@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;
+  srcStart = payloadStart;
+
+  while (srcStart < srcEnd) {
+    const char = load<u16>(srcStart);
+    if (char == QUOTE) {
+      writeStringToField(dstFieldPtr, payloadStart, <u32>(srcStart - payloadStart));
+      return srcStart + 2;
+    }
+    if (char != BACK_SLASH) {
+      srcStart += 2;
+      continue;
+    }
+
+    bs.offset = bs.buffer;
+    bs.ensureSize(u32(srcEnd - payloadStart));
+    const prefixLen = <u32>(srcStart - payloadStart);
+    if (prefixLen != 0) {
+      memory.copy(bs.buffer, payloadStart, prefixLen);
+      bs.offset += prefixLen;
+    }
+
+    while (srcStart < srcEnd) {
+      const block = load<u16>(srcStart);
+      if (block == QUOTE) {
+        writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
+        bs.offset = bs.buffer;
+        return srcStart + 2;
+      }
+
+      if (block != BACK_SLASH) {
+        store<u16>(bs.offset, block);
+        srcStart += 2;
+        bs.offset += 2;
+        continue;
+      }
+
+      srcStart += 2;
+      const code = load<u16>(srcStart);
+      if (code !== 0x75) {
+        const escape = load<u16>(DESERIALIZE_ESCAPE_TABLE + code);
+        store<u16>(bs.offset, escape);
+        srcStart += 2;
+      } else {
+        const escaped = hex4_to_u16_swar(load<u64>(srcStart, 2));
+        store<u16>(bs.offset, escaped);
+        srcStart += 10;
+      }
+      bs.offset += 2;
+    }
+
+    bs.offset = bs.buffer;
+    break;
+  }
+
+  abort("Unterminated string literal");
+  return srcStart;
 }

package/assembly/deserialize/simple/struct.ts

@@ -1,165 +1,15 @@
-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 {
+    // @ts-ignore: supplied by transform
+    out.__DESERIALIZE_SLOW(srcStart, srcEnd, out);
   }
   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();