json-as 1.1.20 → 1.1.22

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## 2025-09-01 - 1.1.22
+
+- fix: Type aliases should work across files [#154](https://github.com/JairusSW/json-as/issues/154)
+
+## 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

package/README.md

@@ -1,34 +1,6 @@
-<h6 align="center">
-  <pre>
-<span style="font-size: 0.8em;">     ██ ███████  ██████  ███    ██        █████  ███████
-     ██ ██      ██    ██ ████   ██       ██   ██ ██     
-     ██ ███████ ██    ██ ██ ██  ██ █████ ███████ ███████
-██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
- █████  ███████  ██████  ██   ████       ██   ██ ███████
- </span>
-    AssemblyScript - v1.1.20
-  </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 {
@@ -406,19 +378,6 @@ These benchmarks compare this library to JavaScript's native `JSON.stringify` an
 | 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             |
 
-**📌 Insights**
-
-- JSON-AS consistently outperforms JavaScript's native implementation.
-
-- **Serialization Speed:**
-
-  - JSON-AS achieves speeds up to `2,133 MB/s`, significantly faster than JavaScript's peak of `1,416 MB/s`.
-  - Large objects see the biggest improvement, with JSON-AS at `2,074 MB/s` vs. JavaScript’s `749.7 MB/s`.
-
-- **Deserialization Speed:**
-  - JSON-AS reaches `1,986 MB/s`, while JavaScript caps at `1,592 MB/s`.
-  - Small and medium objects see the most significant performance boost overall.
-
 ### 📈 Comparison to v0.9.x version
 
 **Table 1** - _v1.0.0_
@@ -441,12 +400,45 @@ These benchmarks compare this library to JavaScript's native `JSON.stringify` an
 | Medium Object   | 494 bytes  | 522,193 ops/s         | 508,582 ops/s           | 258.0 MB/s           | 251.2 MB/s             |
 | Large Object    | 3374 bytes | 51,229 ops/s          | 65,585 ops/s            | 172.8 MB/s           | 221.3 MB/s             |
 
-**📌 Insights:**
+### Running benchmarks locally
+
+Benchmarks are run directly on top of v8 for more tailored control
+
+1. Download JSVU off of npm
+
+```bash
+npm install jsvu -g
+```
+
+2. Modify your dotfiles to add `~/.jsvu/bin` to `PATH`
+
+```bash
+export PATH="${HOME}/.jsvu/bin:${PATH}"
+```
+
+3. Clone the repository
 
-- Massive performance improvements in JSON-AS `v1.0.0`:
-- Serialization is **2-12x faster** (e.g., Large Object: `2,074 MB/s` vs. `172.8 MB/s`).
-- Deserialization is **2-3x faster** (e.g., Large Object: `1,348 MB/s` vs. `221.3 MB/s`).
-- Vector3 Object serialization improved from `416 MB/s` to `1,357 MB/s`--a **3x benefit** through new code generation techniques.
+```bash
+git clone https://github.com/JairusSW/json-as
+```
+
+4. Install dependencies
+
+```bash
+npm i
+```
+
+5. Run benchmarks for either AssemblyScript or JavaScript
+
+```bash
+./run-bench.as.sh
+```
+
+or
+
+```bash
+./run-bench.js.sh
+```
 
 ## 🔭 What's Next
 

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

@@ -260,6 +260,8 @@ export namespace JSON {
     }
   }
 
+
+  @final
   export class Value {
     static METHODS: Map<u32, u32> = new Map<u32, u32>();
     public type: i32;
@@ -334,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);
@@ -419,16 +421,20 @@ 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() { }
+    constructor() {}
 
     // @ts-ignore: decorator
     @inline get size(): i32 {
@@ -437,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));
     }
 
@@ -475,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) {
       }
