json-as 1.2.6 → 1.3.1

package/assembly/deserialize/simple/staticarray.ts

@@ -1,36 +1,72 @@
-import { deserializeStaticArrayInteger } from "./staticarray/integer";
-import { deserializeStaticArrayFloat } from "./staticarray/float";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { JSON } from "../..";
+import { deserializeArbitraryArray } from "./array/arbitrary";
+import { deserializeArrayArray } from "./array/array";
+import { deserializeBooleanArray } from "./array/bool";
+import { deserializeBoxArray } from "./array/box";
+import { deserializeFloatArray } from "./array/float";
+import { deserializeIntegerArray } from "./array/integer";
+import { deserializeMapArray } from "./array/map";
+import { deserializeObjectArray } from "./array/object";
+import { deserializeRawArray } from "./array/raw";
+import { deserializeStructArray } from "./array/struct";
+import { deserializeStringArray } from "./array/string";
 import { deserializeStaticArrayBoolean } from "./staticarray/bool";
+import { deserializeStaticArrayFloat } from "./staticarray/float";
+import { deserializeStaticArrayInteger } from "./staticarray/integer";
 import { deserializeStaticArrayString } from "./staticarray/string";
-import { deserializeStaticArrayArray } from "./staticarray/array";
-import { deserializeStaticArrayStruct } from "./staticarray/struct";
 
-export function deserializeStaticArray<T extends StaticArray<any>>(
-  srcStart: usize,
-  srcEnd: usize,
-  dst: usize,
-): T {
+
+@inline function materializeStaticArray<T extends StaticArray<any>>(src: valueof<T>[], dst: usize): T {
+  const byteLength = <usize>src.length * sizeof<valueof<T>>();
+  let out = dst;
+
+  if (!out) {
+    out = __new(byteLength, idof<T>());
+  } else if (changetype<OBJECT>(out - TOTAL_OVERHEAD).rtSize != byteLength) {
+    out = __renew(out, byteLength);
+  }
+
+  const typed = changetype<T>(out);
+  for (let i = 0; i < src.length; i++) {
+    unchecked((typed[i] = unchecked(src[i])));
+  }
+  return typed;
+}
+
+export function deserializeStaticArray<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
   if (isString<valueof<T>>()) {
-    return <T>deserializeStaticArrayString(srcStart, srcEnd, dst);
+    return changetype<T>(deserializeStaticArrayString(srcStart, srcEnd, dst));
   } else if (isBoolean<valueof<T>>()) {
     return deserializeStaticArrayBoolean<T>(srcStart, srcEnd, dst);
   } else if (isInteger<valueof<T>>()) {
     return deserializeStaticArrayInteger<T>(srcStart, srcEnd, dst);
   } else if (isFloat<valueof<T>>()) {
     return deserializeStaticArrayFloat<T>(srcStart, srcEnd, dst);
-  } else if (isArrayLike<valueof<T>>()) {
-    return deserializeStaticArrayArray<T>(srcStart, srcEnd, dst);
+  } else if (isArray<valueof<T>>()) {
+    return materializeStaticArray<T>(deserializeArrayArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
   } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
     const type = changetype<nonnull<valueof<T>>>(0);
-    if (isDefined(type.__DESERIALIZE)) {
-      return deserializeStaticArrayStruct<T>(srcStart, srcEnd, dst);
+    if (type instanceof StaticArray) {
+      return materializeStaticArray<T>(deserializeArrayArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+    } else if (type instanceof JSON.Value) {
+      return materializeStaticArray<T>(changetype<valueof<T>[]>(deserializeArbitraryArray(srcStart, srcEnd, 0)), dst);
+    } else if (type instanceof JSON.Box) {
+      return materializeStaticArray<T>(changetype<valueof<T>[]>(deserializeBoxArray<valueof<T>[]>(srcStart, srcEnd, 0)), dst);
+    } else if (type instanceof JSON.Obj) {
+      return materializeStaticArray<T>(deserializeObjectArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+    } else if (type instanceof JSON.Raw) {
+      return materializeStaticArray<T>(changetype<valueof<T>[]>(deserializeRawArray(srcStart, srcEnd, 0)), dst);
+    } else if (type instanceof Map) {
+      return materializeStaticArray<T>(deserializeMapArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+      // @ts-ignore: supplied by transform
+    } 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)) {
+      return materializeStaticArray<T>(deserializeStructArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
     }
-    throw new Error(
-      "Could not parse static array of type " + nameof<T>() + "!",
-    );
-  } else {
-    throw new Error(
-      "Could not parse static array of type " + nameof<T>() + "!",
-    );
   }
+
+  throw new Error("Could not parse static array of type " + nameof<T>() + "!");
 }

package/assembly/deserialize/simple/string.ts

@@ -1,19 +1,37 @@
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { bs } from "../../../lib/as-bs";
-import {
-  DESERIALIZE_ESCAPE_TABLE,
-  ESCAPE_HEX_TABLE,
-} from "../../globals/tables";
+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 export function deserializeString(
-  srcStart: usize,
-  srcEnd: usize,
-): string {
+@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 != 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);
+  } 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);
@@ -43,5 +61,67 @@ 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, dstFieldPtr: usize): usize {
+  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;
+    }
+
+    const outStart = bs.offset - bs.buffer;
+    bs.ensureSize(u32(srcEnd - payloadStart));
+    const prefixLen = <u32>(srcStart - payloadStart);
+    if (prefixLen != 0) {
+      memory.copy(bs.offset, payloadStart, prefixLen);
+      bs.offset += prefixLen;
+    }
+
+    while (srcStart < srcEnd) {
+      const block = load<u16>(srcStart);
+      if (block == QUOTE) {
+        bs.toField(outStart, dstFieldPtr);
+        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 + outStart;
+    break;
+  }
+
+  abort("Unterminated string literal");
+  return srcStart;
 }

