json-as 0.7.0 → 0.7.2

package/assembly/__tests__/as-json.spec.ts

@@ -15,7 +15,6 @@ function canSer<T>(data: T, toBe: string): void {
   expect(serialized).toBe(toBe);
 }
 
-// @ts-ignore
 @json
 class Map4 {
   a: string;
@@ -24,7 +23,6 @@ class Map4 {
   d: string;
 }
 
-// @ts-ignore
 @json
 class Vec3 {
   x: f64;
@@ -32,7 +30,6 @@ class Vec3 {
   z: f64;
 }
 
-// @ts-ignore
 @json
 class Player {
   firstName: string;
@@ -179,7 +176,6 @@ describe("Ser externals", () => {
   })
 });
 
-// @ts-ignore
 @json
 class HttpResp {
   statusCode: number;
@@ -202,4 +198,148 @@ describe("Deser externals", () => {
         body: '{\n  "args": {},\n  "headers": {\n    "content-length": "0",\n    "accept": "*/*" \n}}'
       })
   })
-});
+});
+
+describe("Ser/de Maps", () => {
+  it("should serialize Map<string, string>", () => {
+    const m = new Map<string, string>();
+    m.set("a", "x");
+    m.set("b", "y");
+    m.set("c", "z");
+    canSer(m, '{"a":"x","b":"y","c":"z"}');
+  });
+  it("should serialize Map<string, string | null>", () => {
+    const m = new Map<string, string | null>();
+    m.set("a", "x");
+    m.set("b", "y");
+    m.set("c", null);
+    canSer(m, '{"a":"x","b":"y","c":null}');
+  });
+  it("should serialize Map<string, string[]]>", () => {
+    const m = new Map<string, string[]>();
+    m.set("a", ["a1", "a2", "a3"]);
+    m.set("b", ["b1", "b2", "b3"]);
+    m.set("c", ["c1", "c2", "c3"]);
+    canSer(m, '{"a":["a1","a2","a3"],"b":["b1","b2","b3"],"c":["c1","c2","c3"]}');
+  });
+  it("should serialize Map<string, u32>", () => {
+    const m = new Map<string, u32>();
+    m.set("a", 1);
+    m.set("b", 2);
+    m.set("c", 3);
+    canSer(m, '{"a":1,"b":2,"c":3}');
+  });
+  it("should serialize Map<string, bool>", () => {
+    const m = new Map<string, bool>();
+    m.set("a", true);
+    m.set("b", false);
+    m.set("c", true);
+    canSer(m, '{"a":true,"b":false,"c":true}');
+  });
+  it("should serialize Map<string, Vec3>", () => {
+    const m = new Map<string, Vec3>();
+    m.set("foo", { x: 1, y: 2, z: 3 });
+    m.set("bar", { x: 11.5, y: 12.5, z: 13.5 });
+    canSer(m, '{"foo":{"x":1.0,"y":2.0,"z":3.0},"bar":{"x":11.5,"y":12.5,"z":13.5}}');
+  });
+
+  it("should deserialize Map<string, string>", () => {
+    const m = new Map<string, string>();
+    m.set("a", "x");
+    m.set("b", "y");
+    m.set("c", "z");
+    canDeser('{"a":"x","b":"y","c":"z"}', m);
+  });
+  it("should deserialize Map<string, string | null>", () => {
+    const m = new Map<string, string | null>();
+    m.set("a", "x");
+    m.set("b", "y");
+    m.set("c", null);
+    canDeser('{"a":"x","b":"y","c":null}', m);
+  });
+  it("should deserialize Map<string, string[]>", () => {
+    const m = new Map<string, string[]>();
+    m.set("a", ["a1", "a2", "a3"]);
+    m.set("b", ["b1", "b2", "b3"]);
+    m.set("c", ["c1", "c2", "c3"]);
+    canDeser('{"a":["a1","a2","a3"],"b":["b1","b2","b3"],"c":["c1","c2","c3"]}', m);
+  });
+  it("should deserialize Map<string, u32>", () => {
+    const m = new Map<string, u32>();
+    m.set("a", 1);
+    m.set("b", 2);
+    m.set("c", 3);
+    canDeser('{"a":1,"b":2,"c":3}', m);
+  });
+  it("should deserialize Map<string, bool>", () => {
+    const m = new Map<string, bool>();
+    m.set("a", true);
+    m.set("b", false);
+    m.set("c", true);
+    canDeser('{"a":true,"b":false,"c":true}', m);
+  });
+  it("should deserialize Map<string, Vec3>", () => {
+    const m = new Map<string, Vec3>();
+    m.set("foo", { x: 1, y: 2, z: 3 });
+    m.set("bar", { x: 11.5, y: 12.5, z: 13.5 });
+    canDeser('{"foo":{"x":1.0,"y":2.0,"z":3.0},"bar":{"x":11.5,"y":12.5,"z":13.5}}', m);
+  });
+
+  it("should serialize Map<u32, bool>", () => {
+    const m = new Map<u32, bool>();
+    m.set(1, true);
+    m.set(2, false);
+    m.set(3, true);
+    canSer(m, '{"1":true,"2":false,"3":true}'); 
+  });
+  it("should deserialize Map<u32, bool>", () => {
+    const m = new Map<u32, bool>();
+    m.set(1, true);
+    m.set(2, false);
+    m.set(3, true);
+    canDeser('{"1":true,"2":false,"3":true}', m); 
+  });
+
+  it("should serialize Map<bool, string>", () => {
+    const m = new Map<bool, string>();
+    m.set(true, "a");
+    m.set(false, "b");
+    canSer(m, '{"true":"a","false":"b"}'); 
+  });
+  it("should deserialize Map<bool, string>", () => {
+    const m = new Map<bool, string>();
+    m.set(true, "a");
+    m.set(false, "b");
+    canDeser('{"true":"a","false":"b"}', m); 
+  });
+
+  it("should serialize Map<string, string>[]", () => {
+    const m1 = new Map<string, string>();
+    m1.set("a", "u");
+    m1.set("b", "v");
+    m1.set("c", "w");
+    
+    const m2 = new Map<string, string>();
+    m2.set("d", "x");
+    m2.set("e", "y");
+    m2.set("f", "z");
+
+    const a = [m1, m2];
+    canSer(a, '[{"a":"u","b":"v","c":"w"},{"d":"x","e":"y","f":"z"}]');
+  });
+  it("should deserialize Map<string, string>[]", () => {
+    const m1 = new Map<string, string>();
+    m1.set("a", "u");
+    m1.set("b", "v");
+    m1.set("c", "w");
+    
+    const m2 = new Map<string, string>();
+    m2.set("d", "x");
+    m2.set("e", "y");
+    m2.set("f", "z");
+
+    const a = [m1, m2];
+    canDeser('[{"a":"u","b":"v","c":"w"},{"d":"x","e":"y","f":"z"}]', a);
+  });
+
+});

