json-as 0.5.37 → 0.5.38

package/assembly/src/json.ts

@@ -1,5 +1,5 @@
 import { StringSink } from "as-string-sink/assembly";
-import { isSpace } from "util/string";
+import { isSpace, CharCode } from "util/string";
 import {
     backSlashCode,
     commaCode,
@@ -19,7 +19,7 @@ import {
     tCode,
     trueWord,
     uCode,
-    emptyArrayWord
+    emptyArrayWord,
 } from "./chars";
 import { parseSciInteger, unsafeCharCodeAt } from "./util";
 
@@ -35,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
@@ -93,7 +94,9 @@ export namespace JSON {
                 return result.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.`
+            );
         }
     }
     /**
@@ -104,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
@@ -130,11 +134,13 @@ export namespace JSON {
             return Date.fromString(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
@@ -145,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";
@@ -169,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;
@@ -200,52 +210,52 @@ export namespace JSON {
             return Date.fromString(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 "\"\"";
-   /*
-    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 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;
     // @ts-ignore
@@ -259,50 +269,49 @@ function serializeString(data: string): string {
             result += (<string>data).slice(last, i);
             last = ++i;
             switch (char) {
-                /*case 0x5C: {
-                    result += "\\\\";
-                    break;
-                }*/
-                case 0x08: {
+                case 8: {
                     result += "\\b";
                     break;
                 }
-                case 0x0D: {
-                    result += "\\r";
+                case 9: {
+                    result += "\\t";
                     break;
                 }
-                case 0x09: {
-                    result += "\\t";
+                case 10: {
+                    result += "\\n";
                     break;
                 }
-                case 0x0C: {
+                case 11: {
+                    result += "\\x0B"; // \\u000b
+                    break;
+                }
+                case 12: {
                     result += "\\f";
                     break;
                 }
-                case 0x0B: {
-                    result += "\\u000b";
+                case 13: {
+                    result += "\\r";
                     break;
                 }
             }
         }
-    }// 8 10 13 9 12
-    if (result.length === 1) return "\"" + data + "\"";
+    }
+    if (result.length === 1) return '"' + data + '"';
     else result += (<string>data).slice(last);
-    return result + "\"";
+    return result + '"';
 }
 
 // @ts-ignore
-@inline
-function parseString(data: string): string {
+@inline function parseString(data: string): string {
     let result = "";
     let last = 1;
     for (let i = 1; i < data.length - 1; i++) {
         // \\"
         if (unsafeCharCodeAt(data, i) === backSlashCode) {
             const 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";
@@ -320,6 +329,10 @@ function parseString(data: string): string {
                         last = ++i;
                         break;
                     }
+                    case 110: {
+                        result += "\n";
+                        last = ++i;
+                    }
                     case 102: {
                         result += "\f";
                         last = ++i;
@@ -336,7 +349,11 @@ function parseString(data: string): string {
                         break;
                     }
                     default: {
-                        if (char === 117 && load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) === 27584753879220272) {
+                        if (
+                            char === 117 &&
+                            load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) ===
+                            27584753879220272
+                        ) {
                             result += "\u000b";
                             i += 4;
                             last = ++i;
@@ -352,17 +369,14 @@ 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 parseSciInteger<T>(data);
@@ -376,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;
@@ -400,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;
@@ -421,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;
@@ -444,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;
@@ -480,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;
@@ -492,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>>()) {
@@ -508,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
@@ -520,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;
@@ -540,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) {
@@ -568,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;
@@ -594,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;
@@ -624,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;
@@ -646,4 +670,4 @@ export function parseObjectArray<T extends unknown[]>(data: string): T {
         }
     }
     return result;
-}
+}

package/assembly/src/util.ts

@@ -1,5 +1,5 @@
 import { StringSink } from "as-string-sink/assembly";
-import { CharCode, isSpace } from "util/string";
+import { isSpace } from "util/string";
 import { backSlashCode, quoteCode } from "./chars";
 
 // @ts-ignore
@@ -8,6 +8,8 @@ export function unsafeCharCodeAt(data: string, pos: i32): i32 {
   return load<u16>(changetype<usize>(data) + ((<usize>pos) << 1));
 }
 
+// @ts-ignore
+@inline
 export function removeWhitespace(data: string): string {
   const result = new StringSink();
   let instr = false;
@@ -34,15 +36,24 @@ export function removeWhitespace(data: string): string {
 @inline
 export function escapeChar(char: string): string {
   switch (unsafeCharCodeAt(char, 0)) {
-    case 0x22: return '\\"';
-    case 0x5C: return "\\\\";
-    case 0x08: return "\\b";
-    case 0x0A: return "\\n";
-    case 0x0D: return "\\r";
-    case 0x09: return "\\t";
-    case 0x0C: return "\\f";
-    case 0x0B: return "\\u000b";
-    default: return char;
+    case 0x22:
+      return '\\"';
+    case 0x5c:
+      return "\\\\";
+    case 0x08:
+      return "\\b";
+    case 0x0a:
+      return "\\n";
+    case 0x0d:
+      return "\\r";
+    case 0x09:
+      return "\\t";
+    case 0x0c:
+      return "\\f";
+    case 0x0b:
+      return "\\u000b";
+    default:
+      return char;
   }
 }
 
@@ -51,6 +62,9 @@ export function escapeChar(char: string): string {
  * Suffers no overhead besides function calling and a if/else.
  * @returns depth of array
  */
+
+// @ts-ignore
+@inline
 export function getArrayDepth<T>(depth: i32 = 1): i32 {
   // @ts-ignore
   if (!isArray<T>()) {
@@ -68,15 +82,19 @@ export function getArrayDepth<T>(depth: i32 = 1): i32 {
 /**
  * Implementation of ATOI. Can be much much faster with SIMD.
  * Benchmark: 40-46m ops/s
-*/
-@unsafe
+ */
+
+// @ts-ignore
 @inline
 export function atoi_fast<T extends number>(str: string, offset: i32 = 0): T {
   // @ts-ignore
   let val: T = 0;
-  for (; offset < (str.length << 1); offset += 2) {
+  for (; offset < str.length << 1; offset += 2) {
     // @ts-ignore
-    val = (val << 1) + (val << 3) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48);
+    val =
+      (val << 1) +
+      (val << 3) +
+      (load<u16>(changetype<usize>(str) + <usize>offset) - 48);
     // We use load because in this case, there is no need to have bounds-checking
   }
   return val;
@@ -87,20 +105,22 @@ export function atoi_fast<T extends number>(str: string, offset: i32 = 0): T {
  * Benchmark: Hovers around 30m ops/s
  * Only safe if the string is valid.
  * @param str integer to parse. example: 123e1, 123e-1, 123E100
- * @returns 
+ * @returns
  */
+
+// @ts-ignore
 @inline
 export function parseSciInteger<T extends number>(str: string): T {
   // @ts-ignore
   let val: T = 0;
   let offset = 0;
-  for (; offset < (str.length << 1); offset += 2) {
+  for (; offset < str.length << 1; offset += 2) {
     const char = load<u16>(changetype<usize>(str) + <usize>offset);
     if (char === 101 || char === 69) {
       const char = load<u16>(changetype<usize>(str) + <usize>(offset += 2));
       if (char === 45) {
         // @ts-ignore
-        val /= sciNote<T>(atoi_fast<T>(str, offset += 2));
+        val /= sciNote<T>(atoi_fast<T>(str, (offset += 2)));
         // @ts-ignore
         return val;
       } else {
@@ -117,6 +137,8 @@ export function parseSciInteger<T extends number>(str: string): T {
   return val;
 }
 
+// @ts-ignore
+@inline
 function sciNote<T extends number>(num: T): T {
   let res = 1;
   if (num > 0) {
@@ -130,4 +152,4 @@ function sciNote<T extends number>(num: T): T {
   }
   // @ts-ignore
   return res;
-}
+}