package/assembly/deserialize/simple/struct.ts

@@ -1,23 +1,7 @@
-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 { 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 {
+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
@@ -32,35 +16,22 @@ export function deserializeStruct<T>(
   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(),
-    );
+  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 && load<u16>(srcStart - 2) !== BACK_SLASH) {
+      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(),
-            );
+          if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
           isKey = false;
         } else {
           // console.log("Got key start");
@@ -73,27 +44,13 @@ export function deserializeStruct<T>(
     } 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;
-        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,
-              changetype<usize>(out),
-            );
-            // while (isSpace(load<u16>(srcStart))) srcStart += 2;
-            srcStart += 4;
-            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
-            keyStart = 0;
-            break;
-          }
-          srcStart += 2;
-        }
+        keyStart = 0;
+        continue;
       } else if (code - 48 <= 9 || code == 45) {
         lastIndex = srcStart;
         srcStart += 2;
@@ -102,13 +59,7 @@ export function deserializeStruct<T>(
           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),
-            );
+            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart, changetype<usize>(out));
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -126,25 +77,13 @@ export function deserializeStruct<T>(
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
           if (code == QUOTE) {
-            srcStart += 2;
-            while (
-              !(
-                load<u16>(srcStart) == QUOTE &&
-                load<u16>(srcStart - 2) != BACK_SLASH
-              )
-            )
-              srcStart += 2;
+            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),
-              );
+              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))) {
@@ -162,25 +101,13 @@ export function deserializeStruct<T>(
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
           if (code == QUOTE) {
-            srcStart += 2;
-            while (
-              !(
-                load<u16>(srcStart) == QUOTE &&
-                load<u16>(srcStart - 2) != BACK_SLASH
-              )
-            )
-              srcStart += 2;
+            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),
-              );
+              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)))) {
@@ -195,13 +122,7 @@ export function deserializeStruct<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),
-          );
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), changetype<usize>(out));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -213,13 +134,7 @@ export function deserializeStruct<T>(
         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),
-          );
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 10), changetype<usize>(out));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -231,13 +146,7 @@ export function deserializeStruct<T>(
         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),
-          );
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), changetype<usize>(out));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */
           // }
@@ -248,12 +157,7 @@ export function deserializeStruct<T>(
       } else if (isSpace(code)) {
         srcStart += 2;
       } else {
-        throw new Error(
-          "Unexpected character in JSON object '" +
-            String.fromCharCode(code) +
-            "' at position " +
-            (srcEnd - srcStart).toString(),
-        );
+        throw new Error("Unexpected character in JSON object '" + String.fromCharCode(code) + "' at position " + (srcEnd - srcStart).toString());
       }
     }
   }

package/assembly/deserialize/simple/typedarray.ts

