json-as 1.1.19 → 1.1.21

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## 2025-08-14 - 1.1.21
+
+- fix: JSON.parse on classes with enums [#155](https://github.com/JairusSW/json-as/issues/155)
+- fix: Resolve memory OOB issue within `serializeFloat` function [#153](https://github.com/JairusSW/json-as/issues/153)
+
+## 2025-07-14 - 1.1.20
+
+- feat: enable SIMD string serialization
+
 ## 2025-06-30 - 1.1.19
 
 - fix: wrong path used in `readFileSync` when importing from a library

package/README.md

@@ -1,34 +1,6 @@
-<h6 align="center">
-  <pre>
-<span style="font-size: 0.8em;">     ██ ███████  ██████  ███    ██        █████  ███████
-     ██ ██      ██    ██ ████   ██       ██   ██ ██     
-     ██ ███████ ██    ██ ██ ██  ██ █████ ███████ ███████
-██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
- █████  ███████  ██████  ██   ████       ██   ██ ███████
- </span>
-    AssemblyScript - v1.1.19
-  </pre>
-</h6>
-
-## 📝 About
-
-JSON is the de-facto serialization format of modern web applications, but its serialization and deserialization remain a significant performance bottleneck, especially at scale. Traditional parsing approaches are computationally expensive, adding unnecessary overhead to both clients and servers. This library is designed to mitigate this by leveraging SIMD acceleration and highly optimized transformations.
-
-## 📚 Contents
-
-- [Installation](#-installation)
-- [Usage](#-usage)
-- [Examples](#-examples)
-  - [Omitting Fields](#️-omitting-fields)
-  - [Nullable Primitives](#️-using-nullable-primitives)
-  - [Unknown or Dynamic Data](#-working-with-unknown-or-dynamic-data)
-  - [Using Raw JSON Strings](#️-using-raw-json-strings)
-  - [Using Enums](#️-working-with-enums)
-  - [Custom Serializers](#️-using-custom-serializers-or-deserializers)
-- [Performance](#-performance)
-- [Debugging](#-debugging)
-- [License](#-license)
-- [Contact](#-contact)
+<h1 align="center"><pre> ╦╔═╗╔═╗╔╗╔  ╔═╗╔═╗
+ ║╚═╗║ ║║║║══╠═╣╚═╗
+╚╝╚═╝╚═╝╝╚╝  ╩ ╩╚═╝</pre></h1>
 
 ## 💾 Installation
 
@@ -297,7 +269,7 @@ console.log(JSON.stringify(map));
 
 ### 📝 Working with enums
 
-By default, enums arn't supported by `json-as`. However, you can use a workaround:
+By default, enums with values other than `i32` arn't supported by AssemblyScript. However, you can use a workaround:
 
 ```typescript
 namespace Foo {
@@ -391,7 +363,7 @@ These benchmarks compare this library to JavaScript's native `JSON.stringify` an
 | Test Case       | Size       | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
 | --------------- | ---------- | --------------------- | ----------------------- | -------------------- | ---------------------- |
 | Vector3 Object  | 38 bytes   | 26,611,226 ops/s      | 32,160,804 ops/s        | 1,357 MB/s           | 1,348 MB/s             |
-| Alphabet String | 104 bytes  | 13,617,021 ops/s      | 18,390,804 ops/s        | 1,416 MB/s           | 1,986 MB/s             |
+| Alphabet String | 104 bytes  | 16,916,886 ops/s      | 18,390,804 ops/s        | 1,759 MB/s           | 1,986 MB/s             |
 | Small Object    | 88 bytes   | 24,242,424 ops/s      | 12,307,692 ops/s        | 2,133 MB/s           | 1,083 MB/s             |
 | Medium Object   | 494 bytes  | 4,060,913 ops/s       | 1,396,160 ops/s         | 2,006 MB/s           | 689.7 MB/s             |
 | Large Object    | 3374 bytes | 479,616 ops/s         | 132,802 ops/s           | 2,074 MB/s           | 448.0 MB/s             |
@@ -401,7 +373,7 @@ These benchmarks compare this library to JavaScript's native `JSON.stringify` an
 | Test Case       | Size       | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
 | --------------- | ---------- | --------------------- | ----------------------- | -------------------- | ---------------------- |
 | Vector3 Object  | 38 bytes   | 8,791,209 ops/s       | 5,369,12 ops/s          | 357.4 MB/s           | 204.3 MB/s             |
-| Alphabet String | 104 bytes  | 13,793,103 ops/s      | 14,746,544 ops/s        | 1,416 MB/s           | 1,592 MB/s             |
+| Alphabet String | 104 bytes  | 12,830,228 ops/s      | 12,140,296 ops/s        | 1,334 MB/s           | 1,311 MB/s             |
 | Small Object    | 88 bytes   | 8,376,963 ops/s       | 4,968,944 ops/s         | 737.1 MB/s           | 437.2 MB/s             |
 | Medium Object   | 494 bytes  | 2,395,210 ops/s       | 1,381,693 ops/s         | 1,183 MB/s           | 682.5 MB/s             |
 | Large Object    | 3374 bytes | 222,222 ops/s         | 117,233 ops/s           | 749.7 MB/s           | 395.5 MB/s             |

package/assembly/__benches__/abc.bench.ts

@@ -5,20 +5,28 @@ import { bench } from "./lib/bench";
 const v1 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 const v2 = '"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"';
 
+const blackBoxArea = memory.data(64);
 expect(JSON.stringify(v1)).toBe(v2);
 
 bench(
   "Serialize Alphabet",
   () => {
-    inline.always(JSON.stringify(v1));
+    blackbox(inline.always(JSON.stringify(blackbox(v1))));
   },
-  64_000_00,
+  24_000_00,
+  v1.length << 1,
 );
 
 bench(
   "Deserialize Alphabet",
   () => {
-    inline.always(JSON.parse<string>(v2));
+    blackbox(inline.always(JSON.parse<string>(blackbox(v2))));
   },
-  64_000_00,
+  24_000_00,
+  v2.length << 1,
 );
+
+function blackbox<T>(value: T): T {
+  store<T>(blackBoxArea, value);
+  return load<T>(blackBoxArea);
+}

package/assembly/__benches__/lib/bench.ts

@@ -1,20 +1,32 @@
-export function bench(description: string, routine: () => void, ops: u64 = 1_000_000): void {
+export function bench(description: string, routine: () => void, ops: u64 = 1_000_000, bytesPerOp: u64 = 0): void {
   console.log(" - Benchmarking " + description);
+
   let warmup = ops / 10;
   while (--warmup) {
     routine();
   }
-  const start = Date.now();
+
+  const start = performance.now();
+
   let count = ops;
-  while (count != 0) {
+  while (count--) {
     routine();
-    count--;
   }
-  const elapsed = Date.now() - start;
 
-  let opsPerSecond = (ops * 1000) / elapsed;
+  const end = performance.now();
+  const elapsed = Math.max(1, end - start);
+
+  const opsPerSecond = f64(ops * 1000) / elapsed;
+
+  let log = `   Completed benchmark in ${formatNumber(u64(Math.round(elapsed)))}ms at ${formatNumber(u64(Math.round(opsPerSecond)))} ops/s`;
+
+  if (bytesPerOp > 0) {
+    const totalBytes = bytesPerOp * ops;
+    const mbPerSec = f64(totalBytes) / (elapsed / 1000) / (1000 * 1000);
+    log += ` @ ${formatNumber(u64(Math.round(mbPerSec)))}MB/s`;
+  }
 
-  console.log(`   Completed benchmark in ${formatNumber(elapsed)}ms at ${formatNumber(opsPerSecond)} ops/s\n`);
+  console.log(log + "\n");
 }
 
 function formatNumber(n: u64): string {

package/assembly/__tests__/arbitrary.spec.ts

@@ -8,6 +8,22 @@ describe("Should serialize arbitrary types", () => {
   expect(JSON.stringify(JSON.Value.from(true))).toBe("true");
   expect(JSON.stringify(JSON.Value.from(new Vec3()))).toBe('{"x":1.0,"y":2.0,"z":3.0}');
   expect(JSON.stringify([JSON.Value.from("string"), JSON.Value.from(true), JSON.Value.from(3.14), JSON.Value.from(new Vec3())])).toBe('["string",true,3.14,{"x":1.0,"y":2.0,"z":3.0}]');
+
+  const o = new JSON.Obj();
+  o.set("schema", "http://json-schema.org/draft-07/schema#");
+  o.set("additionalProperties", false);
+  o.set("properties", new JSON.Obj());
+  o.get("properties")!.as<JSON.Obj>().set("duration", new JSON.Obj());
+  o.get("properties")!.as<JSON.Obj>().get("duration")!.as<JSON.Obj>().set("default", 10.0);
+  o.get("properties")!.as<JSON.Obj>().get("duration")!.as<JSON.Obj>().set("description", "Duration of the operation in seconds");
+  o.get("properties")!.as<JSON.Obj>().get("duration")!.as<JSON.Obj>().set("type", "number");
+  o.get("properties")!.as<JSON.Obj>().set("steps", new JSON.Obj());
+  o.get("properties")!.as<JSON.Obj>().get("steps")!.as<JSON.Obj>().set("default", 5.0);
+  o.get("properties")!.as<JSON.Obj>().get("steps")!.as<JSON.Obj>().set("description", "Number of steps in the operation");
+  o.get("properties")!.as<JSON.Obj>().get("steps")!.as<JSON.Obj>().set("type", "number");
+  o.set("type", "object");
+
+  expect(o.toString()).toBe('{"schema":"http://json-schema.org/draft-07/schema#","additionalProperties":false,"properties":{"duration":{"default":10.0,"description":"Duration of the operation in seconds","type":"number"},"steps":{"default":5.0,"description":"Number of steps in the operation","type":"number"}},"type":"object"}');
 });
 
 describe("Should deserialize arbitrary types", () => {

package/assembly/__tests__/enum.spec.ts

@@ -0,0 +1,35 @@
+import { JSON } from "..";
+import { describe, expect } from "./lib";
+
+enum Enum1 {
+  Zero = 0,
+  One = 1,
+  Two = 2,
+  Three = 3,
+}
+
+
+@json
+class DataWithEnum {
+  v: Enum1 = Enum1.One;
+  constructor(v: Enum1) {
+    this.v = v;
+  }
+}
+
+describe("Should serialize enums", () => {
+  expect(JSON.stringify<Enum1>(Enum1.One)).toBe("1");
+  expect(JSON.stringify<Enum1>(Enum1.Zero)).toBe("0");
+  expect(JSON.stringify<DataWithEnum>(new DataWithEnum(Enum1.Two))).toBe('{"v":2}');
+});
+
+describe("Should deserialize enums", () => {
+  const date1 = JSON.parse<Enum1>("2");
+  expect(date1).toBe(Enum1.Two);
+
+  const date2 = JSON.parse<Enum1>("0");
+  expect(date2).toBe(Enum1.Zero);
+
+  const date3 = JSON.parse<DataWithEnum>('{"v":3}');
+  expect(date3.v).toBe(Enum1.Three);
+});

package/assembly/deserialize/simd/string.ts

@@ -10,14 +10,13 @@ import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables
 // todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
 export function deserializeString_SIMD(srcStart: usize, srcEnd: usize, dst: usize): usize {
   const SPLAT_92 = i16x8.splat(92); /* \ */
-  let src_ptr = srcStart + 2;
+  srcStart += 2;
+  srcEnd -= 2;
   let dst_ptr = changetype<usize>(dst);
+  const src_end_15 = srcEnd - 15;
 
-  const src_end = srcEnd - 2;
-  const src_end_15 = src_end - 15;
-
-  while (src_ptr < src_end_15) {
-    const block = v128.load(src_ptr);
+  while (srcStart < src_end_15) {
+    const block = v128.load(srcStart);
     v128.store(dst_ptr, block);
 
     const backslash_indices = i16x8.eq(block, SPLAT_92);
@@ -26,7 +25,7 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize, dst: usiz
     while (mask != 0) {
       const lane_index = ctz(mask) << 1;
       const dst_offset = dst_ptr + lane_index;
-      const src_offset = src_ptr + lane_index;
+      const src_offset = srcStart + lane_index;
       const code = load<u16>(src_offset, 2);
 
       mask &= mask - 1;
@@ -48,7 +47,7 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize, dst: usiz
         v128.store(dst_offset, v128.load(src_offset, 4), 2);
         if (lane_index >= 6) {
           const bytes_left = lane_index - 4;
-          src_ptr += bytes_left;
+          srcStart += bytes_left;
           dst_ptr += bytes_left;
           // console.log("  e: " + (bytes_left).toString())
         }
@@ -59,25 +58,25 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize, dst: usiz
         v128.store(dst_offset, v128.load(src_offset, 4), 2);
         // console.log("Escaped:");
         if (lane_index == 14) {
-          src_ptr += 2;
+          srcStart += 2;
         } else {
           dst_ptr -= 2;
         }
       }
     }
 
-    src_ptr += 16;
+    srcStart += 16;
     dst_ptr += 16;
 
-    // console.log("src: " + (src_ptr - changetype<usize>(src)).toString());
+    // console.log("src: " + (srcStart - changetype<usize>(src)).toString());
     // console.log("dst: " + (dst_ptr - dst).toString());
   }
-  while (src_ptr < src_end) {
-    let code = load<u16>(src_ptr);
+  while (srcStart < srcEnd) {
+    let code = load<u16>(srcStart);
     if (code == BACK_SLASH) {
-      code = load<u16>(DESERIALIZE_ESCAPE_TABLE + load<u8>(src_ptr, 2));
-      if (code == 117 && load<u32>(src_ptr, 4) == 3145776) {
-        const block = load<u32>(src_ptr, 8);
+      code = load<u16>(DESERIALIZE_ESCAPE_TABLE + load<u8>(srcStart, 2));
+      if (code == 117 && load<u32>(srcStart, 4) == 3145776) {
+        const block = load<u32>(srcStart, 8);
         const codeA = block & 0xffff;
         const codeB = (block >> 16) & 0xffff;
         const escapedA = load<u8>(ESCAPE_HEX_TABLE + codeA);
@@ -85,16 +84,16 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize, dst: usiz
         const escaped = (escapedA << 4) + escapedB;
         store<u16>(dst_ptr, escaped);
         dst_ptr += 2;
-        src_ptr += 12;
+        srcStart += 12;
       } else {
         store<u16>(dst_ptr, code);
         dst_ptr += 2;
-        src_ptr += 4;
+        srcStart += 4;
       }
     } else {
       store<u16>(dst_ptr, code);
       dst_ptr += 2;
-      src_ptr += 2;
+      srcStart += 2;
     }
   }
 

package/assembly/deserialize/simple/object.ts

@@ -3,6 +3,10 @@ import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRA
 import { isSpace } from "../../util";
 import { ptrToStr } from "../../util/ptrToStr";
 import { deserializeArbitrary } from "./arbitrary";
+import { deserializeArray } from "./array";
+import { deserializeBoolean } from "./bool";
+import { deserializeFloat } from "./float";
+import { deserializeString } from "./string";
 
 export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): JSON.Obj {
   const out = changetype<JSON.Obj>(dst || changetype<usize>(new JSON.Obj()));
@@ -48,8 +52,8 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
         while (srcStart < srcEnd) {
           const code = load<u16>(srcStart);
           if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
-            // console.log("Value (string): " + ptrToStr(lastIndex, srcStart + 2));
-            out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart + 2, dst));
+            // console.log("Value (string):-" + deserializeString(lastIndex, srcStart + 2, 0) + "-");
+            out.set(ptrToStr(keyStart, keyEnd), deserializeString(lastIndex, srcStart + 2, 0));
             // while (isSpace(load<u16>(srcStart))) srcStart += 2;
             srcStart += 4;
             // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
@@ -65,7 +69,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           const code = load<u16>(srcStart);
           if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
             // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
-            out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, srcStart, dst));
+            out.set(ptrToStr(keyStart, keyEnd), deserializeFloat<f64>(lastIndex, srcStart));
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -88,7 +92,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           } else if (code == BRACE_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
-              out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, (srcStart += 2), dst));
+              out.set(ptrToStr(keyStart, keyEnd), deserializeObject(lastIndex, (srcStart += 2), 0));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>(srcStart))) {
@@ -108,7 +112,7 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
           if (code == BRACKET_RIGHT) {
             if (--depth == 0) {
               // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
-              out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(lastIndex, (srcStart += 2), dst));
+              out.set(ptrToStr(keyStart, keyEnd), deserializeArray<JSON.Value[]>(lastIndex, (srcStart += 2), 0));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>((srcStart += 2)))) {
@@ -122,7 +126,8 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
       } else if (code == CHAR_T) {
         if (load<u64>(srcStart) == 28429475166421108) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
-          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(srcStart, (srcStart += 8), dst));
+          out.set(ptrToStr(keyStart, keyEnd), true);
+          srcStart += 8;
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -133,7 +138,8 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
       } else if (code == CHAR_F) {
         if (load<u64>(srcStart, 2) == 28429466576093281) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
-          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(srcStart, (srcStart += 10), dst));
+          out.set(ptrToStr(keyStart, keyEnd), false);
+          srcStart += 10;
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -144,7 +150,8 @@ export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): J
       } else if (code == CHAR_N) {
         if (load<u64>(srcStart) == 30399761348886638) {
           // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
-          out.set(ptrToStr(keyStart, keyEnd), deserializeArbitrary(srcStart, (srcStart += 8), dst));
+          out.set(ptrToStr(keyStart, keyEnd), JSON.Value.from<usize>(0));
+          srcStart += 8;
           // while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */
           // }

package/assembly/index.ts

@@ -27,6 +27,8 @@ 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 { deserializeString_SIMD } from "./deserialize/simd/string";
 
 /**
  * Offset of the 'storage' property in the JSON.Value class.
@@ -112,11 +114,11 @@ export namespace JSON {
       //   bs.setBuffer(oldBuf);
       //   return changetype<string>(newBuf);
       // }
-      // if (ASC_FEATURE_SIMD) {
-      //   serializeString_SIMD(data as string);
-      // } else {
-      serializeString(data as string);
-      // }
+      if (ASC_FEATURE_SIMD) {
+        serializeString_SIMD(data as string);
+      } else {
+        serializeString(data as string);
+      }
       return bs.out<string>();
       // @ts-ignore: Supplied by transform
     } else if (isDefined(data.__SERIALIZE)) {
@@ -179,7 +181,7 @@ export namespace JSON {
     } else if (isString<T>()) {
       if (dataSize < 4) throw new Error("Cannot parse data as string because it was formatted incorrectly!");
       // if (ASC_FEATURE_SIMD) {
-      // // @ts-ignore
+      //   // @ts-ignore
       //   return changetype<string>(deserializeString_SIMD(dataPtr, dataPtr + dataSize, __new(dataSize - 4, idof<string>())));
       // } else {
       // @ts-ignore
@@ -258,6 +260,8 @@ export namespace JSON {
     }
   }
 
+
+  @final
   export class Value {
     static METHODS: Map<u32, u32> = new Map<u32, u32>();
     public type: i32;
@@ -332,7 +336,7 @@ export namespace JSON {
         this.type = JSON.Types.Struct;
         store<T>(changetype<usize>(this), value, STORAGE);
         // @ts-ignore: supplied by transform
-      } else if (isDefined(value.__SERIALIZE)) {
+      } 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);
@@ -417,14 +421,18 @@ export namespace JSON {
         }
       }
     }
+
+
+    @unsafe private __visit(cookie: u32): void {
+      if (this.type >= JSON.Types.String) {
+        __visit(load<usize>(changetype<usize>(this), STORAGE), cookie);
+      }
+    }
   }
 
   export class Obj {
-    // When accessing stackSize, subtract 2
-    // @ts-ignore: type
-    private stackSize: u32 = 6;
     // @ts-ignore: type
-    private storage: Map<string, JSON.Value> = new Map<string, JSON.Value>();
+    storage: Map<string, JSON.Value> = new Map<string, JSON.Value>();
 
     constructor() {}
 
@@ -435,7 +443,7 @@ export namespace JSON {
 
     // @ts-ignore: decorator
     @inline set<T>(key: string, value: T): void {
-      if (!this.storage.has(key)) this.stackSize += bytes(key) + 8;
+      // if (!this.storage.has(key)) this.stackSize += bytes(key) + 8;
       this.storage.set(key, JSON.Value.from<T>(value));
     }
 
@@ -473,7 +481,7 @@ export namespace JSON {
     // @ts-ignore: decorator
     @inline static from<T>(value: T): JSON.Obj {
       if (value instanceof JSON.Obj) return value;
-      const out = changetype<JSON.Obj>(__new(offsetof<JSON.Obj>(), idof<JSON.Obj>()));
+      const out = new JSON.Obj();
 
       if (value instanceof Map) {
       }
@@ -542,7 +550,11 @@ export namespace JSON {
       store<u64>(bs.offset, 30399761348886638);
       bs.offset += 8;
     } else if (isString<nonnull<T>>()) {
-      serializeString(src as string);
+      if (ASC_FEATURE_SIMD) {
+        serializeString_SIMD(src as string);
+      } else {
+        serializeString(src as string);
+      }
       // @ts-ignore: Supplied by transform
     } else if (isDefined(src.__SERIALIZE_CUSTOM)) {
       // @ts-ignore
@@ -714,12 +726,12 @@ export namespace JSON {
         //   bs.setBuffer(oldBuf);
         //   return changetype<string>(newBuf);
         // }
-        // if (ASC_FEATURE_SIMD) {
-        //   serializeString_SIMD(data as string);
-        // } else {
-        bs.saveState();
-        serializeString(data as string);
-        // }
+        if (ASC_FEATURE_SIMD) {
+          serializeString_SIMD(data as string);
+        } else {
+          bs.saveState();
+          serializeString(data as string);
+        }
         return bs.cpyOut<string>();
         // @ts-ignore: Supplied by transform
       } else if (isDefined(data.__SERIALIZE)) {

package/assembly/serialize/simd/string.ts

@@ -9,11 +9,11 @@ import { bytes } from "../../util";
  * @param srcEnd pointer to end serialization at
  */
 export function serializeString_SIMD(src: string): void {
+  const U00_MARKER = 13511005048209500;
   const SPLAT_34 = i16x8.splat(34); /* " */
   const SPLAT_92 = i16x8.splat(92); /* \ */
 
   const SPLAT_32 = i16x8.splat(32); /* [ESC] */
-  const SPLAT_0 = i16x8.splat(0); /* 0 */
 
   const srcSize = bytes(src);
   let srcStart = changetype<usize>(src);
@@ -27,6 +27,7 @@ export function serializeString_SIMD(src: string): void {
 
   while (srcStart <= srcEnd16) {
     const block = v128.load(srcStart);
+
     v128.store(bs.offset, block);
 
     const backslash_indices = i16x8.eq(block, SPLAT_92);
@@ -38,21 +39,20 @@ export function serializeString_SIMD(src: string): void {
 
     while (mask != 0) {
       const lane_index = ctz(mask) << 1;
-      const dst_offset = bs.offset + lane_index;
       const src_offset = srcStart + lane_index;
       const code = load<u16>(src_offset) << 2;
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + code);
-
       mask &= mask - 1;
-
       if ((escaped & 0xffff) != BACK_SLASH) {
         bs.growSize(10);
-        store<u64>(dst_offset, 13511005048209500);
+        const dst_offset = bs.offset + lane_index;
+        store<u64>(dst_offset, U00_MARKER);
         store<u32>(dst_offset, escaped, 8);
         v128.store(dst_offset, v128.load(src_offset, 2), 12);
         bs.offset += 10;
       } else {
         bs.growSize(2);
+        const dst_offset = bs.offset + lane_index;
         store<u32>(dst_offset, escaped);
         v128.store(dst_offset, v128.load(src_offset, 2), 4);
         bs.offset += 2;
@@ -63,101 +63,13 @@ export function serializeString_SIMD(src: string): void {
     bs.offset += 16;
   }
 
-  const rem = srcEnd - srcStart;
-  if (rem & 8) {
-    const block = v128.load64_zero(srcStart);
-    v128.store64_lane(bs.offset, block, 0);
-
-    const backslash_indices = i16x8.eq(block, SPLAT_92);
-    const quote_indices = i16x8.eq(block, SPLAT_34);
-    const escape_indices = i16x8.lt_u(block, SPLAT_32);
-    const zero_indices = i16x8.eq(block, SPLAT_0);
-    const sieve = v128.and(v128.or(v128.or(backslash_indices, quote_indices), escape_indices), v128.not(zero_indices));
-
-    let mask = i16x8.bitmask(sieve);
-    while (mask != 0) {
-      let lane_index = ctz(mask) << 1;
-      const dst_offset = bs.offset + lane_index;
-      const src_offset = srcStart + lane_index;
-      const code = load<u16>(src_offset) << 2;
-      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + code);
-      mask &= mask - 1;
-
-      if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.growSize(10);
-        store<u64>(dst_offset, 13511005048209500);
-        store<u32>(dst_offset, escaped, 8);
-        while (lane_index < 6) {
-          store<u8>(bs.offset + lane_index, load<u8>(srcStart + lane_index, 2), 12);
-          lane_index += 2;
-        }
-        bs.offset += 10;
-      } else {
-        bs.growSize(2);
-        store<u32>(dst_offset, escaped);
-
-        while (lane_index < 6) {
-          store<u8>(bs.offset + lane_index, load<u8>(srcStart + lane_index, 2), 4);
-          lane_index += 2;
-        }
-        bs.offset += 2;
-      }
-    }
-
-    bs.offset += 8;
-    srcStart += 8;
-  }
-  if (rem & 4) {
-    const block = load<u32>(srcStart);
-    const codeA = block & 0xffff;
-    const codeB = (block >> 16) & 0xffff;
-
-    if (codeA == 92 || codeA == 34 || codeA < 32) {
-      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (codeA << 2));
-
-      if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.growSize(10);
-        store<u64>(bs.offset, 13511005048209500);
-        store<u32>(bs.offset, escaped, 8);
-        bs.offset += 12;
-      } else {
-        bs.growSize(2);
-        store<u32>(bs.offset, escaped);
-        bs.offset += 4;
-      }
-    } else {
-      store<u16>(bs.offset, codeA);
-      bs.offset += 2;
-    }
-
-    if (codeB == 92 || codeB == 34 || codeB < 32) {
-      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (codeB << 2));
-
-      if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.growSize(10);
-        store<u64>(bs.offset, 13511005048209500);
-        store<u32>(bs.offset, escaped, 8);
-        bs.offset += 12;
-      } else {
-        bs.growSize(2);
-        store<u32>(bs.offset, escaped);
-        bs.offset += 4;
-      }
-    } else {
-      store<u16>(bs.offset, codeB);
-      bs.offset += 2;
-    }
-
-    srcStart += 4;
-  }
-  if (rem & 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));
-
       if ((escaped & 0xffff) != BACK_SLASH) {
         bs.growSize(10);
-        store<u64>(bs.offset, 13511005048209500);
+        store<u64>(bs.offset, U00_MARKER);
         store<u32>(bs.offset, escaped, 8);
         bs.offset += 12;
       } else {
@@ -169,6 +81,7 @@ export function serializeString_SIMD(src: string): void {
       store<u16>(bs.offset, code);
       bs.offset += 2;
     }
+    srcStart += 2;
   }
 
   store<u8>(bs.offset, 34); /* " */