json-as 0.9.23 → 0.9.25

package/CHANGELOG

@@ -30,7 +30,8 @@ v0.9.19 - Fix arguments in @omitif declarations not working properly
 v0.9.20 - Strings were being received with quotes attached via the toString functionality. Removed that.
 v0.9.22 - Fix #89 and #93. Several bug fixes some severe such as ",null" being prepended when using @omit. Properly warn when a schema has fields that are not compatible with json
 v0.9.23 - Comment out SIMD-related code for now
-
+v0.9.24 - Remove transform changes from previous release
+v0.9.25 - Implement JSON.parseSafe
 [UNRELEASED] v1.0.0
  - Allow nullable primitives
  - Port over JSON.Value

package/README.md

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

package/assembly/__benches__/misc.bench.ts

@@ -0,0 +1,33 @@
+import { JSON } from "..";
+import { BRACE_LEFT, BRACKET_LEFT, CHAR_F, CHAR_T, QUOTE } from "../custom/chars";
+
+bench("Match Type (string)", () => {
+    blackbox<boolean>(matchType(blackbox<string>("\""), JSON.Types.String));
+});
+
+bench("Match Type (bool)", () => {
+    blackbox<boolean>(matchType(blackbox<string>("t"), JSON.Types.Bool));
+});
+
+bench("Match Type (array)", () => {
+    blackbox<boolean>(matchType(blackbox<string>("["), JSON.Types.Array));
+});
+
+bench("Match Type (struct)", () => {
+    blackbox<boolean>(matchType(blackbox<string>("{"), JSON.Types.Obj));
+});
+
+bench("Match Type (raw)", () => {
+    blackbox<boolean>(matchType(blackbox<string>("\""), JSON.Types.Raw));
+});
+
+@inline function matchType(data: string, type: JSON.Types): boolean {
+    const firstChar = load<u8>(changetype<usize>(data));
+    if (JSON.Types.String == type && firstChar == QUOTE) return true;
+    else if (JSON.Types.Bool == type && (firstChar == CHAR_T || firstChar == CHAR_F)) return true;
+    else if (JSON.Types.Array == type && firstChar == BRACKET_LEFT) return true;
+    else if (JSON.Types.Obj == type && firstChar == BRACE_LEFT) return true;
+    else if (type < 7 && type > 0 && (firstChar < 58 && firstChar > 46)) return true;
+    else if (JSON.Types.Raw == type) return true;
+    else return false;
+}

package/assembly/custom/util.ts

@@ -1,6 +1,7 @@
 import { isSpace } from "util/string";
-import { BACK_SLASH, QUOTE } from "./chars";
+import { BACK_SLASH, BRACE_LEFT, BRACKET_LEFT, CHAR_F, CHAR_T, QUOTE } from "./chars";
 import { Sink } from "./sink";
