json-as 1.3.0 → 1.3.1

package/assembly/deserialize/simple/string.ts

@@ -1,13 +1,37 @@
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { bs } from "../../../lib/as-bs";
+import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
 import { hex4_to_u16_swar } from "../../util/swar";
 
+// @ts-ignore: inline
+@inline function writeStringToField(dstFieldPtr: usize, srcStart: usize, byteLength: u32): void {
+  if (byteLength == 0) {
+    store<usize>(dstFieldPtr, changetype<usize>(""));
+    return;
+  }
+
+  const current = load<usize>(dstFieldPtr);
+  let stringPtr: usize;
+  if (current != 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);
@@ -37,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/swar/string.ts

@@ -43,7 +43,6 @@ import { hex4_to_u16_swar } from "../../util/swar";
 // @ts-expect-error: @inline is a valid decorator
 @inline function copyStringFromSource(srcStart: usize, byteLength: usize): string {
   if (byteLength == 0) return changetype<string>("");
-  // @ts-expect-error: __new is a runtime builtin
   const out = __new(byteLength, idof<string>());
   memory.copy(out, srcStart, byteLength);
   return changetype<string>(out);
@@ -53,10 +52,10 @@ import { hex4_to_u16_swar } from "../../util/swar";
 @inline function deserializeEscapedString_SWAR(payloadStart: usize, escapeStart: usize, srcEnd: usize): string {
   const srcEnd8 = srcEnd - 8;
   const prefixLen = <u32>(escapeStart - payloadStart);
-  bs.offset = bs.buffer;
+  const outStart = bs.offset - bs.buffer;
   bs.ensureSize(<u32>(srcEnd - payloadStart));
   if (prefixLen != 0) {
-    memory.copy(bs.buffer, payloadStart, prefixLen);
+    memory.copy(bs.offset, payloadStart, prefixLen);
     bs.offset += prefixLen;
   }
 
@@ -141,7 +140,7 @@ import { hex4_to_u16_swar } from "../../util/swar";
 
     bs.offset += 2;
   }
-  return bs.out<string>();
+  return bs.sliceOut<string>(outStart);
 }
 
 export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
@@ -608,10 +607,10 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
 @inline function deserializeEscapedStringScan_SWAR(payloadStart: usize, escapeStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
   const prefixLen = <u32>(escapeStart - payloadStart);
   const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
-  bs.offset = bs.buffer;
+  const outStart = bs.offset - bs.buffer;
   bs.ensureSize(<u32>(srcEnd - payloadStart));
   if (prefixLen != 0) {
-    memory.copy(bs.buffer, payloadStart, prefixLen);
+    memory.copy(bs.offset, payloadStart, prefixLen);
     bs.offset += prefixLen;
   }
 
@@ -637,8 +636,7 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
           memory.copy(bs.offset, lastPtr, runLen);
           bs.offset += runLen;
         }
-        writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
-        bs.offset = bs.buffer;
+        bs.toField(outStart, dstFieldPtr);
         return srcIdx + 2;
       }
       if (char != BACK_SLASH) continue;
@@ -674,8 +672,7 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
         memory.copy(bs.offset, lastPtr, runLen);
         bs.offset += runLen;
       }
-      writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
-      bs.offset = bs.buffer;
+      bs.toField(outStart, dstFieldPtr);
       return srcStart + 2;
     }
     if (char != BACK_SLASH) {
@@ -703,7 +700,7 @@ export function deserializeStringField_SWAR<T extends string | null>(srcStart: u
     lastPtr = srcStart;
   }
 
-  bs.offset = bs.buffer;
+  bs.offset = bs.buffer + outStart;
   abort("Unterminated string literal");
   return srcStart;
 }

package/assembly/index.ts

