json-as 1.2.1 → 1.2.2

package/assembly/index.ts

@@ -31,8 +31,8 @@ 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";
-
 /**
  * Offset of the 'storage' property in the JSON.Value class.
  */
@@ -106,21 +106,12 @@ export namespace JSON {
       return NULL_WORD;
       // @ts-ignore
     } else if (isString<nonnull<T>>()) {
-      // if (out) {
-      //   out = changetype<string>(__renew(changetype<usize>(out), bytes(data) + 4));
-      //   // const oldSize = bs.byteLength;
-      //   const oldBuf = bs.buffer;
-      //   const newSize = bytes(data) + 4;
-      //   const newBuf = __new(newSize, idof<string>());
-      //   bs.setBuffer(newBuf);
-      //   serializeString_SWAR(changetype<string>(data));
-      //   bs.setBuffer(oldBuf);
-      //   return changetype<string>(newBuf);
-      // }
-      if (ASC_FEATURE_SIMD) {
+      if (JSON_MODE === JSONMode.SIMD) {
         serializeString_SIMD(data as string);
-      } else {
+      } else if (JSON_MODE === JSONMode.SWAR) {
         serializeString_SWAR(data as string);
+      } else {
+        serializeString(data as string);
       }
       return bs.out<string>();
       // @ts-ignore: Supplied by transform
@@ -187,7 +178,7 @@ export namespace JSON {
       //   // @ts-ignore
       //   return changetype<string>(deserializeString_SIMD(dataPtr, dataPtr + dataSize, __new(dataSize - 4, idof<string>())));
       // } else {
-      
+
       // @ts-ignore
       return deserializeString(dataPtr, dataPtr + dataSize, 0);
       // }
@@ -232,19 +223,31 @@ export namespace JSON {
    * Enum representing the different types supported by JSON.
    */
   export enum Types {
-    Raw = 0,
-    U8 = 1,
-    U16 = 2,
-    U32 = 3,
-    U64 = 4,
-    F32 = 5,
-    F64 = 6,
-    Null = 7,
+    StructNull = -12,
+    ArrayNull = -11,
+    ObjectNull = -10,
+    StringNull = -9,
+    BoolNull = -8,
+    F64Null = -7,
+    F32Null = -6,
+    U64Null = -5,
+    U32Null = -4,
+    U16Null = -3,
+    U8Null = -2,
+    RawNull = -1, // unused
+    Null = 0,
+    Raw = 1,
+    U8 = 2,
+    U16 = 3,
+    U32 = 4,
+    U64 = 5,
+    F32 = 6,
+    F64 = 7,
     Bool = 8,
     String = 9,
     Object = 10,
-    Array = 12,
-    Struct = 13,
+    Array = 11,
+    Struct = 12,
   }
 
   export class Raw {
@@ -271,6 +274,7 @@ export namespace JSON {
     static METHODS: Map<u32, u32> = new Map<u32, u32>();
     public type: i32;
 
+    public isNull: bool;
     private storage: u64;
 
     private constructor() {
@@ -298,63 +302,125 @@ export namespace JSON {
       out.set<T>(value);
       return out;
     }
-
-    /**
-     * Sets the value of the JSON.Value instance.
-     * @param value - The value to be set.
-     */
-    @inline set<T>(value: T): void {
-      if (isBoolean<T>()) {
-        this.type = JSON.Types.Bool;
+    @inline private setPrimitive<T>(value: T): void {
+      if (isBoolean(value)) {
+        this.type = JSON.Types.BoolNull;
         store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (isInteger<T>() && !isSigned<T>() && changetype<usize>(value) == 0 && nameof<T>() == "usize") {
-        this.type = JSON.Types.Null;
-        store<usize>(changetype<usize>(this), 0, STORAGE);
       } else if (value instanceof u8 || value instanceof i8) {
-        this.type = JSON.Types.U8;
+        this.type = JSON.Types.U8Null;
         store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof u16 || value instanceof i16) {
         this.type = JSON.Types.U16;
         store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof u32 || value instanceof i32) {
-        this.type = JSON.Types.U32;
+        this.type = JSON.Types.U32Null;
         store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof u64 || value instanceof i64) {
-        this.type = JSON.Types.U64;
+        this.type = JSON.Types.U64Null;
         store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof f32) {
-        this.type = JSON.Types.F32;
+        this.type = JSON.Types.F32Null;
         store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof f64) {
-        this.type = JSON.Types.F64;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (isString<T>()) {
-        this.type = JSON.Types.String;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (value instanceof JSON.Raw) {
-        this.type = JSON.Types.Raw;
+        this.type = JSON.Types.F64Null;
         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>!");
+      }
+    }
+    /**
+     * Sets the value of the JSON.Value instance.
+     * @param value - The value to be set.
+     */
+    @inline set<T>(value: T): void {
+      if (isNullable<T>()) {
+        this.isNull = changetype<usize>(value) === 0;
+        if (value instanceof JSON.Box) {
+          return this.setPrimitive(value.value);
+        } else if (isBoolean<T>()) {
+          this.type = JSON.Types.BoolNull;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (isString<T>()) {
+          this.type = JSON.Types.StringNull;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (value instanceof JSON.Raw) {
+          this.type = JSON.Types.RawNull;
+          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>!");
+          }
+          this.type = JSON.Types.StructNull;
+          store<T>(changetype<usize>(this), value, STORAGE);
+          // @ts-ignore: supplied by transform
+        } else if (isDefined(value.__SERIALIZE) && isManaged<T>(value)) {
+          this.type = idof<T>() + JSON.Types.StructNull;
+          // @ts-ignore
+          if (!JSON.Value.METHODS.has(idof<T>())) JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE.index);
+          // @ts-ignore
+          store<usize>(changetype<usize>(this), changetype<usize>(value), STORAGE);
+        } else if (value instanceof JSON.Obj) {
+          this.type = JSON.Types.ObjectNull;
+          store<T>(changetype<usize>(this), value, STORAGE);
+          // @ts-ignore
+        } else if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>()) {
+          // @ts-ignore: T satisfies constraints of any[]
+          this.type = JSON.Types.ArrayNull;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        }
+      } else {
+        if (value instanceof JSON.Box) {
+          return this.set(value.value);
+        } else if (isBoolean<T>()) {
+          this.type = JSON.Types.Bool;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (isInteger<T>() && !isSigned<T>() && changetype<usize>(value) == 0 && nameof<T>() == "usize") {
+          this.type = JSON.Types.Null;
+          store<usize>(changetype<usize>(this), 0, STORAGE);
+        } else if (value instanceof u8 || value instanceof i8) {
+          this.type = JSON.Types.U8;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (value instanceof u16 || value instanceof i16) {
+          this.type = JSON.Types.U16;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (value instanceof u32 || value instanceof i32) {
+          this.type = JSON.Types.U32;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (value instanceof u64 || value instanceof i64) {
+          this.type = JSON.Types.U64;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (value instanceof f32) {
+          this.type = JSON.Types.F32;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (value instanceof f64) {
+          this.type = JSON.Types.F64;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (isString<T>()) {
+          this.type = JSON.Types.String;
+          store<T>(changetype<usize>(this), value, STORAGE);
+        } else if (value instanceof JSON.Raw) {
+          this.type = JSON.Types.Raw;
+          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>!");
+          }
+          this.type = JSON.Types.Struct;
+          store<T>(changetype<usize>(this), value, STORAGE);
+          // @ts-ignore: supplied by transform
+        } else if (isDefined(value.__SERIALIZE) && isManaged<T>(value)) {
+          this.type = idof<T>() + JSON.Types.Struct;
+          // @ts-ignore
+          if (!JSON.Value.METHODS.has(idof<T>())) JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE.index);
+          // @ts-ignore
+          store<usize>(changetype<usize>(this), changetype<usize>(value), STORAGE);
+        } else if (value instanceof JSON.Obj) {
+          this.type = JSON.Types.Object;
+          store<T>(changetype<usize>(this), value, STORAGE);
+          // @ts-ignore
+        } else if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>()) {
+          // @ts-ignore: T satisfies constraints of any[]
+          this.type = JSON.Types.Array;
+          store<T>(changetype<usize>(this), value, STORAGE);
         }
-        this.type = JSON.Types.Struct;
-        store<T>(changetype<usize>(this), value, STORAGE);
-        // @ts-ignore: supplied by transform
-      } else if (isDefined(value.__SERIALIZE) && isManaged<T>(value)) {
-        this.type = idof<T>() + JSON.Types.Struct;
-        // @ts-ignore
-        if (!JSON.Value.METHODS.has(idof<T>())) JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE.index);
-        // @ts-ignore
-        store<usize>(changetype<usize>(this), changetype<usize>(value), STORAGE);
-      } else if (value instanceof JSON.Obj) {
-        this.type = JSON.Types.Object;
-        store<T>(changetype<usize>(this), value, STORAGE);
-        // @ts-ignore
-      } else if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>()) {
-        // @ts-ignore: T satisfies constraints of any[]
-        this.type = JSON.Types.Array;
-        store<T>(changetype<usize>(this), value, STORAGE);
       }
     }
 
@@ -375,12 +441,29 @@ export namespace JSON {
       return load<T>(changetype<usize>(this), STORAGE);
     }
 
+    /**
+     * Gets the value of the JSON.Value instance as a Box<T>.
+     * Alias for .get<T>()
+     * @returns The encapsulated value.
+     */
+    @inline asBox<T>(): Box<T> | null {
+      if (this.isNull) return null;
+      return changetype<Box<T>>(JSON.Box.fromValue<T>(this));
+    }
+
     /**
      * Converts the JSON.Value to a string representation.
      * @returns The string representation of the JSON.Value.
      */
     toString(): string {
+      if (this.type < JSON.Types.Null) {
+        if (this.isNull) return "null";
+        else this.type = ~this.type + 1;
+      }
+
       switch (this.type) {
+        case JSON.Types.Null:
+          return "null";
         case JSON.Types.U8:
           return this.get<u8>().toString();
         case JSON.Types.U16:
@@ -439,7 +522,7 @@ export namespace JSON {
     // @ts-ignore: type
     storage: Map<string, JSON.Value> = new Map<string, JSON.Value>();
 
-    constructor() {}
+    constructor() { }
 
     // @ts-ignore: decorator
     @inline get size(): i32 {
@@ -509,6 +592,24 @@ export namespace JSON {
       this.value = value;
       return this;
     }
+    /**
+     * Creates a Box<T> | null from a JSON.Value
+     * This means that it can create a nullable primitive from a JSON.Value
+     * ```js
+     * const value = JSON.parse<i32>("null"); // -> Box<i32> | null
+     * const boxed = JSON.Box.fromValue<i32>(value); // -> Box<i32> | null
+     * // null
+     * ```
+     * @param from T
+     * @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.isNull) return null;
+      const v = value.type === JSON.Types.F64 ?value.get<f64>() : value.get<T>();
+      // @ts-ignore
+      return new Box(isInteger<T>() || isFloat<T>() ? <T>(v) : v);
+    }
     /**
      * Creates a reference to a primitive type
      * This means that it can create a nullable primitive
@@ -533,58 +634,60 @@ export namespace JSON {
   /**
    * Serializes JSON data but writes directly to the buffer.
    * Should only be used if you know what you are doing.
-   * @param src - T
+   * @param data - T
    * @returns void
    */
-  export function __serialize<T>(src: T): void {
+  export function __serialize<T>(data: T): void {
     if (isBoolean<T>()) {
-      serializeBool(src as bool);
-    } else if (isInteger<T>() && nameof<T>() == "usize" && src == 0) {
+      serializeBool(data as bool);
+    } else if (isInteger<T>() && nameof<T>() == "usize" && data == 0) {
       bs.proposeSize(8);
       store<u64>(bs.offset, 30399761348886638);
       bs.offset += 8;
     } else if (isInteger<T>()) {
       // @ts-ignore
-      serializeInteger<T>(src);
-    } else if (isFloat<T>(src)) {
+      serializeInteger<T>(data);
+    } else if (isFloat<T>(data)) {
       // @ts-ignore
-      serializeFloat<T>(src);
+      serializeFloat<T>(data);
       // @ts-ignore: Function is generated by transform
-    } else if (isNullable<T>() && changetype<usize>(src) == <usize>0) {
+    } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
       bs.proposeSize(8);
       store<u64>(bs.offset, 30399761348886638);
       bs.offset += 8;
     } else if (isString<nonnull<T>>()) {
-      if (ASC_FEATURE_SIMD) {
-        serializeString_SIMD(src as string);
+      if (JSON_MODE === JSONMode.SIMD) {
+        serializeString_SIMD(data as string);
+      } else if (JSON_MODE === JSONMode.SWAR) {
+        serializeString_SWAR(data as string);
       } else {
-        serializeString_SWAR(src as string);
+        serializeString(data as string);
       }
       // @ts-ignore: Supplied by transform
-    } else if (isDefined(src.__SERIALIZE_CUSTOM)) {
+    } else if (isDefined(data.__SERIALIZE_CUSTOM)) {
       // @ts-ignore
-      return src.__SERIALIZE_CUSTOM();
+      return data.__SERIALIZE_CUSTOM();
       // @ts-ignore: Supplied by transform
-    } else if (isDefined(src.__SERIALIZE)) {
+    } else if (isDefined(data.__SERIALIZE)) {
       // @ts-ignore
-      serializeStruct(changetype<nonnull<T>>(src));
-    } else if (src instanceof Date) {
+      serializeStruct(changetype<nonnull<T>>(data));
+    } else if (data instanceof Date) {
       // @ts-ignore
-      inline.always(serializeDate(changetype<nonnull<T>>(src)));
-    } else if (src instanceof Array || src instanceof StaticArray) {
+      inline.always(serializeDate(changetype<nonnull<T>>(data)));
+    } else if (data instanceof Array || data instanceof StaticArray) {
       // @ts-ignore
-      serializeArray(changetype<nonnull<T>>(src));
-    } else if (src instanceof Map) {
+      serializeArray(changetype<nonnull<T>>(data));
+    } else if (data instanceof Map) {
       // @ts-ignore
-      serializeMap(changetype<nonnull<T>>(src));
-    } else if (src instanceof JSON.Raw) {
-      serializeRaw(src);
-    } else if (src instanceof JSON.Value) {
-      serializeArbitrary(src);
-    } else if (src instanceof JSON.Obj) {
-      serializeObject(src);
-    } else if (src instanceof JSON.Box) {
-      __serialize(src.value);
+      serializeMap(changetype<nonnull<T>>(data));
+    } else if (data instanceof JSON.Raw) {
+      serializeRaw(data);
+    } else if (data instanceof JSON.Value) {
+      serializeArbitrary(data);
+    } else if (data instanceof JSON.Obj) {
+      serializeObject(data);
+    } else if (data instanceof JSON.Box) {
+      __serialize(data.value);
     } else {
       throw new Error(`Could not serialize provided data. Make sure to add the correct decorators to classes.`);
     }
@@ -608,7 +711,7 @@ export namespace JSON {
       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!");
-      
+
       // @ts-ignore: type
       return deserializeString(srcStart, srcEnd, dst);
     } else if (isNullable<T>() && srcEnd - srcStart == 8 && load<u64>(srcStart) == 30399761348886638) {
@@ -721,22 +824,12 @@ export namespace JSON {
         return NULL_WORD;
         // @ts-ignore
       } else if (isString<nonnull<T>>()) {
-        // if (out) {
-        //   out = changetype<string>(__renew(changetype<usize>(out), bytes(data) + 4));
-        //   // const oldSize = bs.byteLength;
-        //   const oldBuf = bs.buffer;
-        //   const newSize = bytes(data) + 4;
-        //   const newBuf = __new(newSize, idof<string>());
-        //   bs.setBuffer(newBuf);
-        //   serializeString_SWAR(changetype<string>(data));
-        //   bs.setBuffer(oldBuf);
-        //   return changetype<string>(newBuf);
-        // }
-        if (ASC_FEATURE_SIMD) {
+        if (JSON_MODE === JSONMode.SIMD) {
           serializeString_SIMD(data as string);
-        } else {
-          bs.saveState();
+        } else if (JSON_MODE === JSONMode.SWAR) {
           serializeString_SWAR(data as string);
+        } else {
+          serializeString(data as string);
         }
         return bs.cpyOut<string>();
         // @ts-ignore: Supplied by transform
@@ -784,6 +877,12 @@ export namespace JSON {
   }
 }
 
+export enum JSONMode {
+  SWAR = 0,
+  SIMD = 1,
+  NAIVE = 2
+}
+
 // @ts-ignore: decorator
 @inline function parseBox<T>(data: string, ty: T): T {
   return JSON.parse<T>(data);

package/assembly/serialize/simd/string.ts

@@ -1,4 +1,4 @@
-import { bs } from "../../../lib/as-bs";
+import { bs, sc } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { bytes } from "../../util";
@@ -7,6 +7,18 @@ import { bytes } from "../../util";
  * Serializes strings into their JSON counterparts using SIMD operations
  */
 export function serializeString_SIMD(src: string): void {
+  let srcStart = changetype<usize>(src);
+if (isDefined(JSON_CACHE)) {
+    // check cache
+    const e = unchecked(sc.entries[(srcStart >> 4) & sc.CACHE_MASK]);
+    if (e.key == srcStart) {
+      // bs.offset += e.len;
+      // bs.stackSize += e.len;
+      bs.cacheOutput = e.ptr;
+      bs.cacheOutputLen = e.len;
+      return;
+    }
+  }
   const U00_MARKER = 13511005048209500;
   const SPLAT_34 = i16x8.splat(34); /* " */
   const SPLAT_92 = i16x8.splat(92); /* \ */
@@ -14,7 +26,6 @@ export function serializeString_SIMD(src: string): void {
   const SPLAT_32 = i16x8.splat(32); /* [ESC] */
 
   const srcSize = bytes(src);
-  let srcStart = changetype<usize>(src);
   const srcEnd = srcStart + srcSize;
   const srcEnd16 = srcEnd - 16;
 
@@ -36,7 +47,7 @@ export function serializeString_SIMD(src: string): void {
     let mask = i16x8.bitmask(sieve);
 
     while (mask != 0) {
-      const lane_index = ctz(mask) << 1;
+      const lane_index = ctz(mask) << 1; // 0 2 4 6 8 10 12 14
       // console.log("lane: "  + (lane_index >= 8 ? (lane_index - 8).toString():lane_index.toString()));
       const src_offset = srcStart + lane_index;
       const code = load<u16>(src_offset) << 2;
@@ -85,4 +96,6 @@ export function serializeString_SIMD(src: string): void {
 
   store<u8>(bs.offset, 34); /* " */
   bs.offset += 2;
+
+  if (isDefined(JSON_CACHE)) sc.insertCached(changetype<usize>(src), srcStart, srcSize);
 }

package/assembly/serialize/simple/arbitrary.ts

@@ -1,5 +1,5 @@
 import { JSON } from "../..";
-import { serializeString_SWAR } from "../swar/string";
+import { bs } from "../../../lib/as-bs";
 import { serializeArray } from "./array";
 import { serializeBool } from "./bool";
 import { serializeFloat } from "./float";
@@ -8,7 +8,21 @@ import { serializeObject } from "./object";
 import { serializeString } from "./string";
 
 export function serializeArbitrary(src: JSON.Value): void {
+  if (src.type < JSON.Types.Null) {
+    if (src.isNull) {
+      bs.proposeSize(8);
+      store<u64>(bs.offset, 30399761348886638);
+      bs.offset += 8;
+      return;
+    } else src.type = ~src.type + 1;
+  }
+
   switch (src.type) {
+    case JSON.Types.Null: 
+      bs.proposeSize(8);
+      store<u64>(bs.offset, 30399761348886638);
+      bs.offset += 8;
+      break;
     case JSON.Types.U8:
       serializeInteger<u8>(src.get<u8>());
       break;
@@ -28,7 +42,7 @@ export function serializeArbitrary(src: JSON.Value): void {
       serializeFloat<f64>(src.get<f64>());
       break;
     case JSON.Types.String:
-      serializeString_SWAR(src.get<string>());
+      serializeString(src.get<string>());
       break;
     case JSON.Types.Bool:
       serializeBool(src.get<bool>());

package/assembly/serialize/swar/string.ts

@@ -1,7 +1,7 @@
-import { bs } from "../../../lib/as-bs";
+import { bs, sc } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
-import { bytes } from "../../util/bytes";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
 
 // @ts-ignore: decorator allowed
@@ -22,8 +22,21 @@ import { bytes } from "../../util/bytes";
 @lazy const U00_MARKER = 13511005048209500;
 
 export function serializeString_SWAR(src: string): void {
-  const srcSize = bytes(src);
   let srcStart = changetype<usize>(src);
+
+  if (isDefined(JSON_CACHE)) {
+    // check cache
+    const e = unchecked(sc.entries[(srcStart >> 4) & sc.CACHE_MASK]);
+    if (e.key == srcStart) {
+      // bs.offset += e.len;
+      // bs.stackSize += e.len;
+      bs.cacheOutput = e.ptr;
+      bs.cacheOutputLen = e.len;
+      return;
+    }
+  }
+
+  const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize
   const srcEnd = srcStart + srcSize;
   const srcEnd8 = srcEnd - 8;
 
@@ -68,7 +81,7 @@ export function serializeString_SWAR(src: string): void {
     bs.offset += 8;
   }
 
-while (srcStart <= srcEnd - 2) {
+  while (srcStart <= srcEnd - 2) {
     const code = load<u16>(srcStart);
     if (code == 92 || code == 34 || code < 32) {
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
@@ -91,19 +104,32 @@ while (srcStart <= srcEnd - 2) {
 
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
+
+  if (isDefined(JSON_CACHE)) sc.insertCached(changetype<usize>(src), srcStart, srcSize);
 }
 
 // @ts-ignore: decorators allowed
 @inline function v64x4_should_escape(x: u64): u64 {
-  x = x ^ 0xFF00FF00FF00FF00;
-  
-  const is_ascii: u64 = HIGHS & ~x;
-  const xor2: u64 = x ^ 0x0202020202020202;
-  const lt32_or_eq34: u64 = xor2 - 0x2121212121212121;
-  const sub92: u64 = x ^ 0x5C5C5C5C5C5C5C5C;
-  const eq92: u64 = sub92 - ONES;
-  
-  const high_bits: u64 = (lt32_or_eq34 | eq92) & is_ascii;
-  
-  return high_bits
+ // console.log("input:    " + mask_to_string(x));
+  const hi = x & 0xff00_ff00_ff00_ff00;
+  const lo = x & 0x00ff_00ff_00ff_00ff;
+  x &= 0x00ff_00ff_00ff_00ff;
+  // const is_cp = hi & 0x8080_8080_8080_8080;
+  const is_ascii = 0x0080_0080_0080_0080 & ~x; // lane remains 0x80 if ascii
+  const lt32 = (x - 0x0020_0020_0020_0020);
+  const sub34 = x ^ 0x0022_0022_0022_0022;
+  const eq34 = (sub34 - 0x0001_0001_0001_0001);
+  const sub92 = x ^ 0x005C_005C_005C_005C;
+  const eq92 = (sub92 - 0x0001_0001_0001_0001);
+  // console.log("low:      " + mask_to_string(lo));
+  // console.log("high:     " + mask_to_string(hi));
+  // console.log("is_cp:    " + mask_to_string(is_cp));
+  // console.log("is_ascii: " + mask_to_string(is_ascii));
+  // console.log("lt32:     " + mask_to_string(lt32));
+  // console.log("sub34:    " + mask_to_string(sub34));
+  // console.log("eq34:     " + mask_to_string(eq34));
+  // console.log("eq92:     " + mask_to_string(eq92));
+  // console.log("pre:      " + mask_to_string((lt32 | eq34 | eq92)));
+  // console.log("out:      " + mask_to_string((lt32 | eq34 | eq92) & is_ascii));
+  return ((lt32 | eq34 | eq92)& is_ascii);
 }

package/assembly/test.ts

@@ -0,0 +1,38 @@
+import { JSON } from ".";
+
+@json
+class Vec3 {
+  x!: f32;
+  y!: f32;
+  z!: f32;
+}
+
+const vec: Vec3 = {
+  x: 1.0,
+  y: 2.0,
+  z: 3.0
+}
+const str: JSON.Value[] = [
+  JSON.Value.from<string>("foo"),
+  JSON.Value.from("bar"),
+  JSON.Value.from(1),
+  JSON.Value.from(2),
+  JSON.Value.from(true),
+  JSON.Value.from<JSON.Box<i32> | null>(null),
+  JSON.Value.from(vec),
+  JSON.Value.from<Vec3 | null>(null),
+  JSON.Value.from<JSON.Box<i32> | null>(JSON.Box.from(123)),
+  JSON.Value.from<JSON.Box<i32> | null>(null),
+];
+const box = JSON.Box.from<i32>(123);
+const value = JSON.Value.from<JSON.Box<i32> | null>(box);
+const reboxed = JSON.Box.fromValue<i32>(value); // Box<i32> | null
+console.log(reboxed !== null ? reboxed!.toString() : "null");
+
+// console.log(str[9]!.asBox<i32>()?.toString());
+// console.log(str.toString())
+const serialized = JSON.stringify(str);
+console.log("Serialized: " + serialized);
+
+const deserialized = JSON.parse<JSON.Value[]>(serialized);
+console.log("Deserialized: " + JSON.stringify(deserialized).toString());