+import { JSON } from "..";
 
 // @ts-ignore: Decorator
 export function isMap<T>(): bool {
@@ -9,12 +10,12 @@ export function isMap<T>(): bool {
 }
 
 // @ts-ignore: Decorator
-export function unsafeCharCodeAt(data: string, pos: i32): i32 {
+@inline export function unsafeCharCodeAt(data: string, pos: i32): i32 {
   return load<u16>(changetype<usize>(data) + ((<usize>pos) << 1));
 }
 
 // @ts-ignore: Decorator
-export function removeWhitespace(data: string): string {
+@inline export function removeWhitespace(data: string): string {
   const result = new Sink();
   let instr = false;
   for (let i = 0; i < data.length; i++) {
@@ -35,7 +36,7 @@ export function removeWhitespace(data: string): string {
 }
 
 // @ts-ignore: Decorator
-export function escapeChar(char: string): string {
+@inline export function escapeChar(char: string): string {
   switch (unsafeCharCodeAt(char, 0)) {
     case 0x22:
       return '\\"';
@@ -93,7 +94,7 @@ export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
  * @param str - Any number. Can include scientific notation.
 */
 // @ts-ignore: Decorator
-export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u32 = 0): T {
+@inline export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u32 = 0): T {
   if (isSigned<T>()) {
     const firstChar: u32 = load<u16>(changetype<usize>(str));
     if (firstChar === 48) return 0 as T;
@@ -258,7 +259,7 @@ export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u
  */
 
 // @ts-ignore
-export function __atoi_fast<T extends number>(str: string, start: u32 = 0, end: u32 = 0): T {
+@inline export function __atoi_fast<T extends number>(str: string, start: u32 = 0, end: u32 = 0): T {
   // @ts-ignore
   let val: T = 0;
   if (!end) end = start + u32(str.length << 1);
@@ -293,7 +294,7 @@ export function __atoi_fast<T extends number>(str: string, start: u32 = 0, end:
  */
 
 // @ts-ignore
-export function parseSciInteger<T extends number>(str: string): T {
+@inline export function parseSciInteger<T extends number>(str: string): T {
   // @ts-ignore
   let val: T = 0;
   let offset = 0;
@@ -328,7 +329,7 @@ export function parseSciInteger<T extends number>(str: string): T {
 }
 
 // @ts-ignore
-function sciNote<T extends number>(num: T): T {
+@inline function sciNote<T extends number>(num: T): T {
   let res = 1;
   // @ts-ignore
   if (num > 0) {
@@ -345,7 +346,7 @@ function sciNote<T extends number>(num: T): T {
 }
 
 // @ts-ignore
-function equalsSlice(p1_data: string, p1_start: i32, p1_end: i32, p2_data: string, p2_start: i32, p2_end: i32): boolean {
+@inline function equalsSlice(p1_data: string, p1_start: i32, p1_end: i32, p2_data: string, p2_start: i32, p2_end: i32): boolean {
   const p1_len = p1_end - p1_start;
   const p2_len = p2_end - p2_start;
   if (p1_len != p2_len) return false;
@@ -356,14 +357,15 @@ function equalsSlice(p1_data: string, p1_start: i32, p1_end: i32, p2_data: strin
 }
 
 // @ts-ignore
-export function containsCodePoint(str: string, code: u32, start: i32, end: i32): bool {
+@inline export function containsCodePoint(str: string, code: u32, start: i32, end: i32): bool {
   for (let i = start; i <= end; i++) {
     if (unsafeCharCodeAt(str, i) == code) return true;
   }
   return false;
 }
 
-export function _intTo16(int: i32): i32 {
+// @ts-ignore: Decorator
+@inline export function _intTo16(int: i32): i32 {
   if (int < 10) {
     // 0-10
     return 48 + int;
@@ -373,6 +375,7 @@ export function _intTo16(int: i32): i32 {
   }
 }
 
+// @ts-ignore: Decorator
 @inline export function intTo16(int: i32): i32 {
   const high = int >> 4;
   const low = int & 0x0F;

package/assembly/deserialize/array.ts

@@ -1,3 +1,4 @@
+import { BRACKET_LEFT } from "../custom/chars";
 import { isMap } from "../custom/util";
 import { deserializeArrayArray } from "./array/array";
 import { deserializeBooleanArray } from "./array/bool";
@@ -36,3 +37,10 @@ export function deserializeArray<T extends unknown[]>(data: string): T {
     throw new Error("Could not parse array of type " + nameof<T>() + "!");
   }
 }
+
+// @ts-ignore: Decorator valid here
+export function deserializeArray_Safe<T extends unknown[]>(data: string): T {
+  const firstChar = load<u8>(changetype<usize>(data));
+  if (firstChar != BRACKET_LEFT) throw new Error("Mismatched Types! Expected " + nameof<T>() + " but got \"" + data.slice(0, 100) + "\" instead!");
+  return deserializeArray<T>(data);
+}

package/assembly/deserialize/bool.ts

@@ -15,4 +15,20 @@ import { unsafeCharCodeAt } from "../custom/util";
     if (len === 4 && firstChar === CHAR_T && load<u64>(ptr) === 28429475166421108) return true;
     else if (len === 5 && firstChar === CHAR_F && load<u64>(ptr, 2) === 28429466576093281) return false;
     return false//ERROR(`Expected to find boolean, but found "${data.slice(0, 100)}" instead!`);
+}
+
+/**
+ * Deserialize a string to type boolean (safely)
+ * @param data data to parse
+ * @returns boolean
+ */
+// @ts-ignore: Decorator valid here
+@inline export function deserializeBoolean_Safe(data: string, start: i32 = 0, end: i32 = 0): boolean {
+    if (!end) end = data.length;
+    const len = end - start;
+    const ptr = changetype<usize>(data) + <usize>(start << 1);
+    const firstChar = unsafeCharCodeAt(data, start);
+    if (len === 4 && firstChar === CHAR_T && load<u64>(ptr) === 28429475166421108) return true;
+    else if (len === 5 && firstChar === CHAR_F && load<u64>(ptr, 2) === 28429466576093281) return false;
+    throw new Error("Mismatched Types! Expected boolean but got \"" + data.slice(0, 100) + "\" instead!");
 }

package/assembly/deserialize/date.ts

@@ -1,11 +1,19 @@
+import { QUOTE } from "../custom/chars";
+
 // @ts-ignore: Decorator valid here
 @inline export function deserializeDate(dateTimeString: string): Date {
-    // Use AssemblyScript's date parser
-    const d = Date.fromString(dateTimeString);
-  
-    // Return a new object instead of the one that the parser returned.
-    // This may seem redundant, but addreses the issue when Date
-    // is globally aliased to wasi_Date (or some other superclass).
-    return new Date(d.getTime());
-  }
-  
+  // Use AssemblyScript's date parser
+  const d = Date.fromString(dateTimeString);
+
+  // Return a new object instead of the one that the parser returned.
+  // This may seem redundant, but addreses the issue when Date
+  // is globally aliased to wasi_Date (or some other superclass).
+  return new Date(d.getTime());
+}
+
+// @ts-ignore: Decorator valid here
+@inline export function deserializeDate_Safe(dateTimeString: string): Date {
+  const firstChar = load<u8>(changetype<usize>(dateTimeString));
+  if (firstChar != QUOTE) throw new Error("Mismatched Types! Expected Date but got \"" + dateTimeString.slice(0, 100) + "\" instead!");
+  return deserializeDate(dateTimeString);
+}

package/assembly/deserialize/float.ts

@@ -6,4 +6,16 @@
     if (type instanceof f64) return f64.parse(data);
     // @ts-ignore
     return f32.parse(data);
+}
+
+// @ts-ignore: Decorator valid here
+@inline export function deserializeFloat_Safe<T>(data: string): T {
+    const firstChar = load<u8>(changetype<usize>(data));
+    if ((firstChar < 48 || firstChar > 57) && firstChar != 45) throw new Error("Mismatched Types! Expected float but got \""+data.slice(0, 100)+"\" instead!");
+    // @ts-ignore
+    const type: T = 0;
+    // @ts-ignore
+    if (type instanceof f64) return f64.parse(data);
+    // @ts-ignore
+    return f32.parse(data);
 }

package/assembly/deserialize/integer.ts

@@ -4,4 +4,13 @@ import { snip_fast } from "../custom/util";
 @inline export function deserializeInteger<T>(data: string): T {
     // @ts-ignore
     return snip_fast<T>(data);
+}
+
+// @ts-ignore: Decorator valid here
+@inline export function deserializeInteger_Safe<T>(data: string): T {
+    const firstChar = load<u8>(changetype<usize>(data));
+    console.log(firstChar.toString())
+    if ((firstChar < 48 || firstChar > 57) && firstChar != 45) throw new Error("Mismatched Types! Expected " + nameof<T>() + " but got \""+data.slice(0, 100)+"\" instead!");
+    // @ts-ignore
+    return snip_fast<T>(data);
 }

package/assembly/deserialize/map.ts

@@ -180,3 +180,10 @@ 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>()}`);
 }
+
+// @ts-ignore: Decorator valid here
+@inline export function deserializeMap_Safe<T extends Map>(data: string): T {
+    const firstChar = load<u8>(changetype<usize>(data));
+    if (firstChar != BRACE_LEFT) throw new Error("Mismatched Types! Expected " + nameof<T>() + " but got \"" + data.slice(0, 100) + "\" instead!");
+    return deserializeMap<T>(data);
+}

package/assembly/deserialize/object.ts

@@ -133,4 +133,139 @@ import { isSpace } from "util/string";
     }
   }
   return schema;
+}
+
+// @ts-ignore: Decorator valid here
+@inline export function deserializeObject_Safe<T>(data: string): T {
+  const firstChar = load<u8>(changetype<usize>(data));
+  if (firstChar != BRACE_LEFT) throw new Error("Mismatched Types! Expected " + nameof<T>() + " but got \"" + data.slice(0, 100) + "\" instead!");
+  const schema: nonnull<T> = changetype<nonnull<T>>(
+    __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
+  );
+
+  // @ts-ignore
+  schema.__INITIALIZE();
+
+  let key_start: i32 = 0;
+  let key_end: i32 = 0;
+  let isKey = false;
+  let depth = 0;
+  let outerLoopIndex = 1;
+  for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
+    const char = unsafeCharCodeAt(data, outerLoopIndex);
+    if (char === BRACKET_LEFT) {
+      for (
+        let arrayValueIndex = outerLoopIndex;
+        arrayValueIndex < data.length - 1;
+        arrayValueIndex++
+      ) {
+        const char = unsafeCharCodeAt(data, arrayValueIndex);
+        if (char === BRACKET_LEFT) {
+          depth++;
+        } else if (char === BRACKET_RIGHT) {
+          depth--;
+          if (depth === 0) {
+            ++arrayValueIndex;
+            // @ts-ignore
+            schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex, arrayValueIndex);
+            outerLoopIndex = arrayValueIndex;
+            isKey = false;
+            break;
+          }
+        }
+      }
+    } else if (char === BRACE_LEFT) {
+      for (
+        let objectValueIndex = outerLoopIndex;
+        objectValueIndex < data.length - 1;
+        objectValueIndex++
+      ) {
+        const char = unsafeCharCodeAt(data, objectValueIndex);
+        if (char === BRACE_LEFT) {
+          depth++;
+        } else if (char === BRACE_RIGHT) {
+          depth--;
+          if (depth === 0) {
+            ++objectValueIndex;
+            // @ts-ignore
+            schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex, objectValueIndex);
+            outerLoopIndex = objectValueIndex;
+            isKey = false;
+            break;
+          }
+        }
+      }
+    } else if (char === QUOTE) {
+      let escaping = false;
+      for (
+        let stringValueIndex = ++outerLoopIndex;
+        stringValueIndex < data.length - 1;
+        stringValueIndex++
+      ) {
+        const char = unsafeCharCodeAt(data, stringValueIndex);
+        if (char === BACK_SLASH && !escaping) {
+          escaping = true;
+        } else {
+          if (char === QUOTE && !escaping) {
+            if (isKey === false) {
+              key_start = outerLoopIndex;
+              key_end = stringValueIndex;
+              isKey = true;
+            } else {
+              // @ts-ignore
+              schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex - 1, stringValueIndex + 1);
+              isKey = false;
+            }
+            outerLoopIndex = ++stringValueIndex;
+            break;
+          }
+          escaping = false;
+        }
+      }
+    } else if (
+      char == CHAR_N &&
+      unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_U &&
+      unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L &&
+      unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_L
+    ) {
+      // @ts-ignore
+      schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 4);
+      outerLoopIndex += 3;
+      isKey = false;
+    } else if (
+      char === CHAR_T &&
+      unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_R &&
+      unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_U &&
+      unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_E
+    ) {
+      // @ts-ignore
+      schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 4);
+      outerLoopIndex += 3;
+      isKey = false;
+    } else if (
+      char === CHAR_F &&
+      unsafeCharCodeAt(data, outerLoopIndex + 1) === CHAR_A &&
+      unsafeCharCodeAt(data, outerLoopIndex + 2) === CHAR_L &&
+      unsafeCharCodeAt(data, outerLoopIndex + 3) === CHAR_S &&
+      unsafeCharCodeAt(data, outerLoopIndex + 4) === CHAR_E
+    ) {
+      // @ts-ignore
+      schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 5);
+      outerLoopIndex += 4;
+      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 === COMMA || char === BRACE_RIGHT || isSpace(char)) {
+          // @ts-ignore
+          schema.__DESERIALIZE_SAFE(data, key_start, key_end, outerLoopIndex - 1, numberValueIndex);
+          outerLoopIndex = numberValueIndex;
+          isKey = false;
+          break;
+        }
+      }
+    }
+  }
+  return schema;
 }

package/assembly/deserialize/string.ts

@@ -1,4 +1,3 @@
-import { bs } from "../custom/bs";
 import {
     CHAR_B,
     BACK_SLASH,
@@ -155,4 +154,11 @@ import { unsafeCharCodeAt } from "../custom/util";
 //     if (end > last) {
 //         result.write(data, last, end);
 //     }
-// }
+// }
+
+// @ts-ignore: Decorator valid here
+@inline export function deserializeString_Safe(data: string, start: i32 = 0, end: i32 = 0): string {
+    const firstChar = load<u8>(changetype<usize>(data));
+    if (firstChar != QUOTE) throw new Error("Mismatched Types! Expected string but got \""+data.slice(0, 100)+"\" instead!");
+    return deserializeString(data, start, end);
+}

package/assembly/index.ts

@@ -7,15 +7,15 @@ import { serializeObject, serializeObject_Pretty } from "./serialize/object";
 import { serializeDate } from "./serialize/date";
 import { serializeArray } from "./serialize/array";
 import { serializeMap } from "./serialize/map";
-import { deserializeBoolean } from "./deserialize/bool";
-import { deserializeArray } from "./deserialize/array";
+import { deserializeBoolean, deserializeBoolean_Safe } from "./deserialize/bool";
+import { deserializeArray, deserializeArray_Safe } from "./deserialize/array";
 import { deserializeFloat } from "./deserialize/float";
-import { deserializeObject } from "./deserialize/object";
-import { deserializeMap } from "./deserialize/map";
+import { deserializeObject, deserializeObject_Safe } from "./deserialize/object";
+import { deserializeMap, deserializeMap_Safe } from "./deserialize/map";
 import { deserializeDate } from "./deserialize/date";
-import { NULL_WORD } from "./custom/chars";
-import { deserializeInteger } from "./deserialize/integer";
-import { deserializeString } from "./deserialize/string";
+import { BRACE_LEFT, BRACKET_LEFT, CHAR_F, CHAR_N, CHAR_T, NULL_WORD, QUOTE } from "./custom/chars";
+import { deserializeInteger, deserializeInteger_Safe } from "./deserialize/integer";
+import { deserializeString, deserializeString_Safe } from "./deserialize/string";
 import { Sink } from "./custom/sink";
 import { getArrayDepth } from "./custom/util";
 
@@ -174,7 +174,7 @@ export namespace JSON {
    * @returns string
    */
   // @ts-ignore: Decorator
-  export function stringify<T>(data: T/*, options: SerializeOptions = DEFAULT_SERIALIZE_OPTIONS*/): string {
+  @inline export function stringify<T>(data: T/*, options: SerializeOptions = DEFAULT_SERIALIZE_OPTIONS*/): string {
     if (isBoolean<T>()) {
       return serializeBool(data as bool);
     } else if (isInteger<T>()) {
@@ -222,7 +222,7 @@ export namespace JSON {
    */
 
   // @ts-ignore: Decorator
-  export function parse<T>(data: string): T {
+  @inline export function parse<T>(data: string): T {
     if (isBoolean<T>()) {
       return deserializeBoolean(data) as T;
     } else if (isInteger<T>()) {
@@ -256,14 +256,62 @@ export namespace JSON {
       );
     }
   }
+  /**
+   * Parses valid JSON strings into their original format (safely).
+   * ```js
+   * JSON.parseSafe<T>(data)
+   * ```
+   * @param data string
+   * @returns T
+   */
+
+  // @ts-ignore: Decorator
+  @inline export function parseSafe<T>(data: string): T {
+    if (isBoolean<T>()) {
+      return deserializeBoolean_Safe(data) as T;
+    } else if (isInteger<T>()) {
+      return deserializeInteger_Safe<T>(data);
+    } else if (isFloat<T>()) {
+      return deserializeFloat<T>(data);
+    } else if (isNullable<T>() && data.length === 4 && data == "null") {
+      // @ts-ignore
+      return null;
+    } else if (isString<T>()) {
+      // @ts-ignore
+      return deserializeString_Safe(data);
+    } else if (isArray<T>()) {
+      // @ts-ignore
+      return deserializeArray_Safe<nonnull<T>>(data);
+    }
+    let type: nonnull<T> = changetype<nonnull<T>>(0);
+    // @ts-ignore: Defined by transform
+    if (isDefined(type.__DESERIALIZE)) {
+      // @ts-ignore
+      return deserializeObject_Safe<nonnull<T>>(data.trimStart());
+    } else if (type instanceof Map) {
+      // @ts-ignore
+      return deserializeMap_Safe<nonnull<T>>(data.trimStart());
+    } else if (type instanceof Date) {
+      // @ts-ignore
+      return deserializeDate_Safe(data);
+    } else {
+      throw new Error(
+        `Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
+      );
+    }
+  }
 }
 
 // This allows JSON.stringify and JSON.parse to be available globally through an alias
 // @ts-ignore: Decorator
-@global function __SERIALIZE<T>(data: T): string {
+@global @inline function __SERIALIZE<T>(data: T): string {
   return JSON.stringify(data);
 }
 // @ts-ignore: Decorator
-@global function __DESERIALIZE<T>(data: string): T {
+@global @inline function __DESERIALIZE<T>(data: string): T {
   return JSON.parse<T>(data);
+}
+// @ts-ignore: Decorator
+@global @inline function __DESERIALIZE_SAFE<T>(data: string): T {
+  return JSON.parseSafe<T>(data);
 }

package/assembly/serialize/bool.ts

@@ -4,19 +4,7 @@
  * @returns string
  */
 
-import { bs } from "../custom/bs";
-
 // @ts-ignore: Decorator valid here
 @inline export function serializeBool(data: bool): string {
     return data ? "true" : "false";
-}
-
-@inline export function serializeBool_BS(data: bool): void {
-    if (data === true) {
-        bs.write_64(28429475166421108); /* true */
-    } else {
-        //bs.write_128_n(i16x8(102, 97, 108, 115, 101, 0, 0, 0), 10);
-        bs.write_64(32370086184550502); /* fals */
-        bs.write_16(101); /* e */
-    }
 }

package/assembly/serialize/string.ts

@@ -1,14 +1,3 @@
-import {
-    BACK_SLASH,
-    BACKSPACE,
-    CARRIAGE_RETURN,
-    FORM_FEED,
-    NEW_LINE,
-    QUOTE,
-    TAB
-} from "../custom/chars";
-import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
-import { bs } from "../custom/bs";
 import { _intTo16, intTo16, unsafeCharCodeAt } from "../custom/util";
 import { Sink } from "../custom/sink";
 

package/assembly/test.ts

@@ -1,34 +1,34 @@
 import { JSON } from "."
 
 @json
-class Vec3<T> {
+class Vec3 {
   public x: i32 = 0;
   public y: i32 = 0;
-  public z: T;
+  public z: i32 = 0;
 }
 
-@json
-class Base {
-  public bam: string = "harekogkeorgke"
-}
+// @json
+// class Base {
+//   public bam: string = "harekogkeorgke"
+// }
 
-@json
-class Foo extends Base {
-  public bar: JSON.Raw = "\"this is ok\'"
-  public baz: i32 = 0;
-  public pos: Vec3<Vec3<i32>> = {
-    x: 1,
-    y: 2,
-    z: {
-      x: 1,
-      y: 2,
-      z: 3
-    }
-  }
-  // ^ this is not okay
-}
+// @json
+// class Foo extends Base {
+//   public bar: JSON.Raw = "\"this is ok\'"
+//   public baz: i32 = 0;
+//   public pos: Vec3<Vec3<i32>> = {
+//     x: 1,
+//     y: 2,
+//     z: {
+//       x: 1,
+//       y: 2,
+//       z: 3
+//     }
+//   }
+//   // ^ this is not okay
+// }
 
-const serialized = JSON.stringify(new Foo());
+const serialized = JSON.stringify(new Vec3());
 console.log("Serialized: " + serialized);
-const deserialized = JSON.parse<Foo>(serialized);
+const deserialized = JSON.parseSafe<Vec3>(`{"x":1,"y":true,"z":3}`);
 console.log("Deserialized: " + JSON.stringify(deserialized));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.9.23",
+  "version": "0.9.25",
   "description": "The only JSON library you'll need for AssemblyScript. SIMD enabled",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -19,7 +19,7 @@
     "test": "ast test && rm -rf ./build/",
     "pretest": "rm -rf ./build/ && ast build",
     "bench": "astral --enable simd --runtime stub",
-    "build:test": "rm -rf ./build/ && asc assembly/test.ts --transform ./transform -o ./build/test.wasm",
+    "build:test": "rm -rf ./build/ && JSON_DEBUG=true asc assembly/test.ts --transform ./transform -o ./build/test.wasm",
     "build:transform": "tsc -p ./transform",
     "test:wasmtime": "wasmtime ./build/test.wasm",
     "test:wavm": "wavm run ./build/test.wasm",
@@ -44,6 +44,7 @@
     "visitor-as": "^0.11.4"
   },
   "dependencies": {
+    "@hypermode/modus-sdk-as": "^0.13.0-prerelease-test-1",
     "as-virtual": "^0.2.0",
     "chalk": "^5.3.0"
   },