json-as 1.1.20 → 1.1.21

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # 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

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 {

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) {
       }

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;
 }