json-as 0.5.52 → 0.5.56

package/assembly/src/json.ts

@@ -20,8 +20,10 @@ import {
   trueWord,
   uCode,
   emptyArrayWord,
+  falseWord,
 } from "./chars";
 import { snip_fast, unsafeCharCodeAt } from "./util";
+import { Virtual } from "as-virtual/assembly";
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
@@ -35,14 +37,11 @@ export namespace JSON {
    * @param data T
    * @returns string
    */
-  // @ts-ignore
-  @inline export function stringify<
-    T
-  >(data: T): string {
+  // @ts-ignore: Decorator
+  @inline export function stringify<T>(data: T): string {
     // String
     if (isString<T>() && data != null) {
-      // @ts-ignore
-      return serializeString(data);
+      return serializeString(data as string);
     } else if (isBoolean<T>()) {
       return data ? "true" : "false";
     } else if (isNullable<T>() && data == null) {
@@ -51,9 +50,9 @@ export namespace JSON {
     } else if ((isInteger<T>() || isFloat<T>()) && isFinite(data)) {
       // @ts-ignore
       return data.toString();
-      // @ts-ignore
+      // @ts-ignore: Hidden function
     } else if (isDefined(data.__JSON_Serialize)) {
-      // @ts-ignore
+      // @ts-ignore: Hidden function
       return data.__JSON_Serialize();
     } else if (data instanceof Date) {
       return data.toISOString();
@@ -110,10 +109,8 @@ export namespace JSON {
    * @returns T
    */
 
-  // @ts-ignore
-  @inline export function parse<
-    T
-  >(data: string): T {
+  // @ts-ignore: Decorator
+  @inline export function parse<T>(data: string): T {
     let type: T;
     if (isString<T>()) {
       // @ts-ignore
@@ -143,176 +140,136 @@ export namespace JSON {
       );
     }
   }
-  // @ts-ignore
-  @inline function parseObjectValue<
-    T
-  >(data: string): T {
-    let type: T;
-    if (isString<T>()) {
-      // @ts-ignore
-      let result = "";
-      let last = 0;
-      let char = 0;
-      for (let i = 0; i < data.length; i++) {
-        // \\"
-        if (unsafeCharCodeAt(data, i) === backSlashCode) {
-          char = unsafeCharCodeAt(data, ++i);
-          result += data.slice(last, i - 1);
-          if (char === 34) {
-            result += '"';
+}
+
+// @ts-ignore: Decorator
+@global @inline function __parseObjectValue<T>(data: string): T {
+  let type: T;
+  if (isString<T>()) {
+    // @ts-ignore
+    let result = "";
+    let last = 0;
+    for (let i = 0; i < data.length; i++) {
+      // \\"
+      if (unsafeCharCodeAt(data, i) === backSlashCode) {
+        const char = unsafeCharCodeAt(data, ++i);
+        result += data.slice(last, i - 1);
+        if (char === 34) {
+          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 === 110) {
-            result += "\n";
+          } 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;
-            // 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;
-            }
           }
         }
       }
-      result += data.slice(last);
-      // @ts-ignore
-      return result;
-    } else if (isBoolean<T>()) {
-      // @ts-ignore
-      return parseBoolean<T>(data);
-    } else if (isFloat<T>() || isInteger<T>()) {
-      return parseNumber<T>(data);
-    } else if (isArrayLike<T>()) {
-      // @ts-ignore
-      return parseArray<T>(data);
-      // @ts-ignore
-    } else if (isNullable<T>() && data == "null") {
-      // @ts-ignore
-      return null;
-      // @ts-ignore
-    } else if (isDefined(type.__JSON_Set_Key)) {
-      return parseObject<T>(data.trimStart());
-    } else if (idof<nonnull<T>>() == idof<Date>()) {
-      // @ts-ignore
-      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.`
-      );
     }
+    result += data.slice(last);
+    // @ts-ignore
+    return result;
+  } else if (isBoolean<T>()) {
+    // @ts-ignore
+    return parseBoolean<T>(data);
+  } else if (isFloat<T>() || isInteger<T>()) {
+    return parseNumber<T>(data);
+  } else if (isArrayLike<T>()) {
+    // @ts-ignore
+    return parseArray<T>(data);
+    // @ts-ignore
+  } else if (isNullable<T>() && data == "null") {
+    // @ts-ignore
+    return null;
+    // @ts-ignore
+  } else if (isDefined(type.__JSON_Set_Key)) {
+    return parseObject<T>(data.trimStart());
+  } else if (idof<nonnull<T>>() == idof<Date>()) {
+    // @ts-ignore
+    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.`
+    );
   }
 }
 
-// @ts-ignore
-@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 result = '"';
+// @ts-ignore: Decorator
+@inline export function serializeString(data: string): string {
+  let result = new StringSink('"');
 
   let last: i32 = 0;
   // @ts-ignore
   for (let i = 0; i < data.length; i++) {
     const char = unsafeCharCodeAt(<string>data, i);
     if (char === 34 || char === 92) {
-      result += (<string>data).slice(last, i) + "\\";
+      result.write(<string>data, last, i);
+      result.writeCodePoint(backSlashCode);
       last = i;
       //i++;
     } else if (char <= 13 && char >= 8) {
-      result += (<string>data).slice(last, i);
+      result.write(<string>data, last, i);
       last = i + 1;
       switch (char) {
         case 8: {
-          result += "\\b";
+          result.write("\\b");
           break;
         }
         case 9: {
-          result += "\\t";
+          result.write("\\t");
           break;
         }
         case 10: {
-          result += "\\n";
+          result.write("\\n");
           break;
         }
         case 11: {
-          result += "\\x0B"; // \\u000b
+          result.write("\\x0B"); // \\u000b
           break;
         }
         case 12: {
-          result += "\\f";
+          result.write("\\f");
           break;
         }
         case 13: {
-          result += "\\r";
+          result.write("\\r");
           break;
         }
       }
     }
   }
   if (result.length === 1) return '"' + data + '"';
-  else result += (<string>data).slice(last);
-  return result + '"';
+  else result.write(<string>data, last);
+  result.write("\"");
+  return result.toString();
 }
 
-// @ts-ignore
-@inline function parseString(
-  data: string
-): string {
+// @ts-ignore: Decorator
+@inline function parseString(data: string): string {
   let result = "";
   let last = 1;
   for (let i = 1; i < data.length - 1; i++) {
@@ -375,16 +332,14 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline function parseBoolean<
-  T extends boolean
->(data: string): T {
+// @ts-ignore: Decorator
+@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
+// @ts-ignore: Decorator
 @inline export function parseNumber<T>(data: string): T {
   if (isInteger<T>()) {
     // @ts-ignore
@@ -398,25 +353,24 @@ export namespace JSON {
   else if (type instanceof f32) return f32.parse(data);
 }
 
-// @ts-ignore
+// @ts-ignore: Decorator
 @inline function parseObject<T>(data: string): T {
   let schema: nonnull<T> = changetype<nonnull<T>>(
     __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
   );
-  let key = "";
+  let key = Virtual.createEmpty<string>();
   let isKey = false;
   let depth = 0;
-  let char = 0;
   let outerLoopIndex = 1;
   for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
-    char = unsafeCharCodeAt(data, outerLoopIndex);
+    const char = unsafeCharCodeAt(data, outerLoopIndex);
     if (char === leftBracketCode) {
       for (
         let arrayValueIndex = outerLoopIndex;
         arrayValueIndex < data.length - 1;
         arrayValueIndex++
       ) {
-        char = unsafeCharCodeAt(data, arrayValueIndex);
+        const char = unsafeCharCodeAt(data, arrayValueIndex);
         if (char === leftBracketCode) {
           depth++;
         } else if (char === rightBracketCode) {
@@ -424,10 +378,7 @@ export namespace JSON {
           if (depth === 0) {
             ++arrayValueIndex;
             // @ts-ignore
-            schema.__JSON_Set_Key(
-              key,
-              data.slice(outerLoopIndex, arrayValueIndex)
-            );
+            schema.__JSON_Set_Key<Virtual<string>>(key, data, outerLoopIndex, arrayValueIndex);
             outerLoopIndex = arrayValueIndex;
             isKey = false;
             break;
@@ -440,7 +391,7 @@ export namespace JSON {
         objectValueIndex < data.length - 1;
         objectValueIndex++
       ) {
-        char = unsafeCharCodeAt(data, objectValueIndex);
+        const char = unsafeCharCodeAt(data, objectValueIndex);
         if (char === leftBraceCode) {
           depth++;
         } else if (char === rightBraceCode) {
@@ -448,10 +399,7 @@ export namespace JSON {
           if (depth === 0) {
             ++objectValueIndex;
             // @ts-ignore
-            schema.__JSON_Set_Key(
-              key,
-              data.slice(outerLoopIndex, objectValueIndex)
-            );
+            schema.__JSON_Set_Key<Virtual<string>>(key, data, outerLoopIndex, objectValueIndex);
             outerLoopIndex = objectValueIndex;
             isKey = false;
             break;
@@ -464,20 +412,17 @@ export namespace JSON {
         stringValueIndex < data.length - 1;
         stringValueIndex++
       ) {
-        char = unsafeCharCodeAt(data, stringValueIndex);
+        const char = unsafeCharCodeAt(data, stringValueIndex);
         if (
           char === quoteCode &&
           unsafeCharCodeAt(data, stringValueIndex - 1) !== backSlashCode
         ) {
           if (isKey === false) {
-            key = data.slice(outerLoopIndex, stringValueIndex);
+            key.reinst(data, outerLoopIndex, stringValueIndex);
             isKey = true;
           } else {
             // @ts-ignore
-            schema.__JSON_Set_Key(
-              key,
-              data.slice(outerLoopIndex, stringValueIndex)
-            );
+            schema.__JSON_Set_Key<Virtual<string>>(key, data, outerLoopIndex, stringValueIndex);
             isKey = false;
           }
           outerLoopIndex = ++stringValueIndex;
@@ -486,7 +431,7 @@ export namespace JSON {
       }
     } else if (char == nCode) {
       // @ts-ignore
-      schema.__JSON_Set_Key(key, nullWord);
+      schema.__JSON_Set_Key<Virtual<string>>(key, nullWord, 0, 4);
       isKey = false;
     } else if (
       char === tCode &&
@@ -495,7 +440,7 @@ export namespace JSON {
       unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
     ) {
       // @ts-ignore
-      schema.__JSON_Set_Key(key, trueWord);
+      schema.__JSON_Set_Key<Virtual<string>>(key, trueWord, 0, 4);
       isKey = false;
     } else if (
       char === fCode &&
@@ -505,18 +450,15 @@ export namespace JSON {
       unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
     ) {
       // @ts-ignore
-      schema.__JSON_Set_Key(key, "false");
+      schema.__JSON_Set_Key<Virtual<string>>(key, falseWord, 0, 5);
       isKey = false;
     } else if ((char >= 48 && char <= 57) || char === 45) {
       let numberValueIndex = ++outerLoopIndex;
       for (; numberValueIndex < data.length; numberValueIndex++) {
-        char = unsafeCharCodeAt(data, numberValueIndex);
+        const 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<Virtual<string>>(key, data, outerLoopIndex - 1, numberValueIndex);
           outerLoopIndex = numberValueIndex;
           isKey = false;
           break;
@@ -527,10 +469,8 @@ export namespace JSON {
   return schema;
 }
 
-// @ts-ignore
-@inline function parseArray<
-  T extends unknown[]
->(data: string): T {
+// @ts-ignore: Decorator
+@inline function parseArray<T extends unknown[]>(data: string): T {
   if (isString<valueof<T>>()) {
     return <T>parseStringArray(data);
   } else if (isBoolean<valueof<T>>()) {
@@ -558,10 +498,8 @@ export namespace JSON {
   return unreachable();
 }
 
-// @ts-ignore
-@inline function parseStringArray(
-  data: string
-): string[] {
+// @ts-ignore: Decorator
+@inline function parseStringArray(data: string): string[] {
   const result: string[] = [];
   let lastPos = 0;
   let instr = false;
@@ -579,15 +517,12 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline function parseBooleanArray<
-  T extends boolean[]
->(data: string): T {
+// @ts-ignore: Decorator
+@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);
+    const char = unsafeCharCodeAt(data, i);
     /*// if char == "t" && i+3 == "e"
                 if (char === tCode && data.charCodeAt(i + 3) === eCode) {
                   //i += 3;
@@ -608,16 +543,13 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline function parseNumberArray<
-  T extends number[]
->(data: string): T {
+// @ts-ignore: Decorator
+@inline function parseNumberArray<T extends number[]>(data: string): T {
   const result = instantiate<T>();
   let lastPos = 0;
-  let char = 0;
   let i = 1;
   for (; i < data.length - 1; i++) {
-    char = unsafeCharCodeAt(data, i);
+    const char = unsafeCharCodeAt(data, i);
     if ((lastPos === 0 && char >= 48 && char <= 57) || char === 45) {
       lastPos = i;
     } else if ((isSpace(char) || char == commaCode) && lastPos > 0) {
@@ -626,7 +558,7 @@ export namespace JSON {
     }
   }
   for (; i > lastPos - 1; i--) {
-    char = unsafeCharCodeAt(data, i);
+    const char = unsafeCharCodeAt(data, i);
     if (char !== rightBracketCode) {
       result.push(parseNumber<valueof<T>>(data.slice(lastPos, i + 1)));
       break;
@@ -635,12 +567,9 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline function parseArrayArray<
-  T extends unknown[][]
->(data: string): T {
+// @ts-ignore: Decorator
+@inline function parseArrayArray<T extends unknown[][]>(data: string): T {
   const result = instantiate<T>();
-  let char = 0;
   let lastPos = 0;
   let depth = 0;
   let i = 1;
@@ -648,7 +577,7 @@ export namespace JSON {
   //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) {}
   //i++;
   for (; i < data.length - 1; i++) {
-    char = unsafeCharCodeAt(data, i);
+    const char = unsafeCharCodeAt(data, i);
     if (char === leftBracketCode) {
       if (depth === 0) {
         lastPos = i;
@@ -666,16 +595,13 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline export function parseObjectArray<
-  T extends unknown[]
->(data: string): T {
+// @ts-ignore: Decorator
+@inline export function parseObjectArray<T extends unknown[]>(data: string): T {
   const result = instantiate<T>();
-  let char = 0;
   let lastPos: u32 = 1;
   let depth: u32 = 0;
   for (let pos: u32 = 0; pos < <u32>data.length; pos++) {
-    char = unsafeCharCodeAt(data, pos);
+    const char = unsafeCharCodeAt(data, pos);
     if (char === leftBraceCode) {
       if (depth === 0) {
         lastPos = pos;