package/assembly/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Class decorator that enables the class to be serializable as JSON.
+ */
+declare function json(target: any): void;
+
+/**
+ * Class decorator that enables the class to be serializable as JSON.
+ */
+declare function serializable(target: any): void;
+
+/**
+ * Property decorator that provides an alias name for JSON serialization.
+ */
+declare function alias(name: string): Function;

package/assembly/index.ts

@@ -1 +1,3 @@
+/// <reference path="./index.d.ts" />
+
 export { JSON } from "./src/json";

package/assembly/src/chars.ts

@@ -43,13 +43,21 @@
 // @ts-ignore: Decorator is valid here
 @inline export const nullWord = "null";
 // @ts-ignore: Decorator is valid here
+@inline export const leftBraceWord = "{";
+// @ts-ignore: Decorator is valid here
 @inline export const leftBracketWord = "[";
 // @ts-ignore: Decorator is valid here
 @inline export const emptyArrayWord = "[]";
 // @ts-ignore: Decorator is valid here
+@inline export const colonWord = ":";
+// @ts-ignore: Decorator is valid here
 @inline export const commaWord = ",";
 // @ts-ignore: Decorator is valid here
+@inline export const rightBraceWord = "}";
+// @ts-ignore: Decorator is valid here
 @inline export const rightBracketWord = "]";
+// @ts-ignore: Decorator is valid here
+@inline export const quoteWord = "\"";
 // Escape Codes
 // @ts-ignore: Decorator is valid here
 @inline export const newLineCode = 10;

