json-as 0.9.10 → 0.9.12

package/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [JairusSW]

package/CHANGELOG

@@ -18,6 +18,8 @@ v0.9.8b - Fix #81 - Revert transform
 v0.9.9 - Fix #82 - Initialize maps
 v0.9.9a - Remove extraneous logs from transform
 v0.9.10 - Fix transform type checks. switch to nodekind checks
+v0.9.11 - Remove MpZ--implement custom serializers and deserializers in the works
+v0.9.12 - Add compat with aspect
 
 [UNRELEASED] v1.0.0
  - Allow nullable primitives

package/README.md

@@ -3,7 +3,7 @@
  __|  ||   __||     ||   | | ___ |  _  ||   __|
 |  |  ||__   ||  |  || | | ||___||     ||__   |
 |_____||_____||_____||_|___|     |__|__||_____|
-v0.9.10
+v0.9.11
 </pre>
 </h5>
 

package/as-test.config.json

@@ -0,0 +1,24 @@
+{
+  "input": [
+    "./assembly/__tests__/*.spec.ts"
+  ],
+  "outDir": "./build",
+  "config": "./asconfig.json",
+  "suites": [],
+  "coverage": {
+    "enabled": true,
+    "show": false
+  },
+  "buildOptions": {
+    "args": [],
+    "wasi": true,
+    "parallel": true,
+    "verbose": true
+  },
+  "runOptions": {
+    "runtime": {
+      "name": "wasmtime",
+      "run": "wasmtime <file>"
+    }
+  }
+}

package/assembly/__tests__/test.spec.ts

@@ -5,7 +5,6 @@ import {
   run
 } from "as-test/assembly";
 import { DerivedObject, Null, ObjWithStrangeKey, ObjectWithFloat, OmitIf, Player, Vec3 } from "./types";
