json-as 1.2.6 → 1.3.1

package/assembly/index.ts

@@ -1,46 +1,40 @@
 /// <reference path="./index.d.ts" />
 
 import { bs } from "../lib/as-bs";
-import { serializeArray } from "./serialize/simple/array";
-import { serializeMap } from "./serialize/simple/map";
-import { serializeDate } from "./serialize/simple/date";
-import { deserializeBoolean } from "./deserialize/simple/bool";
-import { deserializeArray } from "./deserialize/simple/array";
-import { deserializeFloat } from "./deserialize/simple/float";
-import { deserializeMap } from "./deserialize/simple/map";
-import { deserializeDate } from "./deserialize/simple/date";
-import { deserializeInteger } from "./deserialize/simple/integer";
-import { serializeArbitrary } from "./serialize/simple/arbitrary";
-import { serializeSet } from "./serialize/simple/set";
-import { deserializeSet } from "./deserialize/simple/set";
-import { serializeStaticArray } from "./serialize/simple/staticarray";
-import { deserializeStaticArray } from "./deserialize/simple/staticarray";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { serializeArray } from "./serialize/index/array";
+import { serializeMap } from "./serialize/index/map";
+import { serializeDate } from "./serialize/index/date";
+import { deserializeBoolean } from "./deserialize/index/bool";
+import { deserializeArray } from "./deserialize/index/array";
+import { deserializeFloat } from "./deserialize/index/float";
+import { deserializeMap } from "./deserialize/index/map";
+import { deserializeDate } from "./deserialize/index/date";
+import { deserializeInteger } from "./deserialize/index/integer";
+import { deserializeUnsigned } from "./deserialize/index/unsigned";
+import { serializeArbitrary } from "./serialize/index/arbitrary";
+import { serializeSet } from "./serialize/index/set";
+import { deserializeSet } from "./deserialize/index/set";
+import { serializeStaticArray } from "./serialize/index/staticarray";
+import { deserializeStaticArray } from "./deserialize/index/staticarray";
 
-import {
-  NULL_WORD,
-  QUOTE,
-  NULL_WORD_U64,
-  TRUE_WORD_U64,
-  FALSE_WORD_U64,
-} from "./custom/chars";
+import { NULL_WORD, QUOTE, NULL_WORD_U64, TRUE_WORD_U64, FALSE_WORD_U64 } from "./custom/chars";
 import { dtoa_buffered, itoa_buffered } from "util/number";
-import { serializeBool } from "./serialize/simple/bool";
-import { serializeInteger } from "./serialize/simple/integer";
-import { serializeFloat } from "./serialize/simple/float";
-import { serializeStruct } from "./serialize/simple/struct";
+import { serializeBool } from "./serialize/index/bool";
+import { serializeInteger } from "./serialize/index/integer";
+import { serializeFloat } from "./serialize/index/float";
+import { serializeStruct } from "./serialize/index/struct";
 import { ptrToStr } from "./util/ptrToStr";
 import { atoi, bytes } from "./util";
-import { deserializeArbitrary } from "./deserialize/simple/arbitrary";
-import { serializeObject } from "./serialize/simple/object";
-import { deserializeObject } from "./deserialize/simple/object";
-import { serializeRaw } from "./serialize/simple/raw";
-import { deserializeRaw } from "./deserialize/simple/raw";
-import { serializeString_SIMD } from "./serialize/simd/string";
-import { serializeString_SWAR } from "./serialize/swar/string";
-import { deserializeString_SWAR } from "./deserialize/swar/string";
-import { deserializeString } from "./deserialize/simple/string";
-import { serializeString } from "./serialize/simple/string";
-import { deserializeString_SIMD } from "./deserialize/simd/string";
+import { deserializeArbitrary } from "./deserialize/index/arbitrary";
+import { serializeObject } from "./serialize/index/object";
+import { deserializeObject } from "./deserialize/index/object";
+import { serializeRaw } from "./serialize/index/raw";
+import { deserializeRaw } from "./deserialize/index/raw";
+import { deserializeString } from "./deserialize/index/string";
+import { serializeString } from "./serialize/index/string";
+import { deserializeArrayBuffer, deserializeTypedArray } from "./deserialize/index/typedarray";
+import { serializeArrayBufferUnsafe, serializeDynamic, serializeTypedArray } from "./serialize/index/typedarray";
 
 /**
  * Offset of the 'storage' property in the JSON.Value class.
@@ -65,7 +59,7 @@ export namespace JSON {
      * ```
      */
     export function shrink(): void {
-      bs.resize(64);
+      bs.shrink();
     }
   }
   /**
@@ -77,10 +71,7 @@ export namespace JSON {
    * @returns string
    */
   // @ts-expect-error: inline