@@ -611,7 +617,7 @@ export namespace JSON {
       if (isDefined(type.__DESERIALIZE)) {
         const out = changetype<nonnull<T>>(dst || __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
         // @ts-ignore: Defined by transform
-        if (isNullable<T>() && isDefined(type.__INITIALIZE)) out.__INITIALIZE();
+        if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
         // @ts-ignore: Defined by transform
         return out.__DESERIALIZE(srcStart, srcEnd, out);
       } else if (type instanceof Map) {

package/assembly/serialize/simd/string.ts

@@ -3,14 +3,13 @@ import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { bytes } from "../../util";
 
-const U00_MARKER = 13511005048209500;
-
 /**
  * Serializes strings into their JSON counterparts using SIMD operations
  * @param srcStart pointer to begin serializing at
  * @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); /* \ */
 
@@ -21,7 +20,7 @@ export function serializeString_SIMD(src: string): void {
   const srcEnd = srcStart + srcSize;
   const srcEnd16 = srcEnd - 16;
 
-  bs.proposeSize(srcSize + 40);
+  bs.proposeSize(srcSize + 4);
 
   store<u8>(changetype<usize>(bs.offset), 34); /* " */
   bs.offset += 2;

package/assembly/serialize/simple/arbitrary.ts

@@ -44,6 +44,7 @@ export function serializeArbitrary(src: JSON.Value): void {
       const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
       const ptr = src.get<usize>();
       call_indirect<void>(fn, 0, ptr);
+      break;
     }
   }
 }

package/assembly/serialize/simple/array.ts

@@ -27,7 +27,7 @@ export function serializeArray<T extends any[]>(src: T): void {
 
   const lastBlock = unchecked(src[end]);
   JSON.__serialize<valueof<T>>(lastBlock);
-  bs.growSize(2);
+  // bs.growSize(2);
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/bool.ts

@@ -5,7 +5,7 @@ import { bs } from "../../../lib/as-bs";
  * @returns void
  */
 export function serializeBool(data: bool): void {
-  if (data == true) {
+  if (data === true) {
     bs.proposeSize(8);
     store<u64>(bs.offset, 28429475166421108);
     bs.offset += 8;

package/assembly/serialize/simple/float.ts

@@ -4,5 +4,7 @@ import { dtoa_buffered } from "util/number";
 // @ts-ignore: inline
 @inline export function serializeFloat<T extends number>(data: T): void {
   bs.ensureSize(64);
-  bs.offset += dtoa_buffered(bs.offset, data) << 1;
+  const size = dtoa_buffered(bs.offset, data) << 1;
+  bs.stackSize += size;
+  bs.offset += size;
 }

package/assembly/serialize/simple/integer.ts

@@ -5,8 +5,8 @@ import { itoa_buffered } from "util/number";
 @inline export function serializeInteger<T extends number>(data: T): void {
   bs.ensureSize(sizeof<T>() << 3);
   const bytesWritten = itoa_buffered(bs.offset, data) << 1;
-  bs.offset += bytesWritten;
   bs.growSize(bytesWritten);
+  bs.offset += bytesWritten;
 }
 
 // 32 {"x":,"y":,"z"}

package/assembly/serialize/simple/map.ts

@@ -16,7 +16,7 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
   let keys = src.keys();
   let values = src.values();
 
-  bs.proposeSize(srcSize << 3); // This needs to be predicted better
+  bs.proposeSize(4);
 
   store<u16>(bs.offset, BRACE_LEFT);
   bs.offset += 2;
@@ -37,7 +37,7 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
   store<u16>(bs.offset, COLON);
   bs.offset += 2;
   JSON.__serialize(unchecked(values[srcEnd]));
-  bs.growSize(2);
+  // bs.growSize(2);
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/object.ts

@@ -1,44 +1,46 @@
 import { bs } from "../../../lib/as-bs";
 import { JSON } from "../..";
-import { BRACE_LEFT, BRACE_RIGHT, QUOTE } from "../../custom/chars";
-import { bytes } from "../../util";
+import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
+import { serializeArbitrary } from "./arbitrary";
+import { serializeString } from "./string";
 
-export function serializeObject(data: JSON.Obj): void {
-  if (!data.size) {
+export function serializeObject(src: JSON.Obj): void {
+  const srcSize = src.size;
+  const srcEnd = srcSize - 1;
+
+  if (srcSize == 0) {
     bs.proposeSize(4);
     store<u32>(bs.offset, 8192123);
     bs.offset += 4;
     return;
   }
 
-  bs.proposeSize(load<u32>(changetype<usize>(data), offsetof<JSON.Obj>("stackSize")) - 2);
-  const keys = data.keys();
-  const values = data.values();
-
-  // console.log(" Keys    " + keys.join(" "));
-  // console.log(" Values  " + values.map<string>(v => v.toString()).join(" "))
+  const keys = src.keys();
+  const values = src.values();
 
+  bs.growSize(2);
   store<u16>(bs.offset, BRACE_LEFT);
   bs.offset += 2;
 
-  const firstKey = unchecked(keys[0]);
-  const keySize = bytes(firstKey);
-  store<u16>(bs.offset, QUOTE);
-  memory.copy(bs.offset + 2, changetype<usize>(firstKey), keySize);
-  store<u32>((bs.offset += keySize + 2), 3801122); // ":
-  bs.offset += 4;
-  JSON.__serialize(unchecked(values[0]));
-
-  for (let i = 1; i < keys.length; i++) {
-    const key = unchecked(keys[i]);
-    const keySize = bytes(key);
-    store<u32>(bs.offset, 2228268); // ,"
-    memory.copy(bs.offset + 4, changetype<usize>(key), keySize);
-    store<u32>((bs.offset += keySize + 4), 3801122); // ":
-    bs.offset += 4;
-    JSON.__serialize(unchecked(values[i]));
+  for (let i = 0; i < srcEnd; i++) {
+    serializeString(unchecked(keys[i]));
+    bs.growSize(2);
+    store<u16>(bs.offset, COLON);
+    bs.offset += 2;
+
+    serializeArbitrary(unchecked(values[i]));
+    bs.growSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
   }
 
+  serializeString(unchecked(keys[srcEnd]));
+  bs.growSize(2);
+  store<u16>(bs.offset, COLON);
+  bs.offset += 2;
+  serializeArbitrary(unchecked(values[srcEnd]));
+
+  bs.growSize(2);
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
 }