json-as 0.4.1 → 0.4.4

package/README.md

@@ -67,14 +67,44 @@ const data: Player = {
 }
 
 const stringified = JSON.stringify<Player>(data);
-// '{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23}'
+// {
+//  "firstName": "Emmet",
+//  "lastName": "West",
+// "lastActive": [8, 27, 2022],
+//  "age": 23,
+//  "pos": {
+//    "x": -3.4000000953674318,
+//    "y": 1.2000000476837159
+//  }
+// }
 console.log(`Stringified: ${stringified}`);
 
-const parsed = JSON.parse<Player>(stringified)
-// { firstName: "Emmet", lastName: "West", "lastActive": [8,27,2022], age: 23 }
-console.log(`Parsed: ${JSON.stringify(parsed)}`)
+const parsed = JSON.parse<Player>(stringified);
+// Player {
+//  firstName: "Emmet",
+//  lastName: "West",
+//  lastActive: [8, 27, 2022],
+//  age: 23,
+//  pos: {
+//    x: -3.4000000953674318,
+//    y: 1.2000000476837159
+//  }
+// }
+console.log(`Parsed: ${JSON.stringify(parsed)}`);
 ```
 
+## FAQ
+
+- Does it support the full JSON spec?
+  Yes, as-json supports the full JSON specification and trys to mimic the JSON API as much as possible
+- What are the differences between as-json and the JSON API?
+  The main difference between as-json and the JSON API is the ability to create new fields in objects during runtime. Since classes are static, Map ser/de support will be added soon allowing the user to parse and stringify dynamic objects and their properties
+- Does this support nested structures?
+  Yes, as-json supports nested structures
+- Does this support whitespace?
+  Yes, as-json supports whitespace although the current implementation is deathly slow
+- How fast is it?
+  Really fast. For example, here are some benchmarks for ser/de a Vec2 with as-json
 ## Issues
 
 Please submit an issue to https://github.com/JairusSW/as-json/issues if you find anything wrong with this library

package/as-pect.asconfig.json

@@ -0,0 +1,24 @@
+{
+  "targets": {
+    "coverage": {
+      "lib": ["./node_modules/@as-covers/assembly/index.ts"],
+      "transform": ["@as-covers/transform", "@as-pect/transform"]
+    },
+    "noCoverage": {
+      "transform": ["@as-pect/transform"]
+    }
+  },
+  "options": {
+    "exportMemory": true,
+    "outFile": "output.wasm",
+    "textFile": "output.wat",
+    "bindings": "raw",
+    "exportStart": "_start",
+    "exportRuntime": true,
+    "use": ["RTRACE=1"],
+    "debug": true,
+    "exportTable": true
+  },
+  "extends": "./asconfig.json",
+  "entries": ["./@as-pect/assembly/assembly/index.ts"]
+}

package/as-pect.config.js

@@ -0,0 +1,30 @@
+export default {
+  /**
+   * A set of globs passed to the glob package that qualify typescript files for testing.
+   */
+  entries: ["assembly/__tests__/**/*.spec.ts"],
+  /**
+   * A set of globs passed to the glob package that quality files to be added to each test.
+   */
+  include: ["assembly/__tests__/**/*.include.ts"],
+  /**
+   * A set of regexp that will disclude source files from testing.
+   */
+  disclude: [/node_modules/],
+  /**
+   * Add your required AssemblyScript imports here.
+   */
+  async instantiate(memory, createImports, instantiate, binary) {
+    let instance; // Imports can reference this
+    const myImports = {
+      // put your web assembly imports here, and return the module
+    };
+    return instantiate(binary, createImports(myImports));
+  },
+  /** Enable code coverage. */
+  // coverage: ["assembly/**/*.ts"],
+  /**
+   * Specify if the binary wasm file should be written to the file system.
+   */
+  outputBinary: false,
+};

package/assembly/__benches__/benchmark.ts

@@ -1,11 +1,11 @@
-import { JSON, parseBooleanArray, parseMap, parseNumberArray } from "..";
+import { JSON } from "..";
 @json
-class Vector {
+class Vec2 {
   x: f32;
   y: f32;
 }
 
-const vec: Vector = blackbox<Vector>({
+const vec: Vec2 = blackbox<Vec2>({
   x: 0.0,
   y: 0.0,
 });
@@ -26,7 +26,7 @@ bench("Stringify Float", () => {
   blackbox(JSON.stringify(blackbox(3.14)));
 });
 
-bench("Stringify Vector", () => {
+bench("Stringify Object (Vec2)", () => {
   blackbox(JSON.stringify(vec));
 });
 
@@ -50,20 +50,20 @@ bench("Parse Float", () => {
   blackbox(JSON.parse<f32>(blackbox("3.14")));
 });
 
-bench("Parse Vector", () => {
-  blackbox(parseMap<Map<string, f32>>(blackbox('{"x":0.0,"y":0.0}')));
+bench("Parse Object (Vec2)", () => {
+  blackbox(JSON.parse<Vec2>(blackbox('{"x":0.0,"y":0.0}')));
 });
 
 bench("Parse Boolean Array", () => {
   blackbox(
-    parseBooleanArray<boolean[]>(blackbox("[true,false,true,false,true]"))
+    JSON.parse<boolean[]>(blackbox("[true,false,true,false,true]"))
   );
 });
 
 bench("Parse Integer Array", () => {
-  blackbox(parseNumberArray<u32[]>(blackbox("[1,2,3,4,5]")));
+  blackbox(JSON.parse<u32[]>(blackbox("[1,2,3,4,5]")));
 });
 
 bench("Parse Float Array", () => {
-  blackbox(parseNumberArray<f32[]>(blackbox("[1.0,2.0,3.0,4.0,5.0]")));
+  blackbox(JSON.parse<f32[]>(blackbox("[1.0,2.0,3.0,4.0,5.0]")));
 });

package/assembly/__tests__/as-pect.d.ts

@@ -0,0 +1 @@
+/// <reference types="@as-pect/assembly/types/as-pect" />

package/assembly/__tests__/example.spec.ts

@@ -0,0 +1,40 @@
+import { JSON } from "../"
+describe("JSON Stringify Test", () => {
+  it("Stringify String", () => {
+    expect<string>().toBe(42, "19 + 23 is 42");
+  });
+
+  it("should be the same reference", () => {
+    let ref = new Vec3();
+    expect<Vec3>(ref).toBe(ref, "Reference Equality");
+  });
+
+  it("should perform a memory comparison", () => {
+    let a = new Vec3(1, 2, 3);
+    let b = new Vec3(1, 2, 3);
+
+    expect<Vec3>(a).toStrictEqual(
+      b,
+      "a and b have the same values, (discluding child references)",
+    );
+  });
+
+  it("should compare strings", () => {
+    expect<string>("a=" + "200").toBe("a=200", "both strings are equal");
+  });
+
+  it("should compare values", () => {
+    expect<i32>(10).toBeLessThan(200);
+    expect<i32>(1000).toBeGreaterThan(200);
+    expect<i32>(1000).toBeGreaterThanOrEqual(1000);
+    expect<i32>(1000).toBeLessThanOrEqual(1000);
+  });
+
+  it("can log some values to the console", () => {
+    log<string>("Hello world!"); // strings!
+    log<f64>(3.1415); // floats!
+    log<u8>(244); // integers!
+    log<u64>(0xffffffff); // long values!
+    log<ArrayBuffer>(new ArrayBuffer(50)); // bytes!
+  });
+});

package/assembly/chars.ts

@@ -1,5 +1,5 @@
 export const commaCode = ",".charCodeAt(0);
-export const quoteCode = "".charCodeAt(0);
+export const quoteCode = "\"".charCodeAt(0);
 export const backSlashCode = "\\".charCodeAt(0);
 export const leftBraceCode = "{".charCodeAt(0);
 export const rightBraceCode = "}".charCodeAt(0);

package/assembly/index.ts

@@ -10,6 +10,7 @@ import {
   rightBraceCode,
   rightBracketCode
 } from "./chars";
+import { removeWhitespace } from "./util";
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
@@ -26,17 +27,13 @@ export namespace JSON {
    */
   export function stringify<T = Nullable | null>(data: T): string {
     // String
-    if (isString(data)) {
-      return serializeString(<string>data);
+    if (isString<T>()) {
+      return '"' + (<string>data).replaceAll('"', '\\"') + '"';
     }
     // Boolean
-    else if (isBoolean(data)) {
+    else if (isBoolean<T>()) {
       return data ? "true" : "false";
     }
-    // Null
-    else if (isNullable<T>() && data == null) {
-      return "null";
-    }
     // Integers/Floats
     // @ts-ignore
     else if ((isInteger<T>() || isFloat<T>()) && isFinite(data)) {
@@ -46,20 +43,28 @@ export namespace JSON {
     // Class-Based serialization
     // @ts-ignore
     else if (isDefined(data.__JSON_Serialize)) {
-      //@ts-ignore
+      // @ts-ignore
       return data.__JSON_Serialize();
     }
     // ArrayLike
-    else if (isArrayLike(data)) {
+    else if (isArrayLike<T>()) {
       let result = new StringSink("[");
+      // @ts-ignore
       if (data.length == 0) return "[]";
+      // @ts-ignore
       for (let i = 0; i < data.length - 1; i++) {
+        // @ts-ignore
         result.write(stringify(unchecked(data[i])));
         result.write(",");
       }
+      // @ts-ignore
       result.write(stringify(unchecked(data[data.length - 1])));
       result.write("]");
       return result.toString();
+    }
+    // Null
+    else if (isNullable<T>() && data == null) {
+      return "null";
     } else {
       return "null";
     }
@@ -73,6 +78,7 @@ export namespace JSON {
    * @returns T
    */
   export function parse<T = Variant>(data: string): T {
+    data = removeWhitespace(data);
     let type!: T;
     if (isString<T>()) {
       // @ts-ignore
@@ -91,18 +97,20 @@ export namespace JSON {
       const result = new Map<string, string>()
       let lastPos: u32 = 1
       let key: string = ''
-      let instr: u32 = 0
+      let instr: boolean = false
       let char: u32 = 0
       let depth: u32 = 0
       let fdepth: u32 = 0
       for (let i: u32 = 1; i < len; i++) {
-        char = data.charCodeAt(i)
-        if (char === "\"".charCodeAt(0) && data.charCodeAt(i - 1) !== "/".charCodeAt(0)) instr = (instr ? 0 : 1)
-        else if (instr === 0) {
+        char = data.charCodeAt(i);
+        if (instr === false && char === quoteCode) instr = true;
+        else if (instr === true && char === quoteCode && data.charCodeAt(i - 1) !== "/".charCodeAt(0)) instr = false;
+        if (instr === false) {
           if (char === leftBraceCode || char === leftBracketCode) depth++
           if (char === rightBraceCode || char === rightBracketCode) fdepth++
         }
         if (depth !== 0 && depth === fdepth) {
+          //console.log(`Found Struct: ${data.slice(lastPos + 1, i + 1)}`)
           result.set(key, data.slice(lastPos + 1, i + 1))
           // Reset the depth
           depth = 0
@@ -110,19 +118,22 @@ export namespace JSON {
           // Set new lastPos
           lastPos = i + 1
         }
-        if (depth === 0) {
+        if (!instr && depth === 0) {
           if (char === colonCode) {
             key = data.slice(lastPos + 1, i - 1)
+           //console.log(`Found Key: ${data.slice(lastPos + 1, i - 1)}`)
             lastPos = i
-          }
-          else if (char === commaCode) {
+          } else if (char === commaCode) {
+            //console.log(`Found Comma: ${data.slice(lastPos + 1, i)}`)
             if ((i - lastPos) > 0) result.set(key, data.slice(lastPos + 1, i))
             lastPos = i + 1
           }
         }
       }
 
-      if ((len - lastPos) > 0) result.set(key, data.slice(lastPos + 1, len))
+      if ((len - lastPos) > 1 && (len - lastPos) !== 0) {
+        result.set(key, data.slice(lastPos + 1, len))
+      }
       // @ts-ignore
       return schema.__JSON_Deserialize(result)
     } else {
@@ -132,11 +143,7 @@ export namespace JSON {
   }
 }
 
-// @ts-ignore
-@inline
-  function serializeString(data: string): string {
-  return '"' + data.replaceAll('"', '\\"') + '"';
-}
+
 // @ts-ignore
 @inline
   function parseString(data: string): string {
@@ -301,37 +308,4 @@ export namespace JSON {
   return result;
 }
 
-export function parseObject(data: string): void {
-  //const obj = instantiate<T>()
-  const result = new Array<string>();
-  let lastPos: u32 = 0;
-  let char: u32 = 0;
-  let i: u32 = 1;
-  let key: string = "";
-  let isKey: boolean = false;
-  for (; i < u32(data.length - 1); i++) {
-    char = data.charCodeAt(i);
-    if (isKey == false) {
-      if (char == colonCode) {
-        key = data.slice(lastPos + 2, i - 1);
-        //console.log(`Found Key: ${key}`);
-        result.push(key);
-        lastPos = ++i;
-        isKey = true;
-      }
-    } else {
-      if (char == commaCode) {
-        const val = data.slice(lastPos, i);
-        lastPos = i;
-        isKey = false;
-        //console.log(`Found Val: ${val}`)
-        result.push(val);
-      }
-    }
-  }
-  result.push(data.slice(lastPos, data.length - 1));
-  //console.log(stringify(result))
-  //return obj
-}
-
 class Nullable { }

package/assembly/test.ts

@@ -1,11 +1,15 @@
 import "wasi";
 import { JSON } from ".";
+import { removeWhitespace } from "./util";
 
+// @ts-ignore
 @json
 class Vec2 {
   x: f32
   y: f32
 }
+
+// @ts-ignore
 @json
 class Player {
   firstName: string
@@ -27,9 +31,45 @@ const data: Player = {
 }
 
 const stringified = JSON.stringify<Player>(data);
-// '{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23}'
+// {
+//  "firstName": "Emmet",
+//  "lastName": "West",
+// "lastActive": [8, 27, 2022],
+//  "age": 23,
+//  "pos": {
+//    "x": -3.4000000953674318,
+//    "y": 1.2000000476837159
+//  }
+// }
 console.log(`Stringified: ${stringified}`);
-
-const parsed = JSON.parse<Player>(stringified)
-// { firstName: "Emmet", lastName: "West", "lastActive": [8,27,2022], age: 23 }
-console.log(`Parsed: ${JSON.stringify(parsed)}`)
+console.log(`Whitespace: ${removeWhitespace(`{
+    "firstName": "Emmet",
+    "lastName": "West",
+   "lastActive": [8, 27, 2022],
+    "age": 23,
+    "pos": {
+      "x": -3.4000000953674318,
+      "y": 1.2000000476837159
+    }
+  }`)}`)
+const parsed = JSON.parse<Player>(`{
+    "firstName": "Emmet",
+    "lastName": "West",
+   "lastActive": [8, 27, 2022],
+    "age": 23,
+    "pos": {
+      "x": -3.4000000953674318,
+      "y": 1.2000000476837159
+    }
+  }`);
+// Player {
+//  firstName: "Emmet",
+//  lastName: "West",
+//  lastActive: [8, 27, 2022],
+//  age: 23,
+//  pos: {
+//    x: -3.4000000953674318,
+//    y: 1.2000000476837159
+//  }
+// }
+console.log(`Parsed: ${JSON.stringify(parsed)}`);

package/assembly/util.ts

@@ -0,0 +1,21 @@
+import { StringSink } from "as-string-sink/assembly";
+import { isSpace } from "assemblyscript/std/assembly/util/string";
+import { backSlashCode, quoteCode } from "./chars";
+
+export function removeWhitespace(data: string): string {
+    const result = new StringSink()
+    let instr = false;
+    for (let i = 0; i < data.length; i++) {
+        const char = data.charCodeAt(i);
+        if (instr === false && char === quoteCode) instr = true
+        else if (instr === true && char === quoteCode && data.charCodeAt(i - 1) !== backSlashCode) instr = false;
+
+        if (instr === false) {
+            if (!isSpace(char)) result.write(data.charAt(i))
+        } else {
+            result.write(data.charAt(i))
+        }
+        
+    }
+    return result.toString()
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.4.1",
+  "version": "0.4.4",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -17,18 +17,16 @@
     "test:wasm3": "wasm3 ./build/test.wasm"
   },
   "devDependencies": {
+    "@as-pect/cli": "^7.0.7",
     "@as-tral/cli": "^1.1.1",
     "as-console": "^6.0.2",
     "assemblyscript": "^0.20.7",
     "assemblyscript-prettier": "^1.0.2",
-    "benchmark": "^2.1.4",
-    "microtime": "^3.0.0",
     "typescript": "^4.7.2"
   },
   "dependencies": {
     "as-string-sink": "^0.5.0",
-    "as-variant": "^0.3.0",
-    "visitor-as": "^0.10.0"
+    "as-variant": "^0.4.0"
   },
   "repository": {
     "type": "git",
@@ -39,7 +37,8 @@
     "json",
     "serialize",
     "deserialize",
-    "dynamic"
+    "dynamic", 
+    "serde"
   ],
   "bugs": {
     "url": "https://github.com/JairusSW/as-json/issues"

package/transform/lib/index.js

@@ -5,8 +5,8 @@ class AsJSONTransform extends ClassDecorator {
     constructor() {
         super(...arguments);
         this.sources = [];
-        this.encodeStmts = new Map();
-        this.decodeCode = new Map();
+        this.encodeStmts = [];
+        this.decodeStmts = [];
     }
     visitMethodDeclaration(node) { }
     visitFieldDeclaration(node) {
@@ -15,15 +15,10 @@ class AsJSONTransform extends ClassDecorator {
             throw new Error(`Field ${name} is missing a type declaration`);
         }
         const type = getName(node.type);
-        const className = this.currentClass.name.text;
-        if (!this.encodeStmts.has(className))
-            this.encodeStmts.set(className, []);
-        if (!this.decodeCode.has(className))
-            this.decodeCode.set(className, []);
         // @ts-ignore
-        this.encodeStmts.get(className).push(`this.__JSON_Serialized += '' + '"' + '${name}' + '"' + ':' + JSON.stringify<${type}>(this.${name}) + ',';`);
+        this.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
         // @ts-ignore
-        this.decodeCode.get(className).push(`${name}: JSON.parse<${type}>(values.get("${name}")),\n`);
+        this.decodeStmts.push(`${name}: JSON.parse<${type}>(values.get("${name}")),\n`);
     }
     visitClassDeclaration(node) {
         if (!node.members) {
@@ -31,39 +26,39 @@ class AsJSONTransform extends ClassDecorator {
         }
         this.currentClass = node;
         const name = getName(node);
-        this.encodeStmts.delete(name);
-        this.decodeCode.delete(name);
         this.visit(node.members);
         const serializedProp = `__JSON_Serialized: string = "";`;
         let serializeFunc = ``;
-        if (this.encodeStmts.has(name) && this.encodeStmts.get(name)) {
+        if (this.encodeStmts.length > 0) {
+            const stmt = this.encodeStmts[this.encodeStmts.length - 1];
+            this.encodeStmts[this.encodeStmts.length - 1] = stmt.slice(0, stmt.length - 1);
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
-        if (!this.__JSON_Serialized) {
-          ${ // @ts-ignore
-            this.encodeStmts.get(name).join("\n")};
-          this.__JSON_Serialized = "{" + this.__JSON_Serialized.slice(0, this.__JSON_Serialized.length - 1) + "}";
-        }
-        return this.__JSON_Serialized;
+        return \`{${this.encodeStmts.join("")}}\`;
       }
       `;
         }
         else {
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
       `;
         }
         const deserializeFunc = `
+    @inline
     __JSON_Deserialize(values: Map<string, string>): ${name} {
         return {
           ${ // @ts-ignore
-        this.decodeCode.get(name) ? this.decodeCode.get(name).join("") : ""}
+        this.decodeStmts.join("")}
         }
     }
     `;
-        //console.log(serializedProp, serializeFunc, deserializeFunc)
+        this.encodeStmts = [];
+        this.decodeStmts = [];
+        //console.log(serializeFunc, deserializeFunc)
         const serializedProperty = SimpleParser.parseClassMember(serializedProp, node);
         node.members.push(serializedProperty);
         const serializeMethod = SimpleParser.parseClassMember(serializeFunc, node);

package/transform/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@json-as/transform",
-    "version": "0.4.0",
+    "version": "0.4.4",
     "description": "JSON encoder/decoder for AssemblyScript",
     "main": "./lib/index.js",
     "author": "Jairus Tanaka",
@@ -10,7 +10,9 @@
     "license": "MIT",
     "scripts": {},
     "devDependencies": {},
-    "dependencies": {},
+    "dependencies": {
+        "visitor-as": "^0.10.2"
+    },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/JairusSW/as-json.git"
@@ -28,4 +30,4 @@
     "homepage": "https://github.com/JairusSW/as-json#readme",
     "type": "module",
     "exports": "./lib/index.js"
-}
+}

package/transform/src/index.ts

@@ -11,8 +11,8 @@ import { SimpleParser } from "visitor-as/dist/index.js";
 class AsJSONTransform extends ClassDecorator {
     public currentClass!: ClassDeclaration;
     public sources: Source[] = [];
-    public encodeStmts = new Map<string, string[]>();
-    public decodeCode = new Map<string, string[]>();
+    public encodeStmts: string[] = [];
+    public decodeStmts: string[] = [];
 
     visitMethodDeclaration(node: MethodDeclaration): void {}
     visitFieldDeclaration(node: FieldDeclaration): void {
@@ -23,16 +23,13 @@ class AsJSONTransform extends ClassDecorator {
 
         const type = getName(node.type);
 
-        const className = this.currentClass!.name.text
-        if (!this.encodeStmts.has(className)) this.encodeStmts.set(className, [])
-        if (!this.decodeCode.has(className)) this.decodeCode.set(className, [])
         // @ts-ignore
-        this.encodeStmts.get(className).push(
-            `this.__JSON_Serialized += '' + '"' + '${name}' + '"' + ':' + JSON.stringify<${type}>(this.${name}) + ',';`
+        this.encodeStmts.push(
+            `"${name}":\${JSON.stringify<${type}>(this.${name})},`
         );
 
         // @ts-ignore
-        this.decodeCode.get(className).push(
+        this.decodeStmts.push(
             `${name}: JSON.parse<${type}>(values.get("${name}")),\n`
         );
     }
@@ -45,27 +42,24 @@ class AsJSONTransform extends ClassDecorator {
 
         const name = getName(node);
 
-        this.encodeStmts.delete(name);
-        this.decodeCode.delete(name);
         this.visit(node.members);
 
         const serializedProp = `__JSON_Serialized: string = "";`
 
         let serializeFunc = ``
 
-        if (this.encodeStmts.has(name) && this.encodeStmts.get(name)) {
+        if (this.encodeStmts.length > 0) {
+            const stmt = this.encodeStmts[this.encodeStmts.length - 1]!
+            this.encodeStmts[this.encodeStmts.length - 1] = stmt!.slice(0, stmt.length - 1)
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
-        if (!this.__JSON_Serialized) {
-          ${// @ts-ignore
-                this.encodeStmts.get(name).join("\n")};
-          this.__JSON_Serialized = "{" + this.__JSON_Serialized.slice(0, this.__JSON_Serialized.length - 1) + "}";
-        }
-        return this.__JSON_Serialized;
+        return \`{${this.encodeStmts.join("")}}\`;
       }
       `
         } else {
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
@@ -73,14 +67,17 @@ class AsJSONTransform extends ClassDecorator {
         }
 
         const deserializeFunc = `
+    @inline
     __JSON_Deserialize(values: Map<string, string>): ${name} {
         return {
           ${// @ts-ignore
-            this.decodeCode.get(name) ? this.decodeCode.get(name).join("") : ""}
+            this.decodeStmts.join("")}
         }
     }
     `;
-        //console.log(serializedProp, serializeFunc, deserializeFunc)
+        this.encodeStmts = [];
+        this.decodeStmts = [];
+        //console.log(serializeFunc, deserializeFunc)
         const serializedProperty = SimpleParser.parseClassMember(serializedProp, node);
         node.members.push(serializedProperty);
 

package/transform/tsconfig.json

@@ -14,7 +14,7 @@
     // "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
     "sourceMap": false /* Generates corresponding '.map' file. */,
     // "outFile": "./",                             /* Concatenate and emit output to single file. */
-    "outDir": "./lib/" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
+    "outDir": "./lib" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
     // "composite": true,                           /* Enable project compilation */
     // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
     // "removeComments": true,                      /* Do not emit comments to output. */