json-as 0.9.28 → 1.0.0-alpha.1

package/assembly/custom/util.ts

@@ -1,135 +1,60 @@
 import { isSpace } from "util/string";
-import { BACK_SLASH, BRACE_LEFT, BRACKET_LEFT, CHAR_F, CHAR_T, QUOTE } from "./chars";
+import { BACK_SLASH, QUOTE } from "./chars";
 import { Sink } from "./sink";
-import { JSON } from "..";
-
-// @ts-ignore: Decorator
-export function isMap<T>(): bool {
-  let type = changetype<T>(0);
-  return type instanceof Map;
-}
-
-// @ts-ignore: Decorator
-@inline export function unsafeCharCodeAt(data: string, pos: i32): i32 {
-  return load<u16>(changetype<usize>(data) + ((<usize>pos) << 1));
-}
-
-// @ts-ignore: Decorator
-@inline export function removeWhitespace(data: string): string {
-  const result = new Sink();
-  let instr = false;
-  for (let i = 0; i < data.length; i++) {
-    const char = unsafeCharCodeAt(data, i);
-    if (instr === false && char === QUOTE) instr = true;
-    else if (
-      instr === true && char === QUOTE
-      && unsafeCharCodeAt(data, i - 1) !== BACK_SLASH
-    ) instr = false;
-
-    if (instr === false) {
-      if (!isSpace(char)) result.write(data.charAt(i));
-    } else {
-      result.write(data.charAt(i));
-    }
-  }
-  return result.toString();
-}
-
-// @ts-ignore: Decorator
-@inline export function escapeChar(char: string): string {
-  switch (unsafeCharCodeAt(char, 0)) {
-    case 0x22:
-      return '\\"';
-    case 0x5c:
-      return "\\\\";
-    case 0x08:
-      return "\\b";
-    case 0x0a:
-      return "\\n";
-    case 0x0d:
-      return "\\r";
-    case 0x09:
-      return "\\t";
-    case 0x0c:
-      return "\\f";
-    case 0x0b:
-      return "\\u000b";
-    default:
-      return char;
-  }
-}
-
-/**
- * A terrible function which finds the depth of a certain array.
- * Suffers no overhead besides function calling and a if/else.
- * @returns depth of array
- */
-
-// @ts-ignore: Decorator
-export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
-  if (!isArray<T>()) {
-    return 0;
-  } else if (isArray<valueof<T>>()) {
-    depth++;
-    return getArrayDepth<valueof<T>>(depth);
-  } else {
-    return depth;
-  }
-}
 
 /** Scientific Notation Integer Parsing - SNIP
  * This is absolutely the fastest algorithm I could think of while adding full support for Scientific Notation
  * Loads 32 bits and retrieves the high/low bits.
  * The reason why we only load 4 bytes at a time is that numbers in the 32-bit range are 7 chars long at most.
  * Using SIMD or 64 bit loads would only work well when parsing large 128+ numbers.
- * 
+ *
  * Here are some benchmarks
- * Parsing: "12345" 
+ * Parsing: "12345"
  * Results are spread over 5000ms
- * 
+ *
  * SNIP: 270M iterations
  * ATOI: 285M iterations
- * ParseInt: 176M iterations 
- * 
+ * ParseInt: 176M iterations
+ *
  * @param str - Any number. Can include scientific notation.
-*/
+ */
 // @ts-ignore: Decorator
 @inline export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u32 = 0): T {
   if (isSigned<T>()) {
     const firstChar: u32 = load<u16>(changetype<usize>(str));
-    if (firstChar === 48) return 0 as T;
-    const isNegative = firstChar === 45; // Check if the number is negative
+    if (firstChar == 48) return 0 as T;
+    const isNegative = firstChar == 45; // Check if the number is negative
     let val: T = 0 as T;
     if (len == 0) len = u32(str.length << 1);
     if (isNegative) {
       offset += 2;
       if (len >= 4) {
         // 32-bit route
-        for (; offset < (len - 3); offset += 4) {
+        for (; offset < len - 3; offset += 4) {
           const ch = load<u32>(changetype<usize>(str) + <usize>offset);
-          const low = ch & 0xFFFF;
+          const low = ch & 0xffff;
           const high = ch >> 16;
           // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
           if (low > 57) {
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+              return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+              return -(val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
             }
           } else if (high > 57) {
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+              return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
+              return -(val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
             }
           } else {
-            val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+            val = (val * 100 + (low - 48) * 10 + (high - 48)) as T;
           }
         }
       }
@@ -141,43 +66,43 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return -(val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+            return -(val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
         } else {
-          val = (val * 10) + (ch - 48) as T;
+          val = (val * 10 + (ch - 48)) as T;
         }
       }
       return -val as T;
     } else {
       if (len >= 4) {
         // Duplet 16 bit lane load
-        for (; offset < (len - 3); offset += 4) {
+        for (; offset < len - 3; offset += 4) {
           const ch = load<u32>(changetype<usize>(str) + <usize>offset);
-          const low = ch & 0xFFFF;
+          const low = ch & 0xffff;
           const high = ch >> 16;
           // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
           if (low > 57) {
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+              return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+              return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
             }
           } else if (high > 57) {
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+              return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
+              return (val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
             }
           } else {
             // Optimized with multiplications and shifts.
-            val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+            val = (val * 100 + (low - 48) * 10 + (high - 48)) as T;
           }
         }
       }
@@ -188,49 +113,49 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
         // e is 101 and E is 69.
         if (ch > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            val = (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            val = (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            val = (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+            val = (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
           return val as T;
         } else {
-          val = (val * 10) + (ch - 48) as T;
+          val = (val * 10 + (ch - 48)) as T;
         }
       }
       return val as T;
     }
   } else {
     const firstChar: u32 = load<u16>(changetype<usize>(str));
-    if (firstChar === 48) return 0 as T;
+    if (firstChar == 48) return 0 as T;
     let val: T = 0 as T;
     if (len == 0) len = u32(str.length << 1);
     if (len >= 4) {
       // Duplet 16 bit lane load
-      for (; offset < (len - 3); offset += 4) {
+      for (; offset < len - 3; offset += 4) {
         const ch = load<u32>(changetype<usize>(str) + <usize>offset);
-        const low = ch & 0xFFFF;
+        const low = ch & 0xffff;
         const high = ch >> 16;
         // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
         if (low > 57) {
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+            return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
         } else if (high > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-            return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
+            return (val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
           }
         } else {
           // Optimized with multiplications and shifts.
-          val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+          val = (val * 100 + (low - 48) * 10 + (high - 48)) as T;
         }
       }
     }
@@ -241,13 +166,13 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
       // e is 101 and E is 69.
       if (ch > 57) {
         if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-          return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+          return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
         } else {
           // Inlined this operation instead of using a loop
-          return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+          return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
         }
       } else {
-        val = (val * 10) + (ch - 48) as T;
+        val = (val * 10 + (ch - 48)) as T;
       }
     }
     return val as T;
@@ -265,21 +190,21 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
   if (!end) end = start + u32(str.length << 1);
   if (isSigned<T>()) {
     // Negative path
-    if (load<u16>(changetype<usize>(str) + <usize>start) === 45) {
+    if (load<u16>(changetype<usize>(str) + <usize>start) == 45) {
       start += 2;
       for (; start < end; start += 2) {
-        val = (val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48) as T;
+        val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
       }
       return -val as T;
     } else {
       for (; start < end; start += 2) {
-        val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+        val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
       }
       return val as T;
     }
   } else {
     for (; start < end; start += 2) {
-      val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+      val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
     }
     return val as T;
   }
@@ -299,14 +224,14 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
   let val: T = 0;
   let offset = 0;
   let firstChar = load<u16>(changetype<usize>(str) + <usize>offset);
-  if (firstChar === 45) {
+  if (firstChar == 45) {
     offset = 2;
   }
   for (; offset < str.length << 1; offset += 2) {
     const char = load<u16>(changetype<usize>(str) + <usize>offset);
-    if (char === 101 || char === 69) {
+    if (char == 101 || char == 69) {
       const char = load<u16>(changetype<usize>(str) + <usize>(offset += 2));
-      if (char === 45) {
+      if (char == 45) {
         // @ts-ignore
         val /= sciNote<T>(__atoi_fast<T>(str, (offset += 2)));
         // @ts-ignore
@@ -322,7 +247,7 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
     val = (val << 1) + (val << 3) + (char - 48);
     // We use load because in this case, there is no need to have bounds-checking
   }
-  if (firstChar === 45) {
+  if (firstChar == 45) {
     val = -val as T;
   }
   return val;
@@ -345,17 +270,6 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
   return res;
 }
 
-// @ts-ignore
-@inline function equalsSlice(p1_data: string, p1_start: i32, p1_end: i32, p2_data: string, p2_start: i32, p2_end: i32): boolean {
-  const p1_len = p1_end - p1_start;
-  const p2_len = p2_end - p2_start;
-  if (p1_len != p2_len) return false;
-  if (p1_len == 2) {
-    return load<u16>(changetype<usize>(p1_data) + p1_start) == load<u16>(changetype<usize>(p2_data) + p2_start)
-  }
-  return memory.compare(changetype<usize>(p1_data) + p1_start, changetype<usize>(p2_data) + p2_start, p1_len) === 0;
-}
-
 // @ts-ignore
 @inline export function containsCodePoint(str: string, code: u32, start: i32, end: i32): bool {
   for (let i = start; i <= end; i++) {
@@ -378,18 +292,23 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
 // @ts-ignore: Decorator
 @inline export function intTo16(int: i32): i32 {
   const high = int >> 4;
-  const low = int & 0x0F;
+  const low = int & 0x0f;
   if (low < 10) {
     if (high < 10) {
-      return ((48 + low) << 16) | 48 + high;
+      return ((48 + low) << 16) | (48 + high);
     } else {
-      return ((48 + low) << 16) | 87 + high;
+      return ((48 + low) << 16) | (87 + high);
     }
   } else {
     if (high < 10) {
-      return ((87 + low) << 16) | 48 + high;
+      return ((87 + low) << 16) | (48 + high);
     } else {
-      return ((87 + low) << 16) | 87 + high;
+      return ((87 + low) << 16) | (87 + high);
     }
   }
-}
+}
+
+// @ts-ignore: Decorator valid here
+@inline export function nextPowerOf2(n: u32): u32 {
+  return 1 << (32 - clz(n - 1));
+}

package/assembly/deserialize/simd/string.ts

@@ -0,0 +1,103 @@
+import { BACK_SLASH } from "../../custom/chars";
+import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
+
+const SPLAT_92 = i16x8.splat(92); /* \ */
+
+/**
+ * Deserializes strings back into into their original form using SIMD operations
+ * @param src string to deserialize
+ * @param dst buffer to write to
+ * @returns number of bytes written
+ */
+// todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
+export function deserializeString_SIMD(src: string, srcStart: usize, srcEnd: usize, dst: usize): usize {
+  let src_ptr = srcStart + 2;
+  let dst_ptr = changetype<usize>(dst);
+
+  const src_end = srcEnd - 2;
+  const src_end_15 = src_end - 15;
+
+  while (src_ptr < src_end_15) {
+    const block = v128.load(src_ptr);
+    v128.store(dst_ptr, block);
+
+    const backslash_indices = i16x8.eq(block, SPLAT_92);
+    let mask = i16x8.bitmask(backslash_indices);
+
+    while (mask != 0) {
+      const lane_index = ctz(mask) << 1;
+      const dst_offset = dst_ptr + lane_index;
+      const src_offset = src_ptr + lane_index;
+      const code = load<u16>(src_offset, 2);
+
+      mask &= mask - 1;
+      if (code == 117 && load<u32>(src_offset, 4) == 3145776) {
+        const block = load<u32>(src_offset, 8);
+        const codeA = block & 0xffff;
+        const codeB = (block >> 16) & 0xffff;
+        const escapedA = load<u8>(ESCAPE_HEX_TABLE + codeA);
+        const escapedB = load<u8>(ESCAPE_HEX_TABLE + codeB);
+        const escaped = (escapedA << 4) + escapedB;
+        // console.log("Escaped:");
+        // console.log("  a: " + escapedA.toString())
+        // console.log("  b: " + escapedB.toString());
+        // console.log("  c: " + escaped.toString());
+        // console.log("  o: " + (dst_ptr - dst).toString());
+        // console.log("  d: " + (dst_offset - dst).toString())
+        // console.log("  l: " + (lane_index).toString())
+        store<u16>(dst_offset, escaped);
+        v128.store(dst_offset, v128.load(src_offset, 4), 2);
+        if (lane_index >= 6) {
+          const bytes_left = lane_index - 4;
+          src_ptr += bytes_left;
+          dst_ptr += bytes_left;
+          // console.log("  e: " + (bytes_left).toString())
+        }
+        dst_ptr -= 10;
+      } else {
+        const escaped = load<u8>(DESERIALIZE_ESCAPE_TABLE + code);
+        store<u16>(dst_offset, escaped);
+        v128.store(dst_offset, v128.load(src_offset, 4), 2);
+        // console.log("Escaped:");
+        if (lane_index == 14) {
+          src_ptr += 2;
+        } else {
+          dst_ptr -= 2;
+        }
+      }
+    }
+
+    src_ptr += 16;
+    dst_ptr += 16;
+
+    // console.log("src: " + (src_ptr - changetype<usize>(src)).toString());
+    // console.log("dst: " + (dst_ptr - dst).toString());
+  }
+  while (src_ptr < src_end) {
+    let code = load<u16>(src_ptr);
+    if (code == BACK_SLASH) {
+      code = load<u16>(DESERIALIZE_ESCAPE_TABLE + load<u8>(src_ptr, 2));
+      if (code == 117 && load<u32>(src_ptr, 4) == 3145776) {
+        const block = load<u32>(src_ptr, 8);
+        const codeA = block & 0xffff;
+        const codeB = (block >> 16) & 0xffff;
+        const escapedA = load<u8>(ESCAPE_HEX_TABLE + codeA);
+        const escapedB = load<u8>(ESCAPE_HEX_TABLE + codeB);
+        const escaped = (escapedA << 4) + escapedB;
+        store<u16>(dst_ptr, escaped);
+        dst_ptr += 2;
+        src_ptr += 12;
+      } else {
+        store<u16>(dst_ptr, code);
+        dst_ptr += 2;
+        src_ptr += 4;
+      }
+    } else {
+      store<u16>(dst_ptr, code);
+      dst_ptr += 2;
+      src_ptr += 2;
+    }
+  }
+
+  return dst_ptr - dst;
+}

package/assembly/deserialize/simple/arbitrary.ts

@@ -0,0 +1,17 @@
+import { JSON } from "../..";
+import { deserializeArray } from "./array";
+import { deserializeBoolean } from "./bool";
+import { deserializeFloat } from "./float";
+import { deserializeObject } from "./object";
+import { deserializeString } from "./string";
+
+export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value {
+  const firstChar = load<u16>(srcStart);
+  if (firstChar == 34) return JSON.Value.from(deserializeString(srcStart, srcEnd, dst));
+  else if (firstChar == 123) return JSON.Value.from(deserializeObject(srcStart, srcEnd, dst));
+  else if (firstChar - 48 <= 9 || firstChar == 45) return JSON.Value.from(deserializeFloat<f64>(srcStart, srcEnd));
+  else if (firstChar == 91) {
+    return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, dst));
+  } else if (firstChar == 116 || firstChar == 102) return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
+  return unreachable();
+}

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

@@ -0,0 +1,113 @@
+import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, CHAR_F, CHAR_N, CHAR_T, COMMA, QUOTE } from "../../../custom/chars";
+import { JSON } from "../../../";
+import { isSpace } from "util/string";
+
+export function deserializeArbitraryArray<T extends JSON.Value>(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value[] {
+  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  let lastIndex: usize = 0;
+  let depth: u32 = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    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));
+          // @ts-ignore: exists
+          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          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)) {
+          // @ts-ignore: type
+          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
+          while (isSpace(load<u16>((srcStart += 2)))) {
+            /* empty */
+          }
+          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) {
+            // @ts-ignore: type
+            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart));
+            while (isSpace(load<u16>((srcStart += 2)))) {
+              /* 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) {
+            // @ts-ignore: type
+            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            // console.log("Value (array): " + ptrToStr(lastIndex, srcStart));
+            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) {
+        // @ts-ignore: type
+        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 8)));
+        // console.log("Value (bool): " + ptrToStr(srcStart - 8, srcStart));
+        while (isSpace(load<u16>((srcStart += 2)))) {
+          /* empty */
+        }
+      }
+    } else if (code == CHAR_F) {
+      if (load<u64>(srcStart, 2) == 28429466576093281) {
+        // @ts-ignore: type
+        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 10)));
+        // console.log("Value (bool): " + ptrToStr(srcStart - 10, srcStart));
+        while (isSpace(load<u16>((srcStart += 2)))) {
+          /* empty */
+        }
+      }
+    } else if (code == CHAR_N) {
+      if (load<u64>(srcStart) == 30399761348886638) {
+        // @ts-ignore: type
+        out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 8)));
+        // console.log("Value (null): " + ptrToStr(srcStart - 8, srcStart));
+        while (isSpace(load<u16>((srcStart += 2)))) {
+          /* empty */
+        }
+      }
+    }
+    srcStart += 2;
+  }
+  // @ts-ignore: type
+  return out;
+}

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

@@ -0,0 +1,18 @@
+import { BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../../";
+
+export function deserializeArrayArray<T extends unknown[][]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  let lastIndex: usize = 0;
+  let depth: u32 = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == BRACKET_LEFT && depth++ == 0) {
+      lastIndex = srcStart;
+    } else if (code == BRACKET_RIGHT && --depth == 0) {
+      out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+    }
+    srcStart += 2;
+  }
+  return out;
+}

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

@@ -0,0 +1,17 @@
+import { CHAR_E, CHAR_F, CHAR_T } from "../../../custom/chars";
+
+export function deserializeBooleanArray<T extends boolean[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == CHAR_T && load<u16>(srcStart, 8) == CHAR_E) {
+      out.push(true);
+      srcStart += 10;
+    } else if (code == CHAR_F && load<u16>(srcStart, 10) == CHAR_E) {
+      out.push(false);
+      srcStart += 12;
+    }
+    srcStart += 2;
+  }
+  return out;
+}