json-as 0.5.36 → 0.5.38

package/assembly/src/json.ts

@@ -1,7 +1,5 @@
-import { u128, u128Safe, u256, u256Safe, i128, i128Safe } from "as-bignum/assembly";
 import { StringSink } from "as-string-sink/assembly";
-import { itoa32, itoa64, dtoa, dtoa_buffered } from "util/number";
-import { isSpace } from "util/string";
+import { isSpace, CharCode } from "util/string";
 import {
     backSlashCode,
     commaCode,
@@ -21,9 +19,9 @@ import {
     tCode,
     trueWord,
     uCode,
-    emptyArrayWord
+    emptyArrayWord,
 } from "./chars";
-import { parseJSONInt, escapeChar, isBigNum, unsafeCharCodeAt } from "./util";
+import { parseSciInteger, unsafeCharCodeAt } from "./util";
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
@@ -37,7 +35,8 @@ export namespace JSON {
      * @param data T
      * @returns string
      */
-    export function stringify<T>(data: T): string {
+    // @ts-ignore
+    @inline export function stringify<T>(data: T): string {
         // String
         if (isString<T>() && data != null) {
             // @ts-ignore
@@ -94,11 +93,10 @@ export namespace JSON {
                 result.write(rightBracketWord);
                 return result.toString();
             }
-        } else if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
-            // @ts-ignore
-            return data.toString();
         } else {
-            throw new Error(`Could not serialize data of type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
+            throw new Error(
+                `Could not serialize data of type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
+            );
         }
     }
     /**
@@ -109,8 +107,9 @@ export namespace JSON {
      * @param data string
      * @returns T
      */
+    
     // @ts-ignore
-    export function parse<T>(data: string): T {
+    @inline export function parse<T>(data: string): T {
         let type: T;
         if (isString<T>()) {
             // @ts-ignore
@@ -133,16 +132,15 @@ export namespace JSON {
         } else if (idof<nonnull<T>>() == idof<Date>()) {
             // @ts-ignore
             return Date.fromString(data);
-        } else if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
-            // @ts-ignore
-            return parseBigNum<T>(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.`);
+            throw new Error(
+                `Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
+            );
         }
     }
     // @ts-ignore
-    function parseObjectValue<T>(data: string): T {
+    @inline function parseObjectValue<T>(data: string): T {
         let type: T;
         if (isString<T>()) {
             // @ts-ignore
@@ -153,9 +151,9 @@ export namespace JSON {
                 // \\"
                 if (unsafeCharCodeAt(data, i) === backSlashCode) {
                     char = unsafeCharCodeAt(data, ++i);
-                    result += data.slice(last, i - 1)
+                    result += data.slice(last, i - 1);
                     if (char === 34) {
-                        result += "\"";
+                        result += '"';
                         last = ++i;
                     } else if (char === 110) {
                         result += "\n";
@@ -177,7 +175,11 @@ export namespace JSON {
                         } else if (char === 116) {
                             result += "\t";
                             last = ++i;
-                        } else if (char === 117 && load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) === 27584753879220272) {
+                        } else if (
+                            char === 117 &&
+                            load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) ===
+                            27584753879220272
+                        ) {
                             result += "\u000b";
                             i += 4;
                             last = ++i;
@@ -206,162 +208,158 @@ export namespace JSON {
         } else if (idof<nonnull<T>>() == idof<Date>()) {
             // @ts-ignore
             return Date.fromString(data);
-        } else if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
-            // @ts-ignore
-            return parseBigNum<T>(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.`)
+            throw new Error(
+                `Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
+            );
         }
     }
 }
 
-
 // @ts-ignore
-@inline
-function serializeString(data: string): string {
+@inline function serializeString(data: string): string {
     // @ts-ignore
-    if (data.length === 0) return "\"\"";
-    // Fast path for Vectors (3)
-    let char: i32 = 0;
-    if (data.length === 1) {
-        char = unsafeCharCodeAt(data, 0);
-        if (char === 34) {
-            return "\\\"";
-        } else if (char === 92) {
-            return "\\n";
-        } else if (char <= 13 && char >= 8) {
-            switch (char) {
-                case 0x5C: {
-                    return "\\\\";
-                }
-                case 0x08: {
-                    return "\\b";
-                }
-                case 0x0D: {
-                    return "\\r";
-                }
-                case 0x09: {
-                    return "\\t";
-                }
-                case 0x0C: {
-                    return "\\f";
-                }
-                case 0x0B: {
-                    return "\\u000b";
-                }
-            }
-        } else {
-            return data;
-        }
-    }
+    //if (data.length === 0) return "\"\"";
+    /*
+       let char: i32 = 0;
+       if (data.length === 1) {
+           char = unsafeCharCodeAt(data, 0);
+           if (char === 34) {
+               return "\\\"";
+           } else if (char === 92) {
+               return "\\n";
+           } else if (char <= 13 && char >= 8) {
+               switch (char) {
+                   case 0x5C: {
+                       return "\\\\";
+                   }
+                   case 0x08: {
+                       return "\\b";
+                   }
+                   case 0x0D: {
+                       return "\\r";
+                   }
+                   case 0x09: {
+                       return "\\t";
+                   }
+                   case 0x0C: {
+                       return "\\f";
+                   }
+                   case 0x0B: {
+                       return "\\u000b";
+                   }
+               }
+           } else {
+               return data;
+           }
+       }*/
 
-    let result = "\"";
+    let result = '"';
 
     let last: i32 = 0;
-    let found: boolean = false;
     // @ts-ignore
     for (let i = 0; i < data.length; i++) {
-        char = unsafeCharCodeAt(<string>data, i);
+        const char = unsafeCharCodeAt(<string>data, i);
         if (char === 34 || char === 92) {
             result += (<string>data).slice(last, i) + "\\";
             last = i;
-            found = true;
             i++;
         } else if (char <= 13 && char >= 8) {
             result += (<string>data).slice(last, i);
             last = ++i;
-            found = true;
             switch (char) {
-                case 0x5C: {
-                    result += "\\\\";
+                case 8: {
+                    result += "\\b";
                     break;
                 }
-                case 0x08: {
-                    result += "\\b";
+                case 9: {
+                    result += "\\t";
                     break;
                 }
-                case 0x0D: {
-                    result += "\\r";
+                case 10: {
+                    result += "\\n";
                     break;
                 }
-                case 0x09: {
-                    result += "\\t";
+                case 11: {
+                    result += "\\x0B"; // \\u000b
                     break;
                 }
-                case 0x0C: {
+                case 12: {
                     result += "\\f";
                     break;
                 }
-                case 0x0B: {
-                    result += "\\u000b";
+                case 13: {
+                    result += "\\r";
                     break;
                 }
             }
         }
-    }// 8 10 13 9 12
-    if (!found) return "\"" + data + "\"";
+    }
+    if (result.length === 1) return '"' + data + '"';
     else result += (<string>data).slice(last);
-    return result + "\"";
-}
-// @ts-ignore
-@inline
-// @ts-ignore
-function parseBigNum<T>(data: string): T {
-    // @ts-ignore
-    if (idof<T>() == idof<u128>()) return u128.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<u128Safe>()) return u128Safe.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<u256>()) return u128Safe.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<u256Safe>()) return u256Safe.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<i128>()) return i128.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<i128Safe>()) return i128Safe.fromString(data);
-    // @ts-ignore
-    //if (idof<T>() == idof<i256Safe>()) return data.
+    return result + '"';
 }
 
 // @ts-ignore
-@inline
-function parseString(data: string): string {
+@inline function parseString(data: string): string {
     let result = "";
     let last = 1;
-    let char = 0;
     for (let i = 1; i < data.length - 1; i++) {
         // \\"
         if (unsafeCharCodeAt(data, i) === backSlashCode) {
-            char = unsafeCharCodeAt(data, ++i);
-            result += data.slice(last, i - 1)
+            const char = unsafeCharCodeAt(data, ++i);
+            result += data.slice(last, i - 1);
             if (char === 34) {
-                result += "\"";
+                result += '"';
                 last = ++i;
             } else if (char === 110) {
                 result += "\n";
                 last = ++i;
                 // 92 98 114 116 102 117
             } else if (char >= 92 && char <= 117) {
-                if (char === 92) {
-                    result += "\\";
-                    last = ++i;
-                } else if (char === 98) {
-                    result += "\b";
-                    last = ++i;
-                } else if (char === 102) {
-                    result += "\f";
-                    last = ++i;
-                } else if (char === 114) {
-                    result += "\r";
-                    last = ++i;
-                } else if (char === 116) {
-                    result += "\t";
-                    last = ++i;
-                } else if (char === 117 && load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) === 27584753879220272) {
-                    result += "\u000b";
-                    i += 4;
-                    last = ++i;
+                switch (char) {
+                    case 92: {
+                        result += "\\";
+                        last = ++i;
+                        break;
+                    }
+                    case 98: {
+                        result += "\b";
+                        last = ++i;
+                        break;
+                    }
+                    case 110: {
+                        result += "\n";
+                        last = ++i;
+                    }
+                    case 102: {
+                        result += "\f";
+                        last = ++i;
+                        break;
+                    }
+                    case 114: {
+                        result += "\r";
+                        last = ++i;
+                        break;
+                    }
+                    case 116: {
+                        result += "\t";
+                        last = ++i;
+                        break;
+                    }
+                    default: {
+                        if (
+                            char === 117 &&
+                            load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) ===
+                            27584753879220272
+                        ) {
+                            result += "\u000b";
+                            i += 4;
+                            last = ++i;
+                        }
+                        break;
+                    }
                 }
             }
         }
@@ -371,20 +369,17 @@ function parseString(data: string): string {
 }
 
 // @ts-ignore
-@inline
-function parseBoolean<T extends boolean>(data: string): T {
+@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;
     else throw new Error(`JSON: Cannot parse "${data}" as boolean`);
 }
 
 // @ts-ignore
-@inline
-// @ts-ignore
-export function parseNumber<T>(data: string): T {
+@inline export function parseNumber<T>(data: string): T {
     if (isInteger<T>()) {
         // @ts-ignore
-        return parseJSONInt<T>(data);
+        return parseSciInteger<T>(data);
     }
     // @ts-ignore
     const type: T = 0;
@@ -395,9 +390,10 @@ export function parseNumber<T>(data: string): T {
 }
 
 // @ts-ignore
-@inline
-function parseObject<T>(data: string): T {
-    let schema: nonnull<T> = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
+@inline function parseObject<T>(data: string): T {
+    let schema: nonnull<T> = changetype<nonnull<T>>(
+        __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
+    );
     let key = "";
     let isKey = false;
     let depth = 0;
@@ -419,7 +415,10 @@ function parseObject<T>(data: string): T {
                     if (depth === 0) {
                         ++arrayValueIndex;
                         // @ts-ignore
-                        schema.__JSON_Set_Key(key, data.slice(outerLoopIndex, arrayValueIndex));
+                        schema.__JSON_Set_Key(
+                            key,
+                            data.slice(outerLoopIndex, arrayValueIndex)
+                        );
                         outerLoopIndex = arrayValueIndex;
                         isKey = false;
                         break;
@@ -440,7 +439,10 @@ function parseObject<T>(data: string): T {
                     if (depth === 0) {
                         ++objectValueIndex;
                         // @ts-ignore
-                        schema.__JSON_Set_Key(key, data.slice(outerLoopIndex, objectValueIndex));
+                        schema.__JSON_Set_Key(
+                            key,
+                            data.slice(outerLoopIndex, objectValueIndex)
+                        );
                         outerLoopIndex = objectValueIndex;
                         isKey = false;
                         break;
@@ -463,7 +465,10 @@ function parseObject<T>(data: string): T {
                         isKey = true;
                     } else {
                         // @ts-ignore
-                        schema.__JSON_Set_Key(key, data.slice(outerLoopIndex, stringValueIndex));
+                        schema.__JSON_Set_Key(
+                            key,
+                            data.slice(outerLoopIndex, stringValueIndex)
+                        );
                         isKey = false;
                     }
                     outerLoopIndex = ++stringValueIndex;
@@ -499,7 +504,10 @@ function parseObject<T>(data: string): T {
                 char = unsafeCharCodeAt(data, numberValueIndex);
                 if (char === commaCode || char === rightBraceCode || isSpace(char)) {
                     // @ts-ignore
-                    schema.__JSON_Set_Key(key, data.slice(outerLoopIndex - 1, numberValueIndex));
+                    schema.__JSON_Set_Key(
+                        key,
+                        data.slice(outerLoopIndex - 1, numberValueIndex)
+                    );
                     outerLoopIndex = numberValueIndex;
                     isKey = false;
                     break;
@@ -511,9 +519,7 @@ function parseObject<T>(data: string): T {
 }
 
 // @ts-ignore
-@inline
-// @ts-ignore
-function parseArray<T extends unknown[]>(data: string): T {
+@inline function parseArray<T extends unknown[]>(data: string): T {
     if (isString<valueof<T>>()) {
         return <T>parseStringArray(data);
     } else if (isBoolean<valueof<T>>()) {
@@ -527,7 +533,10 @@ function parseArray<T extends unknown[]>(data: string): T {
         return parseArrayArray<T>(data);
         // @ts-ignore
     } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
-        const type = changetype<nonnull<valueof<T>>>(__new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<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>>>(
+            __new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<valueof<T>>>())
+        );
         // @ts-ignore
         if (isDefined(type.__JSON_Set_Key)) {
             // @ts-ignore
@@ -539,8 +548,7 @@ function parseArray<T extends unknown[]>(data: string): T {
 }
 
 // @ts-ignore
-@inline
-function parseStringArray(data: string): string[] {
+@inline function parseStringArray(data: string): string[] {
     const result: string[] = [];
     let lastPos = 0;
     let instr = false;
@@ -559,23 +567,22 @@ function parseStringArray(data: string): string[] {
 }
 
 // @ts-ignore
-@inline
-function parseBooleanArray<T extends boolean[]>(data: string): T {
+@inline function parseBooleanArray<T extends boolean[]>(data: string): T {
     const result = instantiate<T>();
     let lastPos = 1;
     let char = 0;
     for (let i = 1; i < data.length - 1; i++) {
         char = unsafeCharCodeAt(data, i);
         /*// if char == "t" && i+3 == "e"
-            if (char === tCode && data.charCodeAt(i + 3) === eCode) {
-              //i += 3;
-              result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+2)));
-              //i++;
-            } else if (char === fCode && data.charCodeAt(i + 4) === eCode) {
-              //i += 4;
-              result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+3)));
-              //i++;
-            }*/
+                if (char === tCode && data.charCodeAt(i + 3) === eCode) {
+                  //i += 3;
+                  result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+2)));
+                  //i++;
+                } else if (char === fCode && data.charCodeAt(i + 4) === eCode) {
+                  //i += 4;
+                  result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+3)));
+                  //i++;
+                }*/
         if (char === tCode || char === fCode) {
             lastPos = i;
         } else if (char === eCode) {
@@ -587,8 +594,7 @@ function parseBooleanArray<T extends boolean[]>(data: string): T {
 }
 
 // @ts-ignore
-@inline
-function parseNumberArray<T extends number[]>(data: string): T {
+@inline function parseNumberArray<T extends number[]>(data: string): T {
     const result = instantiate<T>();
     let lastPos = 0;
     let char = 0;
@@ -613,8 +619,7 @@ function parseNumberArray<T extends number[]>(data: string): T {
 }
 
 // @ts-ignore
-@inline
-function parseArrayArray<T extends unknown[][]>(data: string): T {
+@inline function parseArrayArray<T extends unknown[][]>(data: string): T {
     const result = instantiate<T>();
     let char = 0;
     let lastPos = 0;
@@ -643,7 +648,7 @@ function parseArrayArray<T extends unknown[][]>(data: string): T {
 }
 
 // @ts-ignore
-export function parseObjectArray<T extends unknown[]>(data: string): T {
+@inline export function parseObjectArray<T extends unknown[]>(data: string): T {
     const result = instantiate<T>();
     let char = 0;
     let lastPos: u32 = 1;
@@ -665,4 +670,4 @@ export function parseObjectArray<T extends unknown[]>(data: string): T {
         }
     }
     return result;
-}
+}