@@ -34,7 +34,7 @@ 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, serializeTypedArray } from "./serialize/index/typedarray";
+import { serializeArrayBufferUnsafe, serializeDynamic, serializeTypedArray } from "./serialize/index/typedarray";
 
 /**
  * Offset of the 'storage' property in the JSON.Value class.
@@ -59,7 +59,7 @@ export namespace JSON {
      * ```
      */
     export function shrink(): void {
-      bs.resize(64);
+      bs.shrink();
     }
   }
   /**
@@ -118,9 +118,14 @@ export namespace JSON {
     } else if (isString<nonnull<T>>()) {
       serializeString(data as string);
       return bs.out<string>();
-      // @ts-expect-error: Supplied by transform
+      // @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: 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) {
@@ -171,6 +176,10 @@ export namespace JSON {
     } 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)));
@@ -191,16 +200,10 @@ 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, StaticArray, TypedArray, Map, Date, and @json decorated classes. ` + `For ArrayBuffer, use JSON.stringifyArrayBuffer(changetype<usize>(...)).`);
+      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.`);
     }
   }
 
-
-  @inline export function stringifyArrayBuffer(dataStart: usize): string {
-    serializeArrayBufferUnsafe(dataStart, changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize);
-    return bs.out<string>();
-  }
-
   /**
    * Parses valid JSON strings into their original format
    * ```js
@@ -225,6 +228,20 @@ export namespace JSON {
       return deserializeString(dataPtr, dataPtr + dataSize) as T;
     } 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
+        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>>()));
+        // @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));
@@ -232,40 +249,32 @@ export namespace JSON {
         // @ts-expect-error
         return inline.always(deserializeArray<nonnull<T>>(dataPtr, dataPtr + dataSize, changetype<usize>(instantiate<T>())));
       } else if (type instanceof Int8Array) {
-        return deserializeTypedArray<Int8Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Uint8Array) {
-        return deserializeTypedArray<Uint8Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Uint8ClampedArray) {
-        return deserializeTypedArray<Uint8ClampedArray>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Int16Array) {
-        return deserializeTypedArray<Int16Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Uint16Array) {
-        return deserializeTypedArray<Uint16Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Int32Array) {
-        return deserializeTypedArray<Int32Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Uint32Array) {
-        return deserializeTypedArray<Uint32Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Int64Array) {
-        return deserializeTypedArray<Int64Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Uint64Array) {
-        return deserializeTypedArray<Uint64Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Float32Array) {
-        return deserializeTypedArray<Float32Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        return deserializeTypedArray<nonnull<T>>(dataPtr, dataPtr + dataSize, 0) as T;
       } else if (type instanceof Float64Array) {
-        return deserializeTypedArray<Float64Array>(dataPtr, dataPtr + dataSize, 0) as T;
+        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));
-        // @ts-expect-error: Defined by transform
-      } else if (isDefined(type.__DESERIALIZE)) {
-        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
-        out.__DESERIALIZE(dataPtr, dataPtr + dataSize, out);
-        return out;
       } else if (type instanceof Map) {
         // @ts-expect-error
         return inline.always(deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize, 0));
@@ -299,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 */
@@ -340,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;
   }
 
   /**
@@ -470,12 +483,23 @@ export namespace JSON {
       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;
     }
     /**
@@ -492,16 +516,28 @@ export namespace JSON {
       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);
+      // @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
@@ -587,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>());
         }
@@ -808,13 +849,13 @@ export namespace JSON {
       bs.offset += 8;
     } else if (isString<nonnull<T>>()) {
       serializeString(data as string);
-      // @ts-expect-error: Supplied by transform
+      // @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
@@ -847,6 +888,9 @@ export namespace JSON {
       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));
@@ -862,33 +906,10 @@ 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, StaticArray, TypedArray, Map, Date, and @json decorated classes. ` + `For ArrayBuffer, use JSON.stringifyArrayBuffer(changetype<usize>(...)).`);
+      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.`);
     }
   }
 
-
-  @inline export function __serializeArrayBufferUnsafe(dataStart: usize): void {
-    serializeArrayBufferUnsafe(dataStart, changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize);
-  }
-
-
-  @inline export function __serializeArrayBuffer(data: ArrayBuffer): void {
-    const dataStart = changetype<usize>(data);
-    serializeArrayBufferUnsafe(dataStart, changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize);
-  }
-
-
-  @inline export function parseArrayBuffer(data: string): ArrayBuffer {
-    const dataSize = bytes(data);
-    const dataPtr = changetype<usize>(data);
-    return deserializeArrayBuffer(dataPtr, dataPtr + dataSize, 0);
-  }
-
-
-  @inline export function __deserializeArrayBuffer(srcStart: usize, srcEnd: usize, dst: usize = 0): ArrayBuffer {
-    return deserializeArrayBuffer(srcStart, srcEnd, dst);
-  }
-
   /**
    * Deserializes JSON data directly from the buffer.
    * Should only be used if you know what you are doing.
@@ -913,6 +934,20 @@ export namespace JSON {
       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);
@@ -920,40 +955,32 @@ export namespace JSON {
         // @ts-expect-error: type
         return deserializeArray<T>(srcStart, srcEnd, dst);
       } else if (type instanceof Int8Array) {
-        return deserializeTypedArray<Int8Array>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Uint8Array) {
-        return deserializeTypedArray<Uint8Array>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Uint8ClampedArray) {
-        return deserializeTypedArray<Uint8ClampedArray>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Int16Array) {
-        return deserializeTypedArray<Int16Array>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Uint16Array) {
-        return deserializeTypedArray<Uint16Array>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Int32Array) {
-        return deserializeTypedArray<Int32Array>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Uint32Array) {
-        return deserializeTypedArray<Uint32Array>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Int64Array) {
-        return deserializeTypedArray<Int64Array>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Uint64Array) {
-        return deserializeTypedArray<Uint64Array>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Float32Array) {
-        return deserializeTypedArray<Float32Array>(srcStart, srcEnd, dst) as T;
+        return deserializeTypedArray<nonnull<T>>(srcStart, srcEnd, dst) as T;
       } else if (type instanceof Float64Array) {
-        return deserializeTypedArray<Float64Array>(srcStart, srcEnd, dst) as T;
+        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
-        out.__DESERIALIZE(srcStart, srcEnd, out);
-        return out;
       } else if (type instanceof Map) {
         // @ts-expect-error: type
         return deserializeMap<T>(srcStart, srcEnd, dst);
@@ -991,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 {
     /**
@@ -1002,102 +1030,30 @@ export namespace JSON {
      */
     // @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>>()) {
-        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.`);
+      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;
     }
   }
 }