-  @inline export function stringify<T>(
-    data: T,
-    out: string | null = null,
-  ): string {
+  @inline export function stringify<T>(data: T, out: string | null = null): string {
     if (isBoolean<T>()) {
       if (out) {
         if (<bool>data == true) {
@@ -94,12 +85,7 @@ export namespace JSON {
         return out;
       }
       return data ? "true" : "false";
-    } else if (
-      isInteger<T>() &&
-      !isSigned<T>() &&
-      nameof<T>() == "usize" &&
-      data == 0
-    ) {
+    } else if (isInteger<T>() && !isSigned<T>() && nameof<T>() == "usize" && data == 0) {
       if (out) {
         out = changetype<string>(__renew(changetype<usize>(out), 8));
         store<u64>(changetype<usize>(out), NULL_WORD_U64);
@@ -108,14 +94,10 @@ export namespace JSON {
       return NULL_WORD;
     } else if (isInteger<T>(data)) {
       if (out) {
-        out = changetype<string>(
-          __renew(changetype<usize>(out), sizeof<T>() << 3),
-        );
+        out = changetype<string>(__renew(changetype<usize>(out), sizeof<T>() << 3));
 
         const bytes = itoa_buffered(changetype<usize>(out), data) << 1;
-        return (out = changetype<string>(
-          __renew(changetype<usize>(out), bytes),
-        ));
+        return (out = changetype<string>(__renew(changetype<usize>(out), bytes)));
       }
       return data.toString();
     } else if (isFloat<T>(data)) {
@@ -123,9 +105,7 @@ export namespace JSON {
         out = changetype<string>(__renew(changetype<usize>(out), 64));
 
         const bytes = dtoa_buffered(changetype<usize>(out), data) << 1;
-        return (out = changetype<string>(
-          __renew(changetype<usize>(out), bytes),
-        ));
+        return (out = changetype<string>(__renew(changetype<usize>(out), bytes)));
       }
       return data.toString();
     } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
@@ -136,30 +116,23 @@ export namespace JSON {
       }
       return NULL_WORD;
     } else if (isString<nonnull<T>>()) {
-      if (JSON_MODE === JSONMode.SIMD) {
-        serializeString_SIMD(data as string);
-      } else if (JSON_MODE === JSONMode.SWAR) {
-        serializeString_SWAR(data as string);
-      } else {
-        serializeString(data as string);
-      }
+      serializeString(data as string);
+      return bs.out<string>();
+      // @ts-expect-error: Defined by transform
+    } else if (isDefined(data.__SERIALIZE_CUSTOM)) {
+      // @ts-expect-error: Defined by transform
+      data.__SERIALIZE_CUSTOM();
       return bs.out<string>();
-      // @ts-expect-error: Supplied by transform
+      // @ts-expect-error: Defined by transform
     } else if (isDefined(data.__SERIALIZE)) {
-      // @ts-expect-error
+      // @ts-expect-error: Defined by transform
       inline.always(data.__SERIALIZE(changetype<usize>(data)));
       return bs.out<string>();
     } else if (data instanceof Date) {
-      out = out
-        ? changetype<string>(__renew(changetype<usize>(out), 52))
-        : changetype<string>(__new(52, idof<string>()));
+      out = out ? changetype<string>(__renew(changetype<usize>(out), 52)) : changetype<string>(__new(52, idof<string>()));
 
       store<u16>(changetype<usize>(out), QUOTE);
-      memory.copy(
-        changetype<usize>(out) + 2,
-        changetype<usize>(data.toISOString()),
-        48,
-      );
+      memory.copy(changetype<usize>(out) + 2, changetype<usize>(data.toISOString()), 48);
       store<u16>(changetype<usize>(out), QUOTE, 50);
       return changetype<string>(out);
     } else if (data instanceof Array) {
@@ -170,6 +143,43 @@ export namespace JSON {
       // @ts-expect-error
       inline.always(serializeStaticArray(changetype<nonnull<T>>(data)));
       return bs.out<string>();
+    } else if (data instanceof Int8Array) {
+      inline.always(serializeTypedArray<Int8Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof Uint8Array) {
+      inline.always(serializeTypedArray<Uint8Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof Uint8ClampedArray) {
+      inline.always(serializeTypedArray<Uint8ClampedArray>(data));
+      return bs.out<string>();
+    } else if (data instanceof Int16Array) {
+      inline.always(serializeTypedArray<Int16Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof Uint16Array) {
+      inline.always(serializeTypedArray<Uint16Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof Int32Array) {
+      inline.always(serializeTypedArray<Int32Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof Uint32Array) {
+      inline.always(serializeTypedArray<Uint32Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof Int64Array) {
+      inline.always(serializeTypedArray<Int64Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof Uint64Array) {
+      inline.always(serializeTypedArray<Uint64Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof Float32Array) {
+      inline.always(serializeTypedArray<Float32Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof Float64Array) {
+      inline.always(serializeTypedArray<Float64Array>(data));
+      return bs.out<string>();
+    } else if (data instanceof ArrayBuffer) {
+      const dataStart = changetype<usize>(data);
+      serializeArrayBufferUnsafe(dataStart, changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize);
+      return bs.out<string>();
     } else if (data instanceof Set) {
       // @ts-expect-error
       inline.always(serializeSet(changetype<nonnull<T>>(data)));
@@ -190,11 +200,7 @@ export namespace JSON {
     } else if (data instanceof JSON.Box) {
       return JSON.stringify(data.value);
     } else {
-      throw new Error(
-        `Could not serialize data of type '${nameof<T>()}'. ` +
-          `If this is a custom class, add the @json decorator: @json class ${nameof<T>()} { ... }. ` +
-          `Supported types: primitives, string, Array, Map, Date, and @json decorated classes.`,
-      );
+      throw new Error(`Could not serialize data of type '${nameof<T>()}'. ` + `If this is a custom class, add the @json decorator: @json class ${nameof<T>()} { ... }. ` + `Supported types: primitives, string, Array, StaticArray, TypedArray, ArrayBuffer, Map, Date, and @json decorated classes.`);
     }
   }
 
@@ -213,61 +219,65 @@ export namespace JSON {
     if (isBoolean<T>()) {
       return deserializeBoolean(dataPtr, dataPtr + dataSize) as T;
     } else if (isInteger<T>()) {
-      return deserializeInteger<T>(dataPtr, dataPtr + dataSize);
+      return isSigned<T>() ? deserializeInteger<T>(dataPtr, dataPtr + dataSize) : deserializeUnsigned<T>(dataPtr, dataPtr + dataSize);
     } else if (isFloat<T>()) {
       return deserializeFloat<T>(dataPtr, dataPtr + dataSize);
-    } else if (
-      isNullable<T>() &&
-      dataSize == 8 &&
-      load<u64>(dataPtr) == NULL_WORD_U64
-    ) {
+    } else if (isNullable<T>() && dataSize == 8 && load<u64>(dataPtr) == NULL_WORD_U64) {
       return null;
     } else if (isString<T>()) {
-      if (JSON_MODE === JSONMode.NAIVE) {
-        // @ts-expect-error: type
-        return deserializeString(dataPtr, dataPtr + dataSize);
-      } else if (JSON_MODE === JSONMode.SWAR) {
-        // @ts-expect-error: type
-        return deserializeString_SWAR(dataPtr, dataPtr + dataSize);
-      } else if (JSON_MODE === JSONMode.SIMD) {
-        // @ts-expect-error: type
-        return deserializeString_SIMD(dataPtr, dataPtr + dataSize);
-      }
+      return deserializeString(dataPtr, dataPtr + dataSize) as T;
     } else {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
-      if (type instanceof StaticArray) {
-        // @ts-expect-error
-        return inline.always(
-          deserializeStaticArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0),
-        );
-      } else if (type instanceof Array) {
-        // @ts-expect-error
-        return inline.always(
-          deserializeArray<nonnull<T>>(
-            dataPtr,
-            dataPtr + dataSize,
-            changetype<usize>(instantiate<T>()),
-          ),
-        );
-      } else if (type instanceof Set) {
+      // @ts-expect-error: Defined by transform
+      if (isDefined(type.__DESERIALIZE_CUSTOM)) {
+        const out = changetype<nonnull<T>>(0);
         // @ts-expect-error
-        return inline.always(
-          deserializeSet<nonnull<T>>(dataPtr, dataPtr + dataSize, 0),
-        );
+        return out.__DESERIALIZE_CUSTOM(data);
         // @ts-expect-error: Defined by transform
       } else if (isDefined(type.__DESERIALIZE)) {
-        const out = changetype<nonnull<T>>(
-          __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()),
-        );
+        const out = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
         // @ts-expect-error: Defined by transform
         if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
+        // @ts-expect-error: Defined by transform
+        out.__DESERIALIZE(dataPtr, dataPtr + dataSize, out);
+        return out;
+      }
+      if (type instanceof StaticArray) {
+        // @ts-expect-error
+        return inline.always(deserializeStaticArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0));
+      } else if (type instanceof Array) {
         // @ts-expect-error
-        return out.__DESERIALIZE(dataPtr, dataPtr + dataSize, out);
+        return inline.always(deserializeArray<nonnull<T>>(dataPtr, dataPtr + dataSize, changetype<usize>(instantiate<T>())));
+      } else if (type instanceof Int8Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Uint8Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Uint8ClampedArray) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Int16Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Uint16Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Int32Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Uint32Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Int64Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Uint64Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Float32Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Float64Array) {
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof ArrayBuffer) {
+        return deserializeArrayBuffer(dataPtr, dataPtr + dataSize, 0) as T;
+      } else if (type instanceof Set) {
+        // @ts-expect-error
+        return inline.always(deserializeSet<nonnull<T>>(dataPtr, dataPtr + dataSize, 0));
       } else if (type instanceof Map) {
         // @ts-expect-error
-        return inline.always(
-          deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize, 0),
-        );
+        return inline.always(deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize, 0));
       } else if (type instanceof Date) {
         // @ts-expect-error
         return deserializeDate(dataPtr, dataPtr + dataSize);
@@ -276,9 +286,7 @@ export namespace JSON {
         return deserializeRaw(dataPtr, dataPtr + dataSize);
       } else if (type instanceof JSON.Value) {
         // @ts-expect-error
-        return inline.always(
-          deserializeArbitrary(dataPtr, dataPtr + dataSize, 0),
-        );
+        return inline.always(deserializeArbitrary(dataPtr, dataPtr + dataSize, 0));
       } else if (type instanceof JSON.Obj) {
         // @ts-expect-error
         return inline.always(deserializeObject(dataPtr, dataPtr + dataSize, 0));
@@ -286,11 +294,7 @@ export namespace JSON {
         // @ts-expect-error
         return new JSON.Box(parseBox(data, changetype<nonnull<T>>(0).value));
       } else {
-        throw new Error(
-          `Could not deserialize JSON to type '${nameof<T>()}'. ` +
-            `If this is a custom class, ensure it has the @json decorator: @json class ${nameof<T>()} { ... }. ` +
-            `Input: "${data.length > 50 ? data.slice(0, 50) + "..." : data}"`,
-        );
+        throw new Error(`Could not deserialize JSON to type '${nameof<T>()}'. ` + `If this is a custom class, ensure it has the @json decorator: @json class ${nameof<T>()} { ... }. ` + `Input: "${data.length > 50 ? data.slice(0, 50) + "..." : data}"`);
       }
     }
   }
@@ -304,7 +308,7 @@ export namespace JSON {
    * Enum-like namespace representing the different types supported by JSON.Value.
    *
    * Used internally to track the runtime type of values stored in JSON.Value instances.
-   * Types 0-17 are reserved for built-in types; custom @json classes use idof<T>() + Struct.
+   * Types 0-19 are reserved for built-in types; custom @json classes use idof<T>() + Struct.
    */
   export namespace Types {
     /** Represents a null value */
@@ -345,6 +349,10 @@ export namespace JSON {
     @inline export const Map: u16 = 16;
     // @ts-expect-error
     @inline export const Struct: u16 = 17;
+    // @ts-expect-error
+    @inline export const TypedArray: u16 = 18;
+    // @ts-expect-error
+    @inline export const ArrayBuffer: u16 = 19;
   }
 
   /**
@@ -437,9 +445,7 @@ export namespace JSON {
      * @returns An instance of JSON.Value.
      */
     @inline static empty(): JSON.Value {
-      return changetype<JSON.Value>(
-        __new(offsetof<JSON.Value>(), idof<JSON.Value>()),
-      );
+      return changetype<JSON.Value>(__new(offsetof<JSON.Value>(), idof<JSON.Value>()));
     }
 
     /**
@@ -449,9 +455,7 @@ export namespace JSON {
      */
     @inline static from<T>(value: T): JSON.Value {
       if (value instanceof JSON.Value) return value;
-      const out = changetype<JSON.Value>(
-        __new(offsetof<JSON.Value>(), idof<JSON.Value>()),
-      );
+      const out = changetype<JSON.Value>(__new(offsetof<JSON.Value>(), idof<JSON.Value>()));
       out.set<T>(value);
       return out;
     }
@@ -462,38 +466,40 @@ export namespace JSON {
      * @returns JSON.Types
      */
     @inline getType<T>(value: T): JSON.Types {
-      if (isNullable<T>() && changetype<usize>(value) === 0)
-        return JSON.Types.Null;
+      if (isNullable<T>() && changetype<usize>(value) === 0) return JSON.Types.Null;
       if (isBoolean<T>()) return JSON.Types.Bool;
-      if (
-        isInteger<T>() &&
-        !isSigned<T>() &&
-        changetype<usize>(value) == 0 &&
-        nameof<T>() == "usize"
-      )
-        return JSON.Types.Null;
+      if (isInteger<T>() && !isSigned<T>() && changetype<usize>(value) == 0 && nameof<T>() == "usize") return JSON.Types.Null;
       if (isString<T>()) return JSON.Types.String;
       // @ts-expect-error: can assume that T is ArrayLike based on previous condition
-      if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>())
-        return JSON.Types.Array;
+      if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>()) return JSON.Types.Array;
       if (value instanceof JSON.Box) return this.getType(value.value);
-      if (value instanceof u8 || value instanceof i8) return JSON.Types.U8;
-      if (value instanceof u16 || value instanceof i16) return JSON.Types.U16;
-      if (value instanceof u32 || value instanceof i32) return JSON.Types.U32;
-      if (value instanceof u64 || value instanceof i64) return JSON.Types.U64;
       if (value instanceof i8) return JSON.Types.I8;
       if (value instanceof i16) return JSON.Types.I16;
       if (value instanceof i32) return JSON.Types.I32;
       if (value instanceof i64) return JSON.Types.I64;
+      if (value instanceof u8) return JSON.Types.U8;
+      if (value instanceof u16) return JSON.Types.U16;
+      if (value instanceof u32) return JSON.Types.U32;
+      if (value instanceof u64) return JSON.Types.U64;
       if (value instanceof f32) return JSON.Types.F32;
       if (value instanceof f64) return JSON.Types.F64;
+      // @ts-expect-error: supplied by transform
+      if (isDefined(value.__SERIALIZE) && isManaged<T>(value)) return u16(idof<T>()) + JSON.Types.Struct;
+      if (value instanceof Int8Array) return JSON.Types.TypedArray;
+      if (value instanceof Uint8Array) return JSON.Types.TypedArray;
+      if (value instanceof Uint8ClampedArray) return JSON.Types.TypedArray;
+      if (value instanceof Int16Array) return JSON.Types.TypedArray;
+      if (value instanceof Uint16Array) return JSON.Types.TypedArray;
+      if (value instanceof Int32Array) return JSON.Types.TypedArray;
+      if (value instanceof Uint32Array) return JSON.Types.TypedArray;
+      if (value instanceof Int64Array) return JSON.Types.TypedArray;
+      if (value instanceof Uint64Array) return JSON.Types.TypedArray;
+      if (value instanceof Float32Array) return JSON.Types.TypedArray;
+      if (value instanceof Float64Array) return JSON.Types.TypedArray;
+      if (value instanceof ArrayBuffer) return JSON.Types.ArrayBuffer;
       if (value instanceof Map) return JSON.Types.Map;
       if (value instanceof JSON.Raw) return JSON.Types.Raw;
       if (value instanceof JSON.Obj) return JSON.Types.Object;
-
-      // @ts-expect-error: supplied by transform
-      if (isDefined(value.__SERIALIZE) && isManaged<T>(value))
-        return u16(idof<T>()) + JSON.Types.Struct;
       return JSON.Types.Null;
     }
     /**
@@ -504,37 +510,34 @@ export namespace JSON {
       this.type = this.getType<T>(value);
 
       if (value instanceof JSON.Box) this.set(value.value);
-      else if (isBoolean<T>())
-        store<T>(changetype<usize>(this), value, STORAGE);
-      else if (
-        isInteger<T>() &&
-        !isSigned<T>() &&
-        changetype<usize>(value) == 0 &&
-        nameof<T>() == "usize"
-      )
-        store<usize>(changetype<usize>(this), 0, STORAGE);
-      else if (isInteger<T>() || isFloat<T>())
-        store<T>(changetype<usize>(this), value, STORAGE);
-      else if (isNullable<T>() && changetype<usize>(value) === 0)
-        store<usize>(changetype<usize>(this), 0, STORAGE);
+      else if (isBoolean<T>()) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (isInteger<T>() && !isSigned<T>() && changetype<usize>(value) == 0 && nameof<T>() == "usize") store<usize>(changetype<usize>(this), 0, STORAGE);
+      else if (isInteger<T>() || isFloat<T>()) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (isNullable<T>() && changetype<usize>(value) === 0) store<usize>(changetype<usize>(this), 0, STORAGE);
       else if (isString<T>()) store<T>(changetype<usize>(this), value, STORAGE);
-      else if (value instanceof JSON.Raw)
-        store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof JSON.Raw) store<T>(changetype<usize>(this), value, STORAGE);
+      // @ts-expect-error: supplied by transform
+      else if (isDefined(value.__SERIALIZE) && isManaged<T>(value)) {
+        // @ts-expect-error
+        if (!JSON.Value.METHODS.has(idof<T>())) JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE.index);
+        store<usize>(changetype<usize>(this), changetype<usize>(value), STORAGE);
+      } else if (value instanceof Int8Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Uint8Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Uint8ClampedArray) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Int16Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Uint16Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Int32Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Uint32Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Int64Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Uint64Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Float32Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof Float64Array) store<T>(changetype<usize>(this), value, STORAGE);
+      else if (value instanceof ArrayBuffer) store<T>(changetype<usize>(this), value, STORAGE);
       else if (value instanceof Map) {
         if (idof<T>() !== idof<Map<string, JSON.Value>>()) {
           abort("Maps must be of type Map<string, JSON.Value>!");
         }
         store<T>(changetype<usize>(this), value, STORAGE);
-        // @ts-expect-error: supplied by transform
-      } else if (isDefined(value.__SERIALIZE) && isManaged<T>(value)) {
-        // @ts-expect-error
-        if (!JSON.Value.METHODS.has(idof<T>()))
-          JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE.index);
-        store<usize>(
-          changetype<usize>(this),
-          changetype<usize>(value),
-          STORAGE,
-        );
       } else if (value instanceof JSON.Obj) {
         store<T>(changetype<usize>(this), value, STORAGE);
         // @ts-expect-error
@@ -586,6 +589,14 @@ export namespace JSON {
           return this.get<u32>().toString();
         case JSON.Types.U64:
           return this.get<u64>().toString();
+        case JSON.Types.I8:
+          return this.get<i8>().toString();
+        case JSON.Types.I16:
+          return this.get<i16>().toString();
+        case JSON.Types.I32:
+          return this.get<i32>().toString();
+        case JSON.Types.I64:
+          return this.get<i64>().toString();
         case JSON.Types.F32:
           return this.get<f32>().toString();
         case JSON.Types.F64:
@@ -612,6 +623,11 @@ export namespace JSON {
 
           return out.toString();
         }
+        case JSON.Types.TypedArray:
+        case JSON.Types.ArrayBuffer: {
+          serializeDynamic(this.type, this.get<usize>());
+          return bs.out<string>();
+        }
         case JSON.Types.Object: {
           return JSON.stringify(this.get<JSON.Obj>());
         }
@@ -732,11 +748,25 @@ export namespace JSON {
      */
     @inline static from<T>(value: T): JSON.Obj {
       if (value instanceof JSON.Obj) return value;
-      const out = new JSON.Obj();
-
       if (value instanceof Map) {
+        const out = new JSON.Obj();
+        if (!isString<indexof<T>>()) {
+          throw new Error("JSON.Obj.from only supports maps with string keys");
+        }
+
+        const keys = value.keys();
+        const values = value.values();
+        for (let i = 0; i < keys.length; i++) {
+          out.set(unchecked(keys[i]), unchecked(values[i]));
+        }
+        return out;
       }
-      return out;
+
+      const parsed = JSON.parse<JSON.Value>(JSON.stringify(value));
+      if (parsed.type != JSON.Types.Object) {
+        throw new Error("JSON.Obj.from expects a value that serializes to a JSON object");
+      }
+      return parsed.get<JSON.Obj>();
     }
   }
   /**
@@ -744,8 +774,7 @@ export namespace JSON {
    */
   export class Box<T> {
     constructor(public value: T) {
-      if (!isInteger<T>() && !isFloat<T>())
-        ERROR("JSON.Box should only hold primitive types!");
+      if (!isInteger<T>() && !isFloat<T>() && !isBoolean<T>()) ERROR("JSON.Box should only hold primitive types!");
     }
     /**
      * Set the internal value of Box to new value
@@ -768,11 +797,9 @@ export namespace JSON {
      * @returns Box<T> | null
      */
     @inline static fromValue<T>(value: JSON.Value): Box<T> | null {
-      if (!(value instanceof JSON.Value))
-        throw new Error("value must be of type JSON.Value");
+      if (!(value instanceof JSON.Value)) throw new Error("value must be of type JSON.Value");
       if (value.type === JSON.Types.Null) return null;
-      const v =
-        value.type === JSON.Types.F64 ? value.get<f64>() : value.get<T>();
+      const v = value.type === JSON.Types.F64 ? value.get<f64>() : value.get<T>();
       // @ts-expect-error
       return new Box(isInteger<T>() || isFloat<T>() ? <T>v : v);
     }
@@ -821,20 +848,14 @@ export namespace JSON {
       store<u64>(bs.offset, NULL_WORD_U64);
       bs.offset += 8;
     } else if (isString<nonnull<T>>()) {
-      if (JSON_MODE === JSONMode.SIMD) {
-        serializeString_SIMD(data as string);
-      } else if (JSON_MODE === JSONMode.SWAR) {
-        serializeString_SWAR(data as string);
-      } else {
-        serializeString(data as string);
-      }
-      // @ts-expect-error: Supplied by transform
+      serializeString(data as string);
+      // @ts-expect-error: Defined by transform
     } else if (isDefined(data.__SERIALIZE_CUSTOM)) {
       // @ts-expect-error
       return data.__SERIALIZE_CUSTOM();
-      // @ts-expect-error: Supplied by transform
+      // @ts-expect-error: Defined by transform
     } else if (isDefined(data.__SERIALIZE)) {
-      // @ts-expect-error
+      // @ts-expect-error: type
       serializeStruct(changetype<nonnull<T>>(data));
     } else if (data instanceof Date) {
       // @ts-expect-error
@@ -845,6 +866,31 @@ export namespace JSON {
     } else if (data instanceof StaticArray) {
       // @ts-expect-error
       serializeStaticArray(changetype<nonnull<T>>(data));
+    } else if (data instanceof Int8Array) {
+      serializeTypedArray<Int8Array>(data);
+    } else if (data instanceof Uint8Array) {
+      serializeTypedArray<Uint8Array>(data);
+    } else if (data instanceof Uint8ClampedArray) {
+      serializeTypedArray<Uint8ClampedArray>(data);
+    } else if (data instanceof Int16Array) {
+      serializeTypedArray<Int16Array>(data);
+    } else if (data instanceof Uint16Array) {
+      serializeTypedArray<Uint16Array>(data);
+    } else if (data instanceof Int32Array) {
+      serializeTypedArray<Int32Array>(data);
+    } else if (data instanceof Uint32Array) {
+      serializeTypedArray<Uint32Array>(data);
+    } else if (data instanceof Int64Array) {
+      serializeTypedArray<Int64Array>(data);
+    } else if (data instanceof Uint64Array) {
+      serializeTypedArray<Uint64Array>(data);
+    } else if (data instanceof Float32Array) {
+      serializeTypedArray<Float32Array>(data);
+    } else if (data instanceof Float64Array) {
+      serializeTypedArray<Float64Array>(data);
+    } else if (data instanceof ArrayBuffer) {
+      const dataStart = changetype<usize>(data);
+      serializeArrayBufferUnsafe(dataStart, changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize);
     } else if (data instanceof Set) {
       // @ts-expect-error
       serializeSet(changetype<nonnull<T>>(data));
@@ -860,11 +906,7 @@ export namespace JSON {
     } else if (data instanceof JSON.Box) {
       __serialize(data.value);
     } else {
-      throw new Error(
-        `Could not serialize data of type '${nameof<T>()}'. ` +
-          `If this is a custom class, add the @json decorator: @json class ${nameof<T>()} { ... }. ` +
-          `Supported types: primitives, string, Array, Map, Date, and @json decorated classes.`,
-      );
+      throw new Error(`Could not serialize data of type '${nameof<T>()}'. ` + `If this is a custom class, add the @json decorator: @json class ${nameof<T>()} { ... }. ` + `Supported types: primitives, string, Array, StaticArray, TypedArray, ArrayBuffer, Map, Date, and @json decorated classes.`);
     }
   }
 
@@ -876,52 +918,69 @@ export namespace JSON {
    * @param dst - usize
    * @returns void
    */
-  export function __deserialize<T>(
-    srcStart: usize,
-    srcEnd: usize,
-    dst: usize = 0,
-  ): T {
+  export function __deserialize<T>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
     if (isBoolean<T>()) {
       // @ts-expect-error: type
       return deserializeBoolean(srcStart, srcEnd);
     } else if (isInteger<T>()) {
-      return atoi<T>(srcStart, srcEnd);
+      return isSigned<T>() ? deserializeInteger<T>(srcStart, srcEnd) : deserializeUnsigned<T>(srcStart, srcEnd);
     } else if (isFloat<T>()) {
       return deserializeFloat<T>(srcStart, srcEnd);
     } else if (isString<T>()) {
-      if (srcEnd - srcStart < 4)
-        throw new Error(
-          "Cannot parse data as string because it was formatted incorrectly!",
-        );
+      if (srcEnd - srcStart < 4) throw new Error("Cannot parse data as string because it was formatted incorrectly!");
 
-      // @ts-expect-error: type
-      return deserializeString(srcStart, srcEnd);
-    } else if (
-      isNullable<T>() &&
-      srcEnd - srcStart == 8 &&
-      load<u64>(srcStart) == NULL_WORD_U64
-    ) {
+      return deserializeString(srcStart, srcEnd) as T;
+    } else if (isNullable<T>() && srcEnd - srcStart == 8 && load<u64>(srcStart) == NULL_WORD_U64) {
       return null;
     } else {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
+      // @ts-expect-error: Defined by transform
+      if (isDefined(type.__DESERIALIZE_CUSTOM)) {
+        const out = changetype<nonnull<T>>(0);
+        // @ts-expect-error: Defined by transform
+        return out.__DESERIALIZE_CUSTOM(ptrToStr(srcStart, srcEnd));
+        // @ts-expect-error: Defined by transform
+      } else if (isDefined(type.__DESERIALIZE)) {
+        const out = changetype<nonnull<T>>(dst || __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
+        // @ts-expect-error: Defined by transform
+        if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
+        // @ts-expect-error: Defined by transform
+        out.__DESERIALIZE(srcStart, srcEnd, out);
+        return out;
+      }
       if (type instanceof StaticArray) {
         // @ts-expect-error: type
         return deserializeStaticArray<T>(srcStart, srcEnd, dst);
       } else if (type instanceof Array) {
         // @ts-expect-error: type
         return deserializeArray<T>(srcStart, srcEnd, dst);
+      } else if (type instanceof Int8Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Uint8Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Uint8ClampedArray) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Int16Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Uint16Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Int32Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Uint32Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Int64Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Uint64Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Float32Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof Float64Array) {
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
+      } else if (type instanceof ArrayBuffer) {
+        return deserializeArrayBuffer(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Set) {
         // @ts-expect-error: type
         return deserializeSet<T>(srcStart, srcEnd, dst);
-        // @ts-expect-error: Defined by transform
-      } else if (isDefined(type.__DESERIALIZE)) {
-        const out = changetype<nonnull<T>>(
-          dst || __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()),
-        );
-        // @ts-expect-error: Defined by transform
-        if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
-        // @ts-expect-error: Defined by transform
-        return out.__DESERIALIZE(srcStart, srcEnd, out);
       } else if (type instanceof Map) {
         // @ts-expect-error: type
         return deserializeMap<T>(srcStart, srcEnd, dst);
@@ -939,22 +998,11 @@ export namespace JSON {
         return deserializeObject(srcStart, srcEnd, 0);
       } else if (type instanceof JSON.Box) {
         // @ts-expect-error: type
-        return new JSON.Box(
-          deserializeBox(
-            srcStart,
-            srcEnd,
-            dst,
-            changetype<nonnull<T>>(0).value,
-          ),
-        );
+        return new JSON.Box(deserializeBox(srcStart, srcEnd, dst, changetype<nonnull<T>>(0).value));
       }
     }
     const snippet = ptrToStr(srcStart, srcEnd);
-    throw new Error(
-      `Could not deserialize JSON to type '${nameof<T>()}'. ` +
-        `If this is a custom class, ensure it has the @json decorator: @json class ${nameof<T>()} { ... }. ` +
-        `Input: "${snippet.length > 50 ? snippet.slice(0, 50) + "..." : snippet}"`,
-    );
+    throw new Error(`Could not deserialize JSON to type '${nameof<T>()}'. ` + `If this is a custom class, ensure it has the @json decorator: @json class ${nameof<T>()} { ... }. ` + `Input: "${snippet.length > 50 ? snippet.slice(0, 50) + "..." : snippet}"`);
   }
   export namespace Util {
     // @ts-expect-error: decorator
@@ -970,7 +1018,8 @@ export namespace JSON {
     }
   }
   /**
-   * Methods for use when using JSON methods inside another JSON method or custom serializer/deserializer.
+   * Methods for use when using JSON methods inside another JSON method or custom serializer/deserializer
+   * Transform will automatically convert JSON.x calls to JSON.internal.x when in a custom (de)serializer
    */
   export namespace internal {
     /**
@@ -980,133 +1029,31 @@ export namespace JSON {
      * @returns - string
      */
     // @ts-expect-error: inline
-    @inline export function stringify<T>(
-      data: T,
-      out: string | null = null,
-    ): string {
-      if (isBoolean<T>()) {
-        if (out) {
-          if (<bool>data == true) {
-            out = changetype<string>(__renew(changetype<usize>(out), 8));
-            store<u64>(changetype<usize>(out), TRUE_WORD_U64);
-          } else {
-            out = changetype<string>(__renew(changetype<usize>(out), 10));
-            store<u64>(changetype<usize>(out), FALSE_WORD_U64);
-            store<u16>(changetype<usize>(out), 101, 8);
-          }
-          return out;
-        }
-        return data ? "true" : "false";
-      } else if (
-        isInteger<T>() &&
-        !isSigned<T>() &&
-        nameof<T>() == "usize" &&
-        data == 0
-      ) {
-        if (out) {
-          out = changetype<string>(__renew(changetype<usize>(out), 8));
-          store<u64>(changetype<usize>(out), NULL_WORD_U64);
-          return out;
-        }
-        return NULL_WORD;
-      } else if (isInteger<T>(data)) {
-        if (out) {
-          out = changetype<string>(
-            __renew(changetype<usize>(out), sizeof<T>() << 3),
-          );
-
-          const bytes = itoa_buffered(changetype<usize>(out), data) << 1;
-          return (out = changetype<string>(
-            __renew(changetype<usize>(out), bytes),
-          ));
-        }
-        return data.toString();
-      } else if (isFloat<T>(data)) {
-        if (out) {
-          out = changetype<string>(__renew(changetype<usize>(out), 64));
-
-          const bytes = dtoa_buffered(changetype<usize>(out), data) << 1;
-          return (out = changetype<string>(
-            __renew(changetype<usize>(out), bytes),
-          ));
-        }
-        return data.toString();
-      } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
-        if (out) {
-          out = changetype<string>(__renew(changetype<usize>(out), 8));
-          store<u64>(changetype<usize>(out), NULL_WORD_U64);
-          return out;
-        }
-        return NULL_WORD;
-      } else if (isString<nonnull<T>>()) {
-        if (JSON_MODE === JSONMode.SIMD) {
-          serializeString_SIMD(data as string);
-        } else if (JSON_MODE === JSONMode.SWAR) {
-          serializeString_SWAR(data as string);
-        } else {
-          serializeString(data as string);
-        }
-        return bs.cpyOut<string>();
-        // @ts-expect-error: Supplied by transform
-      } else if (isDefined(data.__SERIALIZE)) {
-        bs.saveState();
-        // @ts-expect-error
-        inline.always(data.__SERIALIZE(changetype<usize>(data)));
-        return bs.cpyOut<string>();
-      } else if (data instanceof Date) {
-        out = out
-          ? changetype<string>(__renew(changetype<usize>(out), 52))
-          : changetype<string>(__new(52, idof<string>()));
-
-        store<u16>(changetype<usize>(out), QUOTE);
-        memory.copy(
-          changetype<usize>(out) + 2,
-          changetype<usize>(data.toISOString()),
-          48,
-        );
-        store<u16>(changetype<usize>(out), QUOTE, 50);
-        return changetype<string>(out);
-      } else if (data instanceof Array) {
-        bs.saveState();
-        // @ts-expect-error
-        inline.always(serializeArray(changetype<nonnull<T>>(data)));
-        return bs.cpyOut<string>();
-      } else if (data instanceof StaticArray) {
-        bs.saveState();
-        // @ts-expect-error
-        inline.always(serializeStaticArray(changetype<nonnull<T>>(data)));
-        return bs.cpyOut<string>();
-      } else if (data instanceof Set) {
-        bs.saveState();
-        // @ts-expect-error
-        inline.always(serializeSet(changetype<nonnull<T>>(data)));
-        return bs.cpyOut<string>();
-      } else if (data instanceof Map) {
-        bs.saveState();
-        // @ts-expect-error
-        inline.always(serializeMap(changetype<nonnull<T>>(data)));
-        return bs.cpyOut<string>();
-      } else if (data instanceof JSON.Raw) {
-        bs.saveState();
-        serializeRaw(data);
-        return bs.cpyOut<string>();
-      } else if (data instanceof JSON.Value) {
-        bs.saveState();
-        inline.always(serializeArbitrary(data));
-        return bs.cpyOut<string>();
-      } else if (data instanceof JSON.Obj) {
-        bs.saveState();
-        inline.always(serializeObject(data));
-        return bs.cpyOut<string>();
-      } else if (data instanceof JSON.Box) {
-        return JSON.internal.stringify(data.value);
-      } else {
-        throw new Error(
-          `Could not serialize data of type '${nameof<T>()}'. ` +
-            `If this is a custom class, add the @json decorator: @json class ${nameof<T>()} { ... }. ` +
-            `Supported types: primitives, string, Array, Map, Date, and @json decorated classes.`,
-        );
+    @inline export function stringify<T>(data: T, out: string | null = null): string {
+      bs.saveState();
+      JSON.__serialize<T>(data);
+      const result = bs.cpyOut<string>();
+      if (out) {
+        const len = bytes(result);
+        out = changetype<string>(__renew(changetype<usize>(out), len));
+        memory.copy(changetype<usize>(out), changetype<usize>(result), len);
+        return out;
       }
+      return result;
+    }
+
+    /**
+     * Parses JSON data without mutating the caller's active serialization buffer state.
+     * Don't use this directly, use `JSON.parse` instead.
+     * @param data - string
+     * @returns - T
+     */
+    // @ts-expect-error: inline
+    @inline export function parse<T>(data: string): T {
+      bs.saveState();
+      const result = JSON.parse<T>(data);
+      bs.loadState();
+      return result;
     }
   }
 }
@@ -1122,12 +1069,7 @@ export enum JSONMode {
   return JSON.parse<T>(data);
 }
 // @ts-expect-error: inline
-@inline function deserializeBox<T>(
-  srcStart: usize,
-  srcEnd: usize,
-  dst: usize,
-  ty: T,
-): T {
+@inline function deserializeBox<T>(srcStart: usize, srcEnd: usize, dst: usize, ty: T): T {
   return JSON.__deserialize<T>(srcStart, srcEnd, dst);
 }