package/assembly/src/json.ts

@@ -1,28 +1,39 @@
 import { StringSink } from "as-string-sink/assembly";
 import { isSpace } from "util/string";
-import { E_INVALIDDATE } from "util/error";
 import {
-  backSlashCode,
-  commaCode,
-  commaWord,
+  aCode,
   eCode,
   fCode,
+  lCode,
+  nCode,
+  rCode,
+  sCode,
+  tCode,
+  uCode,
+
+  backSlashCode,
+  colonCode,
+  commaCode,
   leftBraceCode,
   leftBracketCode,
-  leftBracketWord,
-  nCode,
-  nullWord,
+  newLineCode,
   quoteCode,
-  rCode,
   rightBraceCode,
   rightBracketCode,
+
+  colonWord,
+  commaWord,
+  quoteWord,
+
+  leftBraceWord,
+  leftBracketWord,
+  rightBraceWord,
   rightBracketWord,
-  tCode,
-  trueWord,
-  uCode,
   emptyArrayWord,
+
+  trueWord,
   falseWord,
-  newLineCode,
+  nullWord,
 } from "./chars";
 import { snip_fast, unsafeCharCodeAt } from "./util";
 import { Virtual } from "as-virtual/assembly";
@@ -47,7 +58,7 @@ export namespace JSON {
     } else if (isBoolean<T>()) {
       return data ? "true" : "false";
     } else if (isNullable<T>() && data == null) {
-      return "null";
+      return nullWord;
       // @ts-ignore
     } else if ((isInteger<T>() || isFloat<T>()) && isFinite(data)) {
       // @ts-ignore
@@ -64,7 +75,7 @@ export namespace JSON {
         return emptyArrayWord;
         // @ts-ignore
       } else if (isString<valueof<T>>()) {
-        let result = "[";
+        let result = leftBracketWord;
         // @ts-ignore
         for (let i = 0; i < data.length - 1; i++) {
           // @ts-ignore
@@ -96,6 +107,20 @@ export namespace JSON {
         result.write(rightBracketWord);
         return result.toString();
       }
+    } else if (data instanceof Map) {
+      let result = new StringSink(leftBraceWord);
+      let keys = data.keys();
+      let values = data.values();
+      for (let i = 0; i < data.size; i++) {
+        result.write(serializeString(keys[i].toString()));
+        result.write(colonWord);
+        result.write(JSON.stringify(values[i]));
+        if (i < data.size - 1) {
+          result.write(commaWord);
+        }
+      }
+      result.write(rightBraceWord);
+      return result.toString();
     } else {
       throw new Error(
         `Could not serialize data of type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
@@ -117,10 +142,10 @@ export namespace JSON {
       out = serializeString(data as string);
       return;
     } else if (isBoolean<T>()) {
-      out = data ? "true" : "false";
+      out = data ? trueWord : falseWord;
       return;
     } else if (isNullable<T>() && data == null) {
-      out = "null";
+      out = nullWord;
       return;
       // @ts-ignore
     } else if ((isInteger<T>() || isFloat<T>()) && isFinite(data)) {
@@ -133,7 +158,7 @@ export namespace JSON {
       out = data.__JSON_Serialize();
       return;
     } else if (data instanceof Date) {
-      out = "\"" + data.toISOString() + "\"";
+      out = quoteWord + data.toISOString() + quoteWord;
       return;
     } else if (isArrayLike<T>()) {
       // @ts-ignore
@@ -142,7 +167,7 @@ export namespace JSON {
         return;
         // @ts-ignore
       } else if (isString<valueof<T>>()) {
-        out = "[";
+        out = leftBracketWord;
         // @ts-ignore
         for (let i = 0; i < data.length - 1; i++) {
           // @ts-ignore
@@ -206,18 +231,18 @@ export namespace JSON {
     } else if (isArrayLike<T>()) {
       // @ts-ignore
       return parseArray<T>(data.trimStart());
-      // @ts-ignore
-    } else if (isNullable<T>() && data == "null") {
+    } else if (isNullable<T>() && data == nullWord) {
       // @ts-ignore
       return null;
       // @ts-ignore
     } else if (isDefined(type.__JSON_Set_Key)) {
       return parseObject<T>(data.trimStart(), initializeDefaultValues);
+    } else if (isMap<T>()) {
+      return parseMap<T>(data.trimStart(), initializeDefaultValues);
     } else if (idof<nonnull<T>>() == idof<Date>()) {
       // @ts-ignore
       return parseDate(data);
     } else {
-      // @ts-ignore
       throw new Error(
         `Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
       );
@@ -229,7 +254,6 @@ export namespace JSON {
 @global @inline function __parseObjectValue<T>(data: string, initializeDefaultValues: boolean): T {
   let type: T;
   if (isString<T>()) {
-    // @ts-ignore
     let result = "";
     let last = 0;
     for (let i = 0; i < data.length; i++) {
@@ -283,18 +307,18 @@ export namespace JSON {
   } else if (isArrayLike<T>()) {
     // @ts-ignore
     return parseArray<T>(data);
-    // @ts-ignore
-  } else if (isNullable<T>() && data == "null") {
+  } else if (isNullable<T>() && data == nullWord) {
     // @ts-ignore
     return null;
     // @ts-ignore
   } else if (isDefined(type.__JSON_Set_Key)) {
     return parseObject<T>(data.trimStart(), initializeDefaultValues);
+  } else if (isMap<T>()) {
+    return parseMap<T>(data.trimStart(), initializeDefaultValues);
   } else if (idof<nonnull<T>>() == idof<Date>()) {
     // @ts-ignore
     return parseDate(data);
   } else {
-    // @ts-ignore
     throw new Error(
       `Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
     );
@@ -306,7 +330,6 @@ export namespace JSON {
   let result = new StringSink('"');
 
   let last: i32 = 0;
-  // @ts-ignore
   for (let i = 0; i < data.length; i++) {
     const char = unsafeCharCodeAt(<string>data, i);
     if (char === 34 || char === 92) {
@@ -344,9 +367,11 @@ export namespace JSON {
       }
     }
   }
-  if (result.length === 1) return '"' + data + '"';
-  else result.write(<string>data, last);
-  result.write("\"");
+  if (result.length === 1) {
+    return quoteWord + data + quoteWord;
+  }
+  result.write(<string>data, last);
+  result.write(quoteWord);
   return result.toString();
 }
 
@@ -410,14 +435,16 @@ export namespace JSON {
       }
     }
   }
-  if ((data.length - 1) > last) result.write(data, last, data.length - 1);
+  if ((data.length - 1) > last) {
+    result.write(data, last, data.length - 1);
+  }
   return result.toString();
 }
 
 // @ts-ignore: Decorator
 @inline function parseBoolean<T extends boolean>(data: string): T {
-  if (data.length > 3 && data.startsWith("true")) return <T>true;
-  else if (data.length > 4 && data.startsWith("false")) return <T>false;
+  if (data.length > 3 && data.startsWith(trueWord)) return <T>true;
+  else if (data.length > 4 && data.startsWith(falseWord)) return <T>false;
   else throw new Error(`JSON: Cannot parse "${data}" as boolean`);
 }
 
@@ -437,13 +464,14 @@ export namespace JSON {
 
 // @ts-ignore: Decorator
 @inline function parseObject<T>(data: string, initializeDefaultValues: boolean): T {
-  let schema: nonnull<T> = changetype<nonnull<T>>(
+  const schema: nonnull<T> = changetype<nonnull<T>>(
     __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
   );
+  
   // @ts-ignore
   if (initializeDefaultValues) schema.__JSON_Initialize();
 
-  let key = Virtual.createEmpty<string>();
+  const key = Virtual.createEmpty<string>();
   let isKey = false;
   let depth = 0;
   let outerLoopIndex = 1;
@@ -519,7 +547,12 @@ export namespace JSON {
           escaping = false;
         }
       }
-    } else if (char == nCode) {
+    } else if (
+      char == nCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === lCode
+    ) {
       // @ts-ignore
       schema.__JSON_Set_Key<Virtual<string>>(key, nullWord, 0, 4, initializeDefaultValues);
       isKey = false;
@@ -534,9 +567,9 @@ export namespace JSON {
       isKey = false;
     } else if (
       char === fCode &&
-      unsafeCharCodeAt(data, ++outerLoopIndex) === "a".charCodeAt(0) &&
-      unsafeCharCodeAt(data, ++outerLoopIndex) === "l".charCodeAt(0) &&
-      unsafeCharCodeAt(data, ++outerLoopIndex) === "s".charCodeAt(0) &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === aCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === sCode &&
       unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
     ) {
       // @ts-ignore
@@ -559,6 +592,156 @@ export namespace JSON {
   return schema;
 }
 
+// @ts-ignore: Decorator
+@inline function parseMap<T extends Map>(data: string, initializeDefaultValues: boolean): T {
+
+  const map: nonnull<T> = changetype<nonnull<T>>(
+    __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
+  );
+  
+  if (!isDefined(map.set)) {
+    return unreachable();
+  }
+
+  const key = Virtual.createEmpty<string>();
+  let isKey = false;
+  let depth = 0;
+  let outerLoopIndex = 1;
+  for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
+    const char = unsafeCharCodeAt(data, outerLoopIndex);
+    if (char === leftBracketCode) {
+      for (
+        let arrayValueIndex = outerLoopIndex;
+        arrayValueIndex < data.length - 1;
+        arrayValueIndex++
+      ) {
+        const char = unsafeCharCodeAt(data, arrayValueIndex);
+        if (char === leftBracketCode) {
+          depth++;
+        } else if (char === rightBracketCode) {
+          depth--;
+          if (depth === 0) {
+            ++arrayValueIndex;
+            map.set(parseMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, arrayValueIndex), initializeDefaultValues));
+            outerLoopIndex = arrayValueIndex;
+            isKey = false;
+            break;
+          }
+        }
+      }
+    } else if (char === leftBraceCode) {
+      for (
+        let objectValueIndex = outerLoopIndex;
+        objectValueIndex < data.length - 1;
+        objectValueIndex++
+      ) {
+        const char = unsafeCharCodeAt(data, objectValueIndex);
+        if (char === leftBraceCode) {
+          depth++;
+        } else if (char === rightBraceCode) {
+          depth--;
+          if (depth === 0) {
+            ++objectValueIndex;
+            map.set(parseMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, objectValueIndex), initializeDefaultValues));
+            outerLoopIndex = objectValueIndex;
+            isKey = false;
+            break;
+          }
+        }
+      }
+    } else if (char === quoteCode) {
+      let escaping = false;
+      for (
+        let stringValueIndex = ++outerLoopIndex;
+        stringValueIndex < data.length - 1;
+        stringValueIndex++
+      ) {
+        const char = unsafeCharCodeAt(data, stringValueIndex);
+        if (char === backSlashCode && !escaping) {
+          escaping = true;
+        } else {
+          if (
+            char === quoteCode && !escaping
+          ) {
+            if (isKey === false) {
+              key.reinst(data, outerLoopIndex, stringValueIndex);
+              isKey = true;
+            } else {              
+              if (isString<valueof<T>>()) {
+                map.set(parseMapKey<indexof<T>>(key), data.slice(outerLoopIndex, stringValueIndex));
+              }
+              isKey = false;
+            }
+            outerLoopIndex = ++stringValueIndex;
+            break;
+          }
+          escaping = false;
+        }
+      }
+    } else if (
+      char == nCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === lCode) {
+      if (isNullable<valueof<T>>()) {
+        map.set(parseMapKey<indexof<T>>(key), null);
+      }
+      isKey = false;
+    } else if (
+      char === tCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === rCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+    ) {
+      if (isBoolean<valueof<T>>()) {
+        map.set(parseMapKey<indexof<T>>(key), true);
+      }
+      isKey = false;
+    } else if (
+      char === fCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === aCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === sCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+    ) {
+      if (isBoolean<valueof<T>>()) {
+        map.set(parseMapKey<indexof<T>>(key), false);
+      }
+      isKey = false;
+    } else if ((char >= 48 && char <= 57) || char === 45) {
+      let numberValueIndex = ++outerLoopIndex;
+      for (; numberValueIndex < data.length; numberValueIndex++) {
+        const char = unsafeCharCodeAt(data, numberValueIndex);
+        if (char === colonCode || char === commaCode || char === rightBraceCode || isSpace(char)) {
+          if (isFloat<valueof<T>>() || isInteger<valueof<T>>()) {
+            map.set(parseMapKey<indexof<T>>(key), parseNumber<valueof<T>>(data.slice(outerLoopIndex - 1, numberValueIndex)));
+          }          
+          outerLoopIndex = numberValueIndex;
+          isKey = false;
+          break;
+        }
+      }
+    }
+  }
+
+  return map;
+}
+
+//@ts-ignore: Decorator
+@inline function parseMapKey<T>(key: Virtual<string>): T {
+  const k = key.copyOut();
+  if (isString<T>()) {
+    return k as T;
+  } else if (isBoolean<T>()) {
+    // @ts-ignore
+    return parseBoolean<T>(k) as T;
+  } else if (isInteger<T>() || isFloat<T>()) {
+    return parseNumber<T>(k);
+  }
+
+  throw new Error(`JSON: Cannot parse JSON object to a Map with a key of type ${nameof<T>()}`);
+}
+
 // @ts-ignore: Decorator
 @inline function parseArray<T extends unknown[]>(data: string): T {
   if (isString<valueof<T>>()) {
@@ -572,7 +755,8 @@ export namespace JSON {
   } else if (isArrayLike<valueof<T>>()) {
     // @ts-ignore
     return parseArrayArray<T>(data);
-    // @ts-ignore
+  } else if (isMap<valueof<T>>()) {
+    return parseObjectArray<T>(data);
   } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
     // We instantiate the required memory for the class and fill it. This is extremely unsafe and uses "a bit of magic".
     const type = changetype<nonnull<valueof<T>>>(
@@ -580,11 +764,10 @@ export namespace JSON {
     );
     // @ts-ignore
     if (isDefined(type.__JSON_Set_Key)) {
-      // @ts-ignore
       return parseObjectArray<T>(data);
     }
-    return unreachable();
   }
+  
   return unreachable();
 }
 
@@ -725,3 +908,9 @@ function parseDate(dateTimeString: string): Date {
   // is globally aliased to wasi_Date (or some other superclass).
   return new Date(d.getTime());
 }
+
+// @ts-ignore: Decorator
+@inline function isMap<T>(): bool {
+  let type = changetype<T>(0);
+  return type instanceof Map;
+}

package/assembly/test.ts

@@ -1,6 +1,5 @@
 import { JSON } from "./src/json";
 
-// @ts-ignore
 @serializable
 class Vec3 {
     x: f64 = 3.4;
@@ -8,7 +7,6 @@ class Vec3 {
     z: f64 = 8.3;
 }
 
-// @ts-ignore
 @serializable
 class Player extends Vec3 {
     @alias("first name")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -10,7 +10,8 @@
     "Derek Barrera",
     "Frankk Taylor",
     "lekiano",
-    "Florian Guitton"
+    "Florian Guitton",
+    "Matt Johnson-Pint"
   ],
   "license": "MIT",
   "scripts": {
@@ -28,18 +29,18 @@
     "prettier": "as-prettier -w ."
   },
   "devDependencies": {
-    "@as-pect/cli": "^8.0.1",
-    "@as-tral/cli": "^2.0.1",
+    "@as-pect/cli": "^8.1.0",
+    "@as-tral/cli": "^3.0.2",
     "@assemblyscript/wasi-shim": "^0.1.0",
     "as-bench": "^0.0.0-alpha",
-    "assemblyscript": "^0.27.18",
+    "assemblyscript": "^0.27.22",
     "assemblyscript-prettier": "^3.0.1",
     "benchmark": "^2.1.4",
     "kati": "^0.6.2",
     "microtime": "^3.1.1",
-    "prettier": "^3.1.0",
+    "prettier": "^3.1.1",
     "tinybench": "^2.5.1",
-    "typescript": "^5.2.2",
+    "typescript": "^5.3.3",
     "visitor-as": "^0.11.4"
   },
   "dependencies": {
@@ -47,6 +48,9 @@
     "as-variant": "^0.4.1",
     "as-virtual": "^0.1.9"
   },
+  "overrides": {
+    "assemblyscript": "$assemblyscript"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/JairusSW/as-json.git"

package/transform/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-as/transform",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "JSON encoder/decoder for AssemblyScript",
   "main": "./lib/index.js",
   "author": "Jairus Tanaka",