json-as 0.5.54 → 0.5.57

package/assembly/src/json.ts

@@ -20,8 +20,11 @@ import {
   trueWord,
   uCode,
   emptyArrayWord,
+  falseWord,
+  newLineCode,
 } from "./chars";
 import { snip_fast, unsafeCharCodeAt } from "./util";
+import { Virtual } from "as-virtual/assembly";
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
@@ -138,208 +141,174 @@ export namespace JSON {
       );
     }
   }
-  // @ts-ignore: Decorator
-  @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 += '"';
+}
+
+// @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: Decorator
 @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 = '"';
+  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: Decorator
 @inline function parseString(data: string): string {
-  let result = "";
+  let result = new StringSink();
   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.write(data, last, i - 1);
       if (char === 34) {
-        result += '"';
+        result.writeCodePoint(quoteCode);
         last = i + 1;
       } else if (char >= 92 && char <= 117) {
         switch (char) {
           case 92: {
-            result += "\\";
+            result.writeCodePoint(backSlashCode);
             last = i + 1;
             break;
           }
           case 98: {
-            result += "\b";
+            result.write("\b");
             last = i + 1;
             break;
           }
           case 102: {
-            result += "\f";
+            result.write("\f");
             last = i + 1;
             break;
           }
           case 110: {
-            result += "\n";
+            result.writeCodePoint(newLineCode);
             last = i + 1;
             break;
           }
           case 114: {
-            result += "\r";
+            result.write("\r");
             last = i + 1;
             break;
           }
           case 116: {
-            result += "\t";
+            result.write("\t");
             last = i + 1;
             break;
           }
@@ -349,7 +318,7 @@ export namespace JSON {
               load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) ===
               27584753879220272
             ) {
-              result += "\u000b";
+              result.write("\u000b");
               i += 4;
               last = i + 1;
             }
@@ -359,8 +328,8 @@ export namespace JSON {
       }
     }
   }
-  result += data.slice(last, data.length - 1);
-  return result;
+  if ((data.length - 1) > last) result.write(data, last, data.length - 1);
+  return result.toString();
 }
 
 // @ts-ignore: Decorator
@@ -371,7 +340,7 @@ export namespace JSON {
 }
 
 // @ts-ignore: Decorator
-@inline export function parseNumber<T>(data: string): T {
+@inline function parseNumber<T>(data: string): T {
   if (isInteger<T>()) {
     // @ts-ignore
     return snip_fast<T>(data);
@@ -389,7 +358,7 @@ export namespace JSON {
   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 outerLoopIndex = 1;
@@ -409,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;
@@ -433,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;
@@ -455,14 +418,11 @@ export namespace JSON {
           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;
@@ -471,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 &&
@@ -480,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 &&
@@ -490,7 +450,7 @@ 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;
@@ -498,10 +458,7 @@ export namespace JSON {
         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;
@@ -639,7 +596,7 @@ export namespace JSON {
 }
 
 // @ts-ignore: Decorator
-@inline export function parseObjectArray<T extends unknown[]>(data: string): T {
+@inline function parseObjectArray<T extends unknown[]>(data: string): T {
   const result = instantiate<T>();
   let lastPos: u32 = 1;
   let depth: u32 = 0;

package/assembly/src/util.ts

@@ -107,19 +107,19 @@ import { backSlashCode, quoteCode } from "./chars";
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return -(val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+              return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) as T;
+              return -(val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
             }
           } else if (high > 57) {
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return -(val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+              return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(val * (10 ** (atoi_fast<u32>(str, offset + 4) + 1))) as T;
+              return -(val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
             }
           } else {
             val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
@@ -134,10 +134,10 @@ import { backSlashCode, quoteCode } from "./chars";
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return -(val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+            return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return -(val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) as T;
+            return -(val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
           }
         } else {
           val = (val * 10) + (ch - 48) as T;
@@ -156,17 +156,17 @@ import { backSlashCode, quoteCode } from "./chars";
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+              return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) as T;
+              return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
             }
           } else if (high > 57) {
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+              return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val * (10 ** (atoi_fast<u32>(str, offset + 4) + 1))) as T;
+              return (val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
             }
           } else {
             // Optimized with multiplications and shifts.
@@ -181,10 +181,10 @@ import { backSlashCode, quoteCode } from "./chars";
         // e is 101 and E is 69.
         if (ch > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            val = (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+            val = (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
           } else {
             // Inlined this operation instead of using a loop
-            val = (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) as T;
+            val = (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
           }
           return val as T;
         } else {
@@ -209,17 +209,17 @@ import { backSlashCode, quoteCode } from "./chars";
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+            return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) as T;
+            return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
           }
         } else if (high > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-            return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+            return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val * (10 ** (atoi_fast<u32>(str, offset + 4) + 1))) as T;
+            return (val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
           }
         } else {
           // Optimized with multiplications and shifts.
@@ -234,10 +234,10 @@ import { backSlashCode, quoteCode } from "./chars";
       // e is 101 and E is 69.
       if (ch > 57) {
         if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-          return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+          return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
         } else {
           // Inlined this operation instead of using a loop
-          return (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) as T;
+          return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
         }
       } else {
         val = (val * 10) + (ch - 48) as T;
@@ -252,34 +252,34 @@ import { backSlashCode, quoteCode } from "./chars";
  */
 
 // @ts-ignore
-@inline export function atoi_fast<T extends number>(str: string, offset: u32 = 0): T {
+@global @inline export function __atoi_fast<T extends number>(str: string, start: u32 = 0, end: u32 = 0): T {
   // @ts-ignore
   let val: T = 0;
-  const len = u32(str.length << 1);
+  if (!end) end = start + u32(str.length << 1);
   if (isSigned<T>()) {
     // Negative path
-    if (load<u16>(changetype<usize>(str) + <usize>offset) === 45) {
-      offset += 2;
-      for (; offset < len; offset += 2) {
-        val = (val * 10) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48) as T;
+    if (load<u16>(changetype<usize>(str) + <usize>start) === 45) {
+      start += 2;
+      for (; start < end; start += 2) {
+        val = (val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48) as T;
       }
       return -val as T;
     } else {
-      for (; offset < len; offset += 2) {
-        val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48)) as T;
+      for (; start < end; start += 2) {
+        val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
       }
       return val as T;
     }
   } else {
-    for (; offset < len; offset += 2) {
-      val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48)) as T;
+    for (; start < end; start += 2) {
+      val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
     }
     return val as T;
   }
 }
 
 /**
- * Parses an integer using atoi_fast and applies the appended exponential number to it as scientific notation.
+ * Parses an integer using __atoi_fast and applies the appended exponential number to it as scientific notation.
  * Benchmark: Hovers around 30m ops/s
  * Only safe if the string is valid.
  * @param str integer to parse. example: 123e1, 123e-1, 123E100
@@ -301,12 +301,12 @@ import { backSlashCode, quoteCode } from "./chars";
       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 {
         // @ts-ignore
-        val *= sciNote<T>(atoi_fast<T>(str, offset));
+        val *= sciNote<T>(__atoi_fast<T>(str, offset));
         // @ts-ignore
         return val;
       }
@@ -336,4 +336,15 @@ import { backSlashCode, quoteCode } from "./chars";
   }
   // @ts-ignore
   return res;
+}
+
+// @ts-ignore
+@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;
+  if (p1_len == 2) {
+    return load<u16>(changetype<usize>(p1_data) + p1_start) == load<u16>(changetype<usize>(p2_data) + p2_start)
+  }
+  return memory.compare(changetype<usize>(p1_data) + p1_start, changetype<usize>(p2_data) + p2_start, p1_len) === 0;
 }