-import { MpZ } from "@hypercubed/as-mpz";
 
 describe("Should serialize strings", () => {
 
@@ -51,18 +50,6 @@ describe("Should serialize integers", () => {
 
 });
 
-describe("Should serialize MpZ (Big Int)", () => {
-
-  expect(
-    JSON.stringify<MpZ>(MpZ.from(0))
-  ).toBe("0");
-
-  expect(
-    JSON.stringify<MpZ>(MpZ.from(2).pow(512))
-  ).toBe("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096");
-
-});
-
 describe("Should serialize floats", () => {
 
   expect(
@@ -370,18 +357,6 @@ describe("Should deserialize integers", () => {
 
 });
 
-describe("Should deserialize MpZ (Big Int)", () => {
-
-  expect(
-    JSON.parse<MpZ>("0").toString()
-  ).toBe("0");
-
-  expect(
-    JSON.parse<MpZ>("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096").toString()
-  ).toBe("13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096");
-
-});
-
 describe("Should deserialize floats", () => {
 
   expect(

package/assembly/custom/bs.ts

@@ -0,0 +1,155 @@
+import { dtoa_buffered, itoa_buffered } from "util/number";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+@inline const MAX_LEN: usize = 65536;
+const STORE: usize[] = [];
+let STORE_LEN: usize = 0;
+const CACHE = memory.data(i32(MAX_LEN));
+// Configurable amount of referenceable strings
+let POINTER = changetype<usize>(CACHE);
+@inline const MAX_CACHE = CACHE + MAX_LEN;
+
+export namespace bs {
+    @inline export function write_int<T extends number>(num: T): void {
+        POINTER += itoa_buffered(POINTER, num) << 1;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_int_u<T extends number>(num: T): void {
+        POINTER += itoa_buffered(POINTER, num) << 1;
+    }
+
+    @inline export function write_fl<T extends number>(num: T): void {
+        POINTER += dtoa_buffered(POINTER, num) << 1;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_fl_u<T extends number>(num: T): void {
+        POINTER += dtoa_buffered(POINTER, num) << 1;
+    }
+
+    @inline export function write_b(buf: usize, bytes: usize = changetype<OBJECT>(buf - TOTAL_OVERHEAD).rtSize): void {
+        memory.copy(POINTER, buf, bytes);
+        POINTER += bytes;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_b_u(buf: usize, bytes: usize = changetype<OBJECT>(buf - TOTAL_OVERHEAD).rtSize): void {
+        memory.copy(POINTER, buf, bytes);
+        POINTER += bytes;
+    }
+
+    @inline export function write_s(str: string, bytes: usize = changetype<OBJECT>(changetype<usize>(str) - TOTAL_OVERHEAD).rtSize): void {
+        memory.copy(POINTER, changetype<usize>(str), bytes);
+        POINTER += bytes;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_s_u(str: string, bytes: usize = changetype<OBJECT>(changetype<usize>(str) - TOTAL_OVERHEAD).rtSize): void {
+        memory.copy(POINTER, changetype<usize>(str), bytes);
+        POINTER += bytes;
+    }
+
+    @inline export function write_s_se(str: string, start: usize, end: usize): void {
+        const bytes = end - start;
+        memory.copy(POINTER, changetype<usize>(str) + start, bytes);
+        POINTER += bytes;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_s_se_u(str: string, start: usize, end: usize): void {
+        const bytes = end - start;
+        memory.copy(POINTER, changetype<usize>(str) + start, bytes);
+        POINTER += bytes;
+    }
+
+    @inline export function write_16(char: i32): void {
+        store<u16>(POINTER, char);
+        POINTER += 2;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_16_u(char: i32): void {
+        store<u16>(POINTER, char);
+        //POINTER += 2;
+    }
+
+    @inline export function write_32(chars: i32): void {
+        store<u32>(POINTER, chars);
+        POINTER += 4;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_32_u(chars: i32): void {
+        store<u32>(POINTER, chars);
+        //POINTER += 4;
+    }
+
+    @inline export function write_64(chars: i64): void {
+        store<u64>(POINTER, chars);
+        POINTER += 8;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+
+    @inline export function write_64_u(chars: i64): void {
+        store<u64>(POINTER, chars);
+        POINTER += 8;
+    }
+
+    @inline export function write_128(chars: v128): void {
+        store<v128>(POINTER, chars);
+        POINTER += 16;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_128_u(chars: v128): void {
+        store<v128>(POINTER, chars);
+        //POINTER += 16;
+       //if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function shrink(): void {
+        const len = POINTER - CACHE;
+        STORE_LEN += len;
+        const out = __new(
+            len,
+            idof<ArrayBuffer>()
+        );
+        memory.copy(out, CACHE, len);
+        bs.reset();
+        STORE.push(out);
+    }
+    @inline export function out<T>(): T {
+        const len = POINTER - CACHE;
+        let out = __new(
+            len + STORE_LEN,
+            idof<T>()
+        );
+
+        memory.copy(out, CACHE, len);
+        if (STORE_LEN) {
+            out += len;
+            for (let i = 0; i < STORE.length; i++) {
+                const ptr = changetype<usize>(unchecked(STORE[i]));
+                const storeLen = changetype<OBJECT>(ptr - TOTAL_OVERHEAD).rtSize;
+                memory.copy(out, ptr, storeLen);
+                //__unpin(ptr);
+                out += storeLen;
+            }
+            STORE_LEN = 0;
+        }
+        bs.reset();
+
+        return changetype<T>(out);
+    }
+
+    @inline export function out_u<T>(): T {
+        const len = POINTER - CACHE;
+        const out = __new(
+            len + STORE_LEN,
+            idof<T>()
+        );
+
+        memory.copy(out, CACHE, len);
+        bs.reset();
+
+        return changetype<T>(out);
+    }
+
+    @inline export function _out(out: usize): void {
+        memory.copy(out, CACHE, POINTER - CACHE);
+    }
+    @inline export function reset(): void {
+        POINTER = CACHE;
+    }
+}

package/assembly/{util.ts → custom/util.ts}

@@ -362,3 +362,31 @@ export function containsCodePoint(str: string, code: u32, start: i32, end: i32):
   }
   return false;
 }
+
+export function _intTo16(int: i32): i32 {
+  if (int < 10) {
+    // 0-10
+    return 48 + int;
+  } else {
+    // a-f
+    return 87 + int;
+  }
+}
+
+@inline export function intTo16(int: i32): i32 {
+  const high = int >> 4;
+  const low = int & 0x0F;
+  if (low < 10) {
+    if (high < 10) {
+      return ((48 + low) << 16) | 48 + high;
+    } else {
+      return ((48 + low) << 16) | 87 + high;
+    }
+  } else {
+    if (high < 10) {
+      return ((87 + low) << 16) | 48 + high;
+    } else {
+      return ((87 + low) << 16) | 87 + high;
+    }
+  }
+}

package/assembly/deserialize/array/array.ts

@@ -1,6 +1,6 @@
-import { BRACKET_LEFT, BRACKET_RIGHT } from "../../chars";
+import { BRACKET_LEFT, BRACKET_RIGHT } from "../../custom/chars";
 import { JSON } from "../..";
-import { unsafeCharCodeAt } from "../../util";
+import { unsafeCharCodeAt } from "../../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeArrayArray<T extends unknown[][]>(data: string): T {

package/assembly/deserialize/array/bool.ts

@@ -1,5 +1,5 @@
-import { CHAR_E, CHAR_F, CHAR_T } from "../../chars";
-import { unsafeCharCodeAt } from "../../util";
+import { CHAR_E, CHAR_F, CHAR_T } from "../../custom/chars";
+import { unsafeCharCodeAt } from "../../custom/util";
 import { deserializeBoolean } from "../bool";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/array/float.ts

@@ -1,6 +1,6 @@
 import { isSpace } from "util/string";
-import { unsafeCharCodeAt } from "../../util";
-import { COMMA, BRACKET_RIGHT } from "../../chars";
+import { unsafeCharCodeAt } from "../../custom/util";
+import { COMMA, BRACKET_RIGHT } from "../../custom/chars";
 import { deserializeFloat } from "../float";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/array/integer.ts

@@ -1,6 +1,6 @@
 import { isSpace } from "util/string";
-import { unsafeCharCodeAt } from "../../util";
-import { COMMA, BRACKET_RIGHT } from "../../chars";
+import { unsafeCharCodeAt } from "../../custom/util";
+import { COMMA, BRACKET_RIGHT } from "../../custom/chars";
 import { deserializeInteger } from "../integer";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/array/map.ts

@@ -1,6 +1,6 @@
-import { BRACE_LEFT, BRACE_RIGHT } from "../../chars";
+import { BRACE_LEFT, BRACE_RIGHT } from "../../custom/chars";
 import { JSON } from "../..";
-import { unsafeCharCodeAt } from "../../util";
+import { unsafeCharCodeAt } from "../../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeMapArray<T extends unknown[]>(data: string): T {

package/assembly/deserialize/array/object.ts

@@ -1,6 +1,6 @@
-import { BRACE_LEFT, BRACE_RIGHT } from "../../chars";
+import { BRACE_LEFT, BRACE_RIGHT } from "../../custom/chars";
 import { JSON } from "../..";
-import { unsafeCharCodeAt } from "../../util";
+import { unsafeCharCodeAt } from "../../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeObjectArray<T extends unknown[]>(data: string): T {

package/assembly/deserialize/array/string.ts

@@ -1,5 +1,5 @@
-import { BACK_SLASH, QUOTE } from "../../chars";
-import { unsafeCharCodeAt } from "../../util";
+import { BACK_SLASH, QUOTE } from "../../custom/chars";
+import { unsafeCharCodeAt } from "../../custom/util";
 import { deserializeString } from "../string";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/array.ts

@@ -1,4 +1,4 @@
-import { isMap } from "../util";
+import { isMap } from "../custom/util";
 import { deserializeArrayArray } from "./array/array";
 import { deserializeBooleanArray } from "./array/bool";
 import { deserializeFloatArray } from "./array/float";
@@ -31,8 +31,8 @@ export function deserializeArray<T extends unknown[]>(data: string): T {
         if (isDefined(type.__DESERIALIZE)) {
             return deserializeObjectArray<T>(data);
         }
-        ERROR("Could not parse array of type " + nameof<T>() + "! Make sure to add the @json decorator over classes!");
+        throw new Error("Could not parse array of type " + nameof<T>() + "! Make sure to add the @json decorator over classes!");
     } else {
-        ERROR("Could not parse array of type " + nameof<T>() + "!");
+        throw new Error("Could not parse array of type " + nameof<T>() + "!");
     }
 }

package/assembly/deserialize/bool.ts

@@ -1,5 +1,5 @@
-import { CHAR_F, CHAR_T } from "../chars";
-import { unsafeCharCodeAt } from "../util";
+import { CHAR_F, CHAR_T } from "../custom/chars";
+import { unsafeCharCodeAt } from "../custom/util";
 
 /**
  * Deserialize a string to type boolean

package/assembly/deserialize/integer.ts

@@ -1,4 +1,4 @@
-import { snip_fast } from "../util";
+import { snip_fast } from "../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeInteger<T>(data: string): T {

package/assembly/deserialize/map.ts

@@ -1,5 +1,5 @@
 import { Virtual } from "as-virtual/assembly";
-import { containsCodePoint, unsafeCharCodeAt } from "../util";
+import { containsCodePoint, unsafeCharCodeAt } from "../custom/util";
 import {
     CHAR_A,
     BACK_SLASH,
@@ -18,7 +18,7 @@ import {
     CHAR_S,
     CHAR_T,
     CHAR_U
-} from "../chars";
+} from "../custom/chars";
 import { deserializeBoolean } from "./bool";
 import { JSON } from "..";
 import { deserializeString } from "./string";
@@ -72,8 +72,6 @@ import { deserializeFloat } from "./float";
                     depth--;
                     if (depth === 0) {
                         ++objectValueIndex;
-                        console.log("Index: " + nameof<indexof<T>>());
-                        console.log("Value: " + nameof<valueof<T>>());
                         map.set(deserializeMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, objectValueIndex)));
                         outerLoopIndex = objectValueIndex;
                         isKey = false;
@@ -181,4 +179,4 @@ function deserializeMapKey<T>(key: Virtual<string>): T {
     }
 
     throw new Error(`JSON: Cannot parse JSON object to a Map with a key of type ${nameof<T>()}`);
-}
+}

package/assembly/deserialize/object.ts

@@ -1,5 +1,5 @@
-import {  unsafeCharCodeAt } from "../util";
-import { CHAR_A, BACK_SLASH, COMMA, CHAR_E, CHAR_F, CHAR_L, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, CHAR_R, BRACE_RIGHT, BRACKET_RIGHT, CHAR_S, CHAR_T, CHAR_U } from "../chars";
+import { unsafeCharCodeAt } from "../custom/util";
+import { CHAR_A, BACK_SLASH, COMMA, CHAR_E, CHAR_F, CHAR_L, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, CHAR_R, BRACE_RIGHT, BRACKET_RIGHT, CHAR_S, CHAR_T, CHAR_U } from "../custom/chars";
 import { isSpace } from "util/string";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/string.ts

@@ -13,9 +13,9 @@ import {
     CHAR_T,
     TAB,
     CHAR_U
-} from "../chars";
-import { Sink } from "../sink";
-import { unsafeCharCodeAt } from "../util";
+} from "../custom/chars";
+import { Sink } from "../custom/sink";
+import { unsafeCharCodeAt } from "../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeString(data: string, start: i32 = 0, end: i32 = 0): string {

package/assembly/index.ts

@@ -13,198 +13,14 @@ import { deserializeFloat } from "./deserialize/float";
 import { deserializeObject } from "./deserialize/object";
 import { deserializeMap } from "./deserialize/map";
 import { deserializeDate } from "./deserialize/date";
-import { FALSE_WORD, NULL_WORD, TRUE_WORD } from "./chars";
+import { NULL_WORD } from "./custom/chars";
 import { deserializeInteger } from "./deserialize/integer";
 import { deserializeString } from "./deserialize/string";
-import { Sink } from "./sink";
-import { Variant } from "as-variant/assembly";
-import { MpZ } from "@hypercubed/as-mpz";
-import { serializeMpZ } from "./serialize/mpz";
-import { deserializeMpZ } from "./deserialize/mpz";
-
-/**
- * Offset of the 'storage' property in the JSON.Value class.
- */
-// @ts-ignore: Decorator valid here
-const STORAGE = offsetof<JSON.Value>("storage");
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
  */
 export namespace JSON {
-  /**
- * Enum representing the different types supported by JSON.
- */
-  export enum Types {
-    U8,
-    U16,
-    U32,
-    U64,
-    F32,
-    F64,
-    Bool,
-    String,
-    ManagedString,
-    Struct,
-    ManagedStruct,
-    Array,
-    ManagedArray
-  }
-
-  export class Value {
-    public type: i32;
-    // @ts-ignore: storage is set directly through memory
-    private storage: u64;
-
-    private constructor() { unreachable(); }
-
-    /**
-     * Creates an JSON.Value instance from a given value.
-     * @param value - The value to be encapsulated.
-     * @returns An instance of JSON.Value.
-     */
-    static from<T>(value: T): JSON.Value {
-      if (value instanceof Variant) {
-        // Handle
-      } else if (value instanceof JSON.Value) {
-        return value;
-      }
-      const out = changetype<JSON.Value>(__new(offsetof<JSON.Value>(), idof<JSON.Value>()));
-      out.set<T>(value);
-      return out;
-    }
-
-    /**
-     * Sets the value of the JSON.Value instance.
-     * @param value - The value to be set.
-     */
-    set<T>(value: T): void {
-      if (isBoolean<T>()) {
-        this.type = JSON.Types.Bool;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (value instanceof u8 || value instanceof i8) {
-        this.type = JSON.Types.U8;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (value instanceof u16 || value instanceof i16) {
-        this.type = JSON.Types.U16;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (value instanceof u32 || value instanceof i32) {
-        this.type = JSON.Types.U32;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (value instanceof u64 || value instanceof i64) {
-        this.type = JSON.Types.U64;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (value instanceof f32) {
-        this.type = JSON.Types.F64;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (value instanceof f64) {
-        this.type = JSON.Types.F64;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (isString<T>()) {
-        this.type = JSON.Types.String;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (value instanceof Map) {
-        if (idof<T>() !== idof<Map<string, JSON.Value>>()) {
-          throw new Error("Maps must be of type Map<string, JSON.Value>!");
-        }
-        this.type = JSON.Types.Struct;
-        store<T>(changetype<usize>(this), value, STORAGE);
-        // @ts-ignore: __SERIALIZE is implemented by the transform
-      } else if (isDefined(value.__SERIALIZE)) {
-        this.type = JSON.Types.Struct;
-        store<T>(changetype<usize>(this), value, STORAGE);
-      } else if (isArray<T>()) {
-        // @ts-ignore: T satisfies constraints of any[]
-        this.type = JSON.Types.Array + getArrayDepth<T>(0);
-        store<T>(changetype<usize>(this), value, STORAGE);
-      }
-    }
-
-    /**
-     * Gets the value of the JSON.Value instance.
-     * @returns The encapsulated value.
-     */
-    unwrap<T>(): T {
-      if (isManaged<T>()) {
-        if (this.type !== JSON.Types.Struct) throw new Error("Type mismatch");
-        if (idof<T>() !== load<u32>(changetype<usize>(this.storage), -8)) throw new Error("Type mismatch");
-      }
-      return load<T>(changetype<usize>(this), STORAGE);
-    }
-
-    /**
-     * Gets the value of the JSON.Value instance.
-     * @returns The encapsulated value.
-     */
-    unwrapUnsafe<T>(): T {
-      return load<T>(changetype<usize>(this), STORAGE);
-    }
-
-    /**
-     * Gets the value of the JSON.Value instance.
-     * @returns The encapsulated value.
-     */
-    get<T>(): T {
-      return load<T>(changetype<usize>(this), STORAGE);
-    }
-
-    /**
-     * Gets the value of the JSON.Value instance.
-     * @returns The encapsulated value.
-     */
-    getUnsafe<T>(): T {
-      return load<T>(changetype<usize>(this), STORAGE);
-    }
-
-    /**
-     * Gets the value of the JSON.Value instance.
-     * @returns The encapsulated value.
-     */
-    is<T>(): T {
-      return load<T>(changetype<usize>(this), STORAGE);
-    }
-
-    /**
-     * Gets the value of the JSON.Value instance.
-     * @returns The encapsulated value.
-     */
-    clone<T>(): T {
-      return load<T>(changetype<usize>(this), STORAGE);
-    }
-
-    /**
-     * Converts the JSON.Value to a string representation.
-     * @param useString - If true, treats Buffer as a string.
-     * @returns The string representation of the JSON.Value.
-     */
-    toString(useString: boolean = false): string {
-      switch (this.type) {
-        case JSON.Types.U8: return this.get<u8>().toString();
-        case JSON.Types.U16: return this.get<u16>().toString();
-        case JSON.Types.U32: return this.get<u32>().toString();
-        case JSON.Types.U64: return this.get<u64>().toString();
-        case JSON.Types.String: return "\"" + this.get<string>() + "\"";
-        case JSON.Types.Bool: return this.get<boolean>() ? TRUE_WORD : FALSE_WORD;
-        default: {
-          const arr = this.get<JSON.Value[]>();
-          if (!arr.length) return "[]";
-          const out = Sink.fromString("[");
-          for (let i = 0; i < arr.length - 1; i++) {
-            const element = unchecked(arr[i]);
-            out.write(element.toString(useString));
-            out.write(",");
-          }
-
-          const element = unchecked(arr[arr.length - 1]);
-          out.write(element.toString(useString));
-
-          out.write("]");
-          return out.toString();
-        }
-      }
-    }
-  }
-
   export class Box<T> {
     constructor(public value: T) {}
     @inline static from<T>(value: T): Box<T> {
@@ -236,6 +52,7 @@ export namespace JSON {
       // @ts-ignore
     } else if (isString<nonnull<T>>()) {
       return serializeString(changetype<string>(data));
+      // @ts-ignore: Supplied by trasnform
     } else if (isDefined(data.__SERIALIZE)) {
       // @ts-ignore
       return serializeObject(changetype<nonnull<T>>(data));
@@ -248,8 +65,6 @@ export namespace JSON {
     } else if (data instanceof Map) {
       // @ts-ignore
       return serializeMap(changetype<nonnull<T>>(data));
-    } else if (data instanceof MpZ) {
-      return serializeMpZ(data);
     } else {
       throw new Error(
         `Could not serialize data of type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
@@ -284,16 +99,14 @@ export namespace JSON {
       return deserializeArray<nonnull<T>>(data);
     }
     let type: nonnull<T> = changetype<nonnull<T>>(0);
+    // @ts-ignore: Defined by trasnform
     if (isDefined(type.__DESERIALIZE)) {
       // @ts-ignore
       return deserializeObject<nonnull<T>>(data.trimStart());
     } else if (type instanceof Map) {
       // @ts-ignore
       return deserializeMap<nonnull<T>>(data.trimStart());
-    } else if (type instanceof MpZ) {
-      // @ts-ignore
-      return deserializeMpZ(data);
-    }else if (type instanceof Date) {
+    } else if (type instanceof Date) {
       // @ts-ignore
       return deserializeDate(data);
     } else {