@@ -0,0 +1,94 @@
+import { COMMA, BRACKET_RIGHT } from "../../custom/chars";
+import { deserializeFloat } from "../index/float";
+import { atoi, isSpace } from "../../util";
+
+
+@inline function countTypedArrayElements(srcStart: usize, srcEnd: usize): i32 {
+  let count = 0;
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code - 48 <= 9 || code == 45) {
+      count++;
+      srcStart += 2;
+
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) break;
+        srcStart += 2;
+      }
+    }
+
+    srcStart += 2;
+  }
+
+  return count;
+}
+
+export function deserializeTypedArray<T extends ArrayLike<number>>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
+  const count = countTypedArrayElements(srcStart, srcEnd);
+  let out = changetype<T>(dst || changetype<usize>(instantiate<T>(count)));
+
+  if (out.length != count) {
+    out = changetype<T>(instantiate<T>(count));
+  }
+
+  let index = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code - 48 <= 9 || code == 45) {
+      const lastIndex = srcStart;
+      srcStart += 2;
+
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
+          if (isFloat<valueof<T>>()) {
+            unchecked((out[index++] = deserializeFloat<valueof<T>>(lastIndex, srcStart)));
+          } else {
+            unchecked((out[index++] = atoi<valueof<T>>(lastIndex, srcStart)));
+          }
+          break;
+        }
+        srcStart += 2;
+      }
+    }
+
+    srcStart += 2;
+  }
+
+  return out;
+}
+
+export function deserializeArrayBuffer(srcStart: usize, srcEnd: usize, dst: usize = 0): ArrayBuffer {
+  const count = countTypedArrayElements(srcStart, srcEnd);
+  let out = dst ? changetype<ArrayBuffer>(dst) : new ArrayBuffer(count);
+
+  if (out.byteLength != count) {
+    out = new ArrayBuffer(count);
+  }
+
+  const outStart = changetype<usize>(out);
+  let index: usize = 0;
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code - 48 <= 9 || code == 45) {
+      const lastIndex = srcStart;
+      srcStart += 2;
+
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
+          store<u8>(outStart + index++, atoi<u8>(lastIndex, srcStart));
+          break;
+        }
+        srcStart += 2;
+      }
+    }
+
+    srcStart += 2;
+  }
+
+  return out;
+}

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

@@ -0,0 +1,8 @@
+import { JSON } from "../../..";
+import { ensureArrayField } from "./shared";
+
+
+@inline export function deserializeArbitraryArrayField(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  ensureArrayField<JSON.Value[]>(fieldPtr);
+  throw new Error("Failed to parse JSON!");
+}

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

@@ -0,0 +1,39 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { deserializeArrayField } from "../array";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+
+
+@inline export function deserializeArrayArrayField<T extends unknown[][]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    while (srcStart < srcEnd) {
+      const slot = ensureArrayElementSlot<T>(out, index);
+      srcStart = deserializeArrayField<valueof<T>>(srcStart, srcEnd, slot);
+      if (!srcStart || srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}

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

@@ -0,0 +1,47 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA, FALSE_WORD_U64, TRUE_WORD_U64 } from "../../../custom/chars";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+
+
+@inline export function deserializeBooleanArrayField<T extends boolean[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    while (srcStart < srcEnd) {
+      const slot = ensureArrayElementSlot<T>(out, index);
+      const block = load<u64>(srcStart);
+      if (block == TRUE_WORD_U64) {
+        store<valueof<T>>(slot, true);
+        srcStart += 8;
+      } else if (block == FALSE_WORD_U64) {
+        store<valueof<T>>(slot, false);
+        srcStart += 10;
+      } else {
+        break;
+      }
+
+      if (srcStart >= srcEnd) break;
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}

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

@@ -0,0 +1,8 @@
+import { JSON } from "../../..";
+import { ensureArrayField } from "./shared";
+
+
+@inline export function deserializeBoxArrayField<T extends JSON.Box<any>[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  ensureArrayField<T>(fieldPtr);
+  throw new Error("Failed to parse JSON!");
+}

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

@@ -0,0 +1,39 @@
+import { deserializeFloatField } from "../../float";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+
+
+@inline export function deserializeFloatArrayField<T extends number[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    while (srcStart < srcEnd) {
+      const slot = ensureArrayElementSlot<T>(out, index);
+      srcStart = deserializeFloatField<valueof<T>>(srcStart, srcEnd, slot);
+      if (!srcStart || srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}