json-as 0.5.51 → 0.5.52

package/LICENSE

@@ -1,21 +1,21 @@
-    MIT License
+MIT License
 
-    Copyright (c) 2023 Jairus Tanaka <jairus.v.tanaka@outlook.com>
+Copyright (c) 2023 Jairus Tanaka <jairus.v.tanaka@outlook.com>
 
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/assembly/__benches__/as-json.ts

@@ -1,6 +1,6 @@
 import { JSON } from "..";
 import { backSlashCode, quoteCode } from "../src/chars";
-import { atoi_fast, parseSciInteger, unsafeCharCodeAt } from "../src/util";
+import { atoi_fast, parseSciInteger, snip_fast, unsafeCharCodeAt } from "../src/util";
 import { HASH } from "util/hash";
 
 
@@ -66,15 +66,31 @@ const vec: Vec3 = {
   y: 1,
   z: 8,
 }
-/*
+
+bench("Parse Number SNIP", () => {
+  blackbox<i32>(snip_fast<i32>("12345"));
+});
+
+bench("Parse Number ATOI", () => {
+  blackbox<i32>(atoi_fast<i32>("12345"));
+})
+
+bench("Parse Number STDLIB", () => {
+  blackbox<i32>(i32.parse("12345"));
+});
+
+bench("Parse Number OLD", () => {
+  blackbox<i32>(parseSciInteger<i32>("12345"));
+});
+
 bench("Stringify Object (Vec3)", () => {
   blackbox<string>(vec.__JSON_Serialize());
 });
 
 // TODO: Make this allocate without crashing
-bench("Parse Object (Vec3)", () => {
+/*bench("Parse Object (Vec3)", () => {
   blackbox<Vec3>(vec.__JSON_Deserialize('{"x":0,"y":0,"z":0}', vec));
-});
+});*/
 
 bench("Stringify Number Array", () => {
   blackbox(JSON.stringify<i32[]>([1, 2, 3]));
@@ -87,7 +103,7 @@ bench("Parse Number Array", () => {
 bench("Stringify String", () => {
   blackbox(JSON.stringify(blackbox('Hello "World!')));
 });
-*/
+
 bench("Parse String", () => {
   blackbox(JSON.parse<string>(blackbox('"Hello "World!"')));
 });

package/assembly/__tests__/as-json.spec.ts

@@ -1,8 +1,8 @@
 import { JSON } from "..";
-function canSerde<T>(data: T): void {
-  const serialized = JSON.stringify<T>(data);
-  const deserialized = JSON.stringify<T>(JSON.parse<T>(serialized));
-  expect(serialized).toBe(deserialized);
+function canSerde<T>(data: T, toBe: string = ""): void {
+  if (!toBe) toBe = JSON.stringify<T>(data);
+  const deserialized = JSON.stringify<T>(JSON.parse<T>(JSON.stringify(data)));
+  expect(deserialized).toBe(toBe);
 }
 
 // @ts-ignore
@@ -53,16 +53,13 @@ describe("Ser/de Numbers", () => {
   });
 
   it("should ser/de floats", () => {
-    canSerde<f64>(7.23);
-    canSerde<f64>(10e2);
-    canSerde<f64>(10e2);
+    canSerde<f64>(7.23, "7.23");
+    canSerde<f64>(10e2, "1000.0");
 
-    canSerde<f64>(123456e-5);
+    canSerde<f64>(123456e-5, "1.23456");
 
-    canSerde<f64>(123456e-5);
-
-    canSerde<f64>(0.0);
-    canSerde<f64>(7.23);
+    canSerde<f64>(0.0, "0.0");
+    canSerde<f64>(7.23, "7.23");
   });
 
   it("should ser/de booleans", () => {
@@ -161,6 +158,6 @@ describe("Ser/de Objects", () => {
         z: 8.3,
       },
       isVerified: true,
-    });
+    }, '{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}');
   });
 });

package/assembly/src/json.ts

@@ -1,5 +1,5 @@
 import { StringSink } from "as-string-sink/assembly";
-import { isSpace, CharCode } from "util/string";
+import { isSpace } from "util/string";
 import {
   backSlashCode,
   commaCode,
@@ -21,7 +21,7 @@ import {
   uCode,
   emptyArrayWord,
 } from "./chars";
-import { parseSciInteger, unsafeCharCodeAt } from "./util";
+import { snip_fast, unsafeCharCodeAt } from "./util";
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
@@ -184,7 +184,7 @@ export namespace JSON {
             } else if (
               char === 117 &&
               load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) ===
-                27584753879220272
+              27584753879220272
             ) {
               result += "\u000b";
               i += 4;
@@ -359,7 +359,7 @@ export namespace JSON {
             if (
               char === 117 &&
               load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) ===
-                27584753879220272
+              27584753879220272
             ) {
               result += "\u000b";
               i += 4;
@@ -385,12 +385,10 @@ export namespace JSON {
 }
 
 // @ts-ignore
-@inline export function parseNumber<
-  T
->(data: string): T {
+@inline export function parseNumber<T>(data: string): T {
   if (isInteger<T>()) {
     // @ts-ignore
-    return parseSciInteger<T>(data);
+    return snip_fast<T>(data);
   }
   // @ts-ignore
   const type: T = 0;
@@ -401,9 +399,7 @@ export namespace JSON {
 }
 
 // @ts-ignore
-@inline function parseObject<
-  T
->(data: string): T {
+@inline function parseObject<T>(data: string): T {
   let schema: nonnull<T> = changetype<nonnull<T>>(
     __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
   );

package/assembly/src/util.ts

@@ -1,5 +1,5 @@
 import { StringSink } from "as-string-sink/assembly";
-import { isSpace } from "util/string";
+import { CharCode, isSpace } from "util/string";
 import { backSlashCode, quoteCode } from "./chars";
 
 // @ts-ignore
@@ -79,6 +79,159 @@ export function getArrayDepth<T>(depth: i32 = 1): i32 {
   }
 }
 
+// Scientific Notation Integer Parsing - SNIP
+// This is absolutely the fastest algorithm I could think of while adding full support for Scientific Notation
+// Loads 32 bits and retrieves the high/low bits
+// Here are some benchmarks
+// Parsing: "12345"
+// Results are spread over 5000ms
+// SNIP: 207M iterations
+// ATOI: 222M iterations
+// STD (parseInt): 162M iterations
+export function snip_fast<T extends number>(str: string, offset: u32 = 0): T {
+  let ch: u32 = load<u32>(changetype<usize>(str));
+  const h = ch & 0xFFFF;
+  if (h === 48) return 0 as T;
+  const isNegative = h === 45; // Check if the number is negative
+  let val: T = 0 as T;
+  const len = u32(str.length << 1);
+  if (isNegative) {
+    if ((ch >> 16) === 48) return -0 as T;
+    offset += 2;
+    if (len >= 4) {
+      // 32-bit route
+      for (; offset < (len - 3); offset += 4) {
+        ch = load<u32>(changetype<usize>(str) + <usize>offset);
+        const low = ch & 0xFFFF;
+        const high = ch >> 16;
+        // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
+        if (low > 57) {
+          // The first char (f) is E or e
+          // We push the offset up by two and apply the notation.
+          offset += 2;
+          let exp: i32 = atoi_fast<i32>(str, offset);
+          if (exp < 0) {
+            for (let i = 0; i < exp; i++) {
+              val = (val / 10) as T;
+            }
+          } else {
+            for (let i = 0; i < exp; i++) {
+              val = (val * 10) as T;
+            }
+          }
+          return -val 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.
+          offset += 4;
+          let exp: i32 = atoi_fast<i32>(str, offset);
+          if (exp < 0) {
+            for (let i = 0; i < exp; i++) {
+              val = (val / 10) as T;
+            }
+          } else {
+            for (let i = 0; i < exp; i++) {
+              val = (val * 10) as T;
+            }
+          }
+          return -val as T;
+        } else {
+          val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+        }
+      }
+    }
+    // Finish up the remainder with 16 bits.
+    for (; offset < len; offset += 2) {
+      ch = load<u16>(changetype<usize>(str) + <usize>offset);
+      // 9 is 57. E and e are larger. Assumes valid JSON.
+      if (ch > 57) {
+        // The first char (f) is E or e
+        // We push the offset up by two and apply the notation.
+        offset += 2;
+        let exp: i32 = atoi_fast<i32>(str, offset);
+        if (exp < 0) {
+          for (let i = 0; i > exp; i--) {
+            val = (val / 10) as T;
+          }
+        } else {
+          for (let i = 0; i < exp; i++) {
+            val = (val * 10) as T;
+          }
+        }
+        return -val as T;
+      } else {
+        val = (val * 10) + (ch - 48) as T;
+      }
+    }
+    return -val as T;
+  } else {
+    if (len >= 4) {
+      // Duplet 16 bit lane load
+      for (; offset < (len - 3); offset += 4) {
+        ch = load<u32>(changetype<usize>(str) + <usize>offset);
+        const low = ch & 0xFFFF;
+        const high = ch >> 16;
+        // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
+        if (low > 57) {
+          // The first char (f) is E or e
+          // We push the offset up by two and apply the notation.
+          offset += 2;
+          let exp: i32 = atoi_fast<i32>(str, offset);
+          if (exp < 0) {
+            for (let i = 0; i < exp; i++) {
+              val = (val / 10) as T;
+            }
+          } else {
+            for (let i = 0; i < exp; i++) {
+              val = (val * 10) as T;
+            }
+          }
+          return val as T;
+        } else if (high > 57) {
+          offset += 4;
+          let exp: i32 = atoi_fast<i32>(str, offset);
+          if (exp < 0) {
+            for (let i = 0; i < exp; i++) {
+              val = (val / 10) as T;
+            }
+          } else {
+            for (let i = 0; i < exp; i++) {
+              val = (val * 10) as T;
+            }
+          }
+          return val as T;
+        } else {
+          // Optimized with multiplications and shifts.
+          val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+        }
+      }
+    }
+    // Cover the remaining numbers with 16 bit loads.
+    for (; offset < len; offset += 2) {
+      ch = load<u16>(changetype<usize>(str) + <usize>offset);
+      // 0's char is 48 and 9 is 57. Anything above this range would signify an exponent (e or E).
+      // e is 101 and E is 69.
+      if (ch > 57) {
+        offset += 2;
+        let exp: i32 = atoi_fast<i32>(str, offset);
+        if (exp < 0) {
+          for (let i = 0; i > exp; i--) {
+            val = (val / 10) as T;
+          }
+        } else {
+          for (let i = 0; i < exp; i++) {
+            val = (val * 10) as T;
+          }
+        }
+        return val as T;
+      } else {
+        val = (val * 10) + (ch - 48) as T;
+      }
+    }
+    return val as T;
+  }
+}
+
 /**
  * Implementation of ATOI. Can be much much faster with SIMD.
  * Benchmark: 40-46m ops/s
@@ -86,33 +239,25 @@ export function getArrayDepth<T>(depth: i32 = 1): i32 {
 
 // @ts-ignore
 @inline
-export function atoi_fast<T extends number>(str: string, offset: i32 = 0): T {
+export function atoi_fast<T extends number>(str: string, offset: u32 = 0): T {
   // @ts-ignore
   let val: T = 0;
-  let firstChar = load<u16>(changetype<usize>(str) + <usize>offset);
-  if (firstChar === 45) {
+  const len = u32(str.length << 1);
+  if (load<u16>(changetype<usize>(str) + <usize>offset) === 45) {
     offset += 2;
-    for (; offset < str.length << 1; offset += 2) {
+    for (; offset < len; offset += 2) {
       // @ts-ignore
-      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
+      val = (val << 1) + (val << 3) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48);
     }
     // @ts-ignore
-    val = -val;
+    return -val;
   } else {
-    for (; offset < str.length << 1; offset += 2) {
+    for (; offset < len; offset += 2) {
       // @ts-ignore
-      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
+      val = (val << 1) + (val << 3) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48);
     }
+    return val;
   }
-  return val;
 }
 
 /**
@@ -164,15 +309,15 @@ export function parseSciInteger<T extends number>(str: string): T {
 function sciNote<T extends number>(num: T): T {
   let res = 1;
   // @ts-ignore
-    if (num > 0) {
-      for (let i: T = 0; i < num; i++) {
-        res *= 10;
-      }
-    } else {
-      for (let i: T = 0; i < num; i++) {
-        res /= 10;
-      }
+  if (num > 0) {
+    for (let i: T = 0; i < num; i++) {
+      res *= 10;
     }
+  } else {
+    for (let i: T = 0; i < num; i++) {
+      res /= 10;
+    }
+  }
   // @ts-ignore
   return res;
 }

package/assembly/test.ts

@@ -1,13 +1,11 @@
-import { JSON } from "./src/json";
-import { atoi_fast, parseSciInteger } from "./src/util";
-import * as a from "util/number";
-// "st\"ring\" w\"\"ith quotes\""
+import { snip_fast } from "./src/util";
 
+import { JSON } from "./src/json";
 @json
 class Vec3 {
-  x!: f32;
-  y!: f32;
-  z!: f32;
+  x!: f64;
+  y!: f64;
+  z!: f64;
 }
 
 @json
@@ -39,6 +37,29 @@ const vec: Vec3 = {
   z: 8,
 };
 
+function canSerde<T>(data: T, toBe: string = ""): void {
+  if (!toBe) toBe = JSON.stringify<T>(data);
+  const deserialized = JSON.stringify<T>(JSON.parse<T>(JSON.stringify(data)));
+  if (deserialized != toBe) {
+    console.log("Expected: " + toBe);
+    console.log("Actual:   " + deserialized);
+  } else {
+    console.log("Passed Test")
+  }
+}
+
+canSerde<Player>({
+  firstName: "Emmet",
+  lastName: "West",
+  lastActive: [8, 27, 2022],
+  age: 23,
+  pos: {
+    x: 3.4,
+    y: 1.2,
+    z: 8.3,
+  },
+  isVerified: true,
+}, '{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}');
 const serializedPlayer = JSON.stringify<Player>(player);
 console.log(serializedPlayer);
 const parsedPlayer = JSON.parse<Player>(serializedPlayer);
@@ -50,230 +71,19 @@ console.log(serializedVec3);
 const parsedVec3 = JSON.parse<Vec3>(serializedVec3);
 console.log(JSON.stringify(parsedVec3));
 
-console.log("atoi:");
-console.log("123 - " + parseSciInteger<i32>("123").toString());
-console.log("1230 - " + parseSciInteger<i32>("123e1").toString());
-console.log("12300 - " + parseSciInteger<i32>("123e2").toString());
-console.log("123000 - " + parseSciInteger<i32>("123e3").toString());
-console.log("12 - " + parseSciInteger<i32>("123e-1").toString());
-console.log(parseSciInteger<i32>("100").toString());
-console.log(parseSciInteger<i32>("-100").toString());
-
-console.log(JSON.stringify("abcdefg"));
-console.log('"abcdefg"')
-console.log(JSON.stringify('st"ring" w""ith quotes"'));
-console.log('"st\\"ring\\" w\\"\\"ith quotes\\""')
-console.log(JSON.stringify(['string "with random spa\nces and \nnewlines\n\n\n']));
-console.log(JSON.stringify(JSON.parse<string[]>(JSON.stringify(['string "with random spa\nces and \nnewlines\n\n\n']))));
-console.log('"string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"')
-console.log(JSON.stringify('string with colon : comma , brace [ ] bracket { } and quote " and other quote "'));
-/*console.log(JSON.stringify(JSON.parse<string[]>(JSON.stringify([
-  "abcdefg",
-  'st"ring" w""ith quotes"',
-  'string \t\r"with ran\tdom spa\nces and \nnewlines\n\n\n',
-  'string with colon : comma , brace [ ] bracket { } and quote " and other quote "',
-]))));
-console.log('["abcdefg","st\"ring\" w\"\"ith quotes\"","string \t\r\"with ran\tdom spa\nces and \nnewlines\n\n\n","string with colon : comma , brace [ ] bracket { } and quote \" and other quote \""]');/*
-console.log(
-  JSON.stringify(
-    JSON.parse<string[]>(
-      JSON.stringify([
-        "abcdefg",
-        'st"ring" w""ith quotes"',
-        'string \t\r"with ran\tdom spa\nces and \nnewlines\n\n\n',
-        'string with colon : comma , brace [ ] bracket { } and quote " and other quote "',
-      ])
-    )
-  )
-);
-/*
-const str = changetype<string>(new ArrayBuffer(6));
-console.log("istr:");
-console.log("123 - " + istr8(123));
-console.log("32 - " + istr8(32));
-console.log("3 - " + istr8(3));
-
-console.log(Uint8Array.wrap(changetype<ArrayBuffer>(istr8(12))).join(" "));
-console.log(load<u32>(changetype<usize>(istr8(12))).toString());
-@inline function istr8<
-  T extends number
->(int: T): string {
-  if (int >= 100) {
-    const str = changetype<string>(__new(6, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 4);
-    return str;
-  } else if (int >= 10) {
-    const str = changetype<string>(__new(4, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 2);
-    return str;
-  } else {
-    const str = changetype<string>(__new(2, idof<String>()));
-    store<u16>(changetype<usize>(str), (int % 10) + 48);
-    return str;
-  }
-}
-
-export function istr16<T extends number>(int: T): string {
-  if (int >= 10_000) {
-    const str = changetype<string>(__new(10, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 10000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 6);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 8);
-    return str;
-  } else if (int >= 1_000) {
-    const str = changetype<string>(__new(8, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 6);
-    return str;
-  } else if (int >= 100) {
-    const str = changetype<string>(__new(6, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 4);
-    return str;
-  } else if (int >= 10) {
-    const str = changetype<string>(__new(4, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 2);
-    return str;
-  } else {
-    const str = changetype<string>(__new(2, idof<String>()));
-    store<u16>(changetype<usize>(str), (int % 10) + 48);
-    return str;
-  }
-}
-
-export function istr32<T extends number>(int: T): string {
-  if (int >= 1_000_000_000) {
-    const str = changetype<string>(__new(22, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 10000000000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 1000000000) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 100000000) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), ((int / 10000000) % 10) + 48, 6);
-    store<u16>(changetype<usize>(str), ((int / 1000000) % 10) + 48, 8);
-    store<u16>(changetype<usize>(str), ((int / 100000) % 10) + 48, 10);
-    store<u16>(changetype<usize>(str), ((int / 10000) % 10) + 48, 12);
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48, 14);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 16);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 18);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 20);
-    return str;
-  } else if (int >= 100_000_000) {
-    const str = changetype<string>(__new(20, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 1000000000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 100000000) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 10000000) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), ((int / 1000000) % 10) + 48, 6);
-    store<u16>(changetype<usize>(str), ((int / 100000) % 10) + 48, 8);
-    store<u16>(changetype<usize>(str), ((int / 10000) % 10) + 48, 10);
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48, 12);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 14);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 16);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 18);
-    return str;
-  } else if (int >= 10_000_000) {
-    const str = changetype<string>(__new(18, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 100000000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 10000000) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 1000000) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), ((int / 100000) % 10) + 48, 6);
-    store<u16>(changetype<usize>(str), ((int / 10000) % 10) + 48, 8);
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48, 10);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 12);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 14);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 16);
-    return str;
-  } else if (int >= 10_000_000) {
-    const str = changetype<string>(__new(16, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 10000000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 1000000) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 100000) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), ((int / 10000) % 10) + 48, 6);
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48, 8);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 10);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 12);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 14);
-    return str;
-  } else if (int >= 1_000_000) {
-    const str = changetype<string>(__new(14, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 1000000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 100000) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 10000) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48, 6);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 8);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 10);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 12);
-    return str;
-  } else if (int >= 100_000) {
-    const str = changetype<string>(__new(12, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 100000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 10000) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 6);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 8);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 10);
-    return str;
-  } else if (int >= 10_000) {
-    const str = changetype<string>(__new(10, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 10000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 6);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 8);
-    return str;
-  } else if (int >= 1_000) {
-    const str = changetype<string>(__new(8, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 1000) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 4);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 6);
-    return str;
-  } else if (int >= 100) {
-    const str = changetype<string>(__new(6, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 4);
-    return str;
-  } else if (int >= 10) {
-    const str = changetype<string>(__new(4, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 2);
-    return str;
-  } else {
-    const str = changetype<string>(__new(2, idof<String>()));
-    store<u16>(changetype<usize>(str), (int % 10) + 48);
-    return str;
-  }
-}
-
-export function istr64<T extends number>(int: T): string {
-  const val = new ArrayBuffer(6);
-  store<u16>(changetype<usize>(val), (int % 10) + 48, 4);
-  if ((int = (int / 10) as T) > 0)
-    store<u16>(changetype<usize>(val), (int % 10) + 48, 2);
-  else return changetype<string>(val);
-  if ((int = (int / 10) as T) > 0)
-    store<u16>(changetype<usize>(val), (int % 10) + 48);
-  return changetype<string>(val);
-}
-
-// 0 = 48
-// 1 = 49
-// 2 = 50
-// 3 = 51
-// 4 = 52
-// 5 = 53
-// 6 = 54
-// 7 = 55
-// 8 = 56
-// 9 = 57
-
-console.log(JSON.stringify("h\\i from gray\bson"));
-*/
+console.log("snip:");
+console.log("1234 <-> " + snip_fast<i32>("1234").toString());
+console.log("-1234 <-> " + snip_fast<i32>("-1234").toString());
+console.log("12340 <-> " + snip_fast<i32>("1234e1").toString());
+console.log("123400 <-> " + snip_fast<i32>("1234e2").toString());
+console.log("1234000 <-> " + snip_fast<i32>("1234e3").toString());
+console.log("12 <-> " + snip_fast<i32>("123e-1").toString());
+console.log("123 <-> " + snip_fast<i32>("123").toString());
+console.log("-12340 <-> " + snip_fast<i32>("-1234e1").toString());
+console.log("-1234500 <-> " + snip_fast<i32>("-12345e2").toString());
+console.log("-123456000 <-> " + snip_fast<i32>("-123456e3").toString());
+console.log("-12 <-> " + snip_fast<i32>("-123e-1").toString());
+console.log("-123 <-> " + snip_fast<i32>("-123").toString());
+console.log(snip_fast<i32>("1000").toString());
+console.log(snip_fast<i32>("-1000").toString());
+console.log(JSON.stringify([[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]]));

package/bench.js

@@ -1,7 +1,5 @@
 import { Bench } from "tinybench";
 // Trying a new benchmarking lib.
-// It seems to not warmup long at all, so its probably bad.
-// benchmark will probably be best here
 
 // JavaScript Results
 // ┌─────────┬───────────────────────────┬─────────────┬────────────────────┬──────────┬─────────┐
@@ -35,7 +33,7 @@ const vec = {
 
 let data;
 
-const bench = new Bench({ time: 100 })
+const bench = new Bench({ time: 1000 })
 
     .add("Stringify Object (Vec3)", () => {
         data = JSON.stringify(vec);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.5.51",
+  "version": "0.5.52",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -14,8 +14,8 @@
   "license": "MIT",
   "scripts": {
     "aspect": "asp",
-    "bench:astral": "astral -Ospeed --noAssert --uncheckedBehavior always --runtime minimal",
-    "build:test": "asc assembly/test.ts --target test --runtime stub",
+    "bench:astral": "astral -Ospeed --noAssert --uncheckedBehavior always --runtime stub",
+    "build:test": "asc assembly/test.ts --target test",
     "build:transform": "tsc -p ./transform",
     "test:wasmtime": "wasmtime ./build/test.wasm",
     "test:lunatic": "lunatic ./build/test.wasm",
@@ -26,8 +26,11 @@
     "@as-pect/cli": "^8.0.1",
     "@as-tral/cli": "^2.0.0",
     "@assemblyscript/wasi-shim": "^0.1.0",
-    "assemblyscript": "^0.27.1",
+    "assemblyscript": "^0.27.8",
     "assemblyscript-prettier": "^1.0.7",
+    "benchmark": "^2.1.4",
+    "kati": "^0.6.2",
+    "microtime": "^3.1.1",
     "prettier": "^2.8.4",
     "tinybench": "^2.5.0",
     "typescript": "^4.9.5",

package/transform/lib/index.js

@@ -1,4 +1,4 @@
-import { getName, toString, isStdlib } from "visitor-as/dist/utils.js";
+import { toString, isStdlib } from "visitor-as/dist/utils.js";
 import { BaseVisitor, SimpleParser } from "visitor-as/dist/index.js";
 import { Transform } from "assemblyscript/dist/transform.js";
 class SchemaData {
@@ -19,48 +19,23 @@ class AsJSONTransform extends BaseVisitor {
         this.sources = [];
     }
     visitMethodDeclaration() { }
-    visitFieldDeclaration(node) {
-        if (toString(node).startsWith("static"))
-            return;
-        const lineText = toString(node);
-        if (lineText.startsWith("private"))
-            return;
-        const name = getName(node);
-        if (!node.type) {
-            throw new Error(`Field ${name} is missing a type declaration`);
-        }
-        let type = getName(node.type);
-        // @ts-ignore
-        this.currentClass.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
-        // @ts-ignore
-        //this.decodeStmts.push(
-        //   `${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`
-        //);
-        // @ts-ignore
-        this.currentClass.setDataStmts.push(`if (key.length === ${name.length} && (memory.compare(changetype<usize>("${name}"), changetype<usize>(key), ${name.length}) == 0)) {
-        this.${name} = JSON.parseObjectValue<${type}>(value);
-        return;
-      }
-      `);
-        // @ts-ignore
-        //this.checkDecodeStmts.push(
-        //  ' if (!values.has("${name}")) throw new Error("Key "${name}" was not found. Cannot instantiate object.");\n'
-        //);
-    }
     visitClassDeclaration(node) {
-        var _a;
+        var _c;
         const className = node.name.text;
-        if (!((_a = node.decorators) === null || _a === void 0 ? void 0 : _a.length))
+        if (!((_c = node.decorators) === null || _c === void 0 ? void 0 : _c.length))
             return;
         let foundDecorator = false;
         for (const decorator of node.decorators) {
+            if (
             // @ts-ignore
-            if (decorator.name.text.toLowerCase() == "json" || decorator.name.text.toLowerCase() == "serializable")
+            decorator.name.text.toLowerCase() == "json" ||
+                // @ts-ignore
+                decorator.name.text.toLowerCase() == "serializable")
                 foundDecorator = true;
         }
         if (!foundDecorator)
             return;
-        // Prevent from being triggered twice
+        // Prevent from being triggered twice.
         for (const member of node.members) {
             if (member.name.text == "__JSON_Serialize")
                 return;
@@ -73,7 +48,7 @@ class AsJSONTransform extends BaseVisitor {
             parent: node.extendsType ? toString(node.extendsType) : "",
             node: node,
             encodeStmts: [],
-            setDataStmts: []
+            setDataStmts: [],
         };
         if (this.currentClass.parent.length > 0) {
             const parentSchema = this.schemasList.find((v) => v.name == this.currentClass.parent);
@@ -82,17 +57,64 @@ class AsJSONTransform extends BaseVisitor {
                 this.currentClass.encodeStmts.push(...parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.encodeStmts);
             }
             else {
-                console.error("Class extends " + this.currentClass.parent + ", but parent class not found. Maybe add the @json decorator over parent class?");
+                console.error("Class extends " +
+                    this.currentClass.parent +
+                    ", but parent class not found. Maybe add the @json decorator over parent class?");
             }
         }
         const parentSchema = this.schemasList.find((v) => v.name == this.currentClass.parent);
-        const members = [...node.members, ...(parentSchema ? parentSchema.node.members : [])];
-        this.visit(members);
+        const members = [
+            ...node.members,
+            ...(parentSchema ? parentSchema.node.members : []),
+        ];
+        for (const mem of members) {
+            // @ts-ignore
+            if (mem.type && mem.type.name && mem.type.name.identifier.text) {
+                const member = mem;
+                if (toString(member).startsWith("static"))
+                    return;
+                const lineText = toString(member);
+                if (lineText.startsWith("private"))
+                    return;
+                // @ts-ignore
+                let type = toString(member.type);
+                const name = member.name.text;
+                this.currentClass.keys.push(name);
+                // @ts-ignore
+                this.currentClass.types.push(type);
+                // @ts-ignore
+                if ([
+                    "u8",
+                    "i8",
+                    "u16",
+                    "i16",
+                    "u32",
+                    "i32",
+                    "f32",
+                    "u64",
+                    "i64",
+                    "f64",
+                ].includes(type.toLowerCase())) {
+                    this.currentClass.encodeStmts.push(`"${name}":\${this.${name}.toString()},`);
+                }
+                else {
+                    this.currentClass.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
+                }
+                // @ts-ignore
+                this.currentClass.setDataStmts.push(`if (key == "${name}") {
+        this.${name} = JSON.parseObjectValue<${type}>(value);
+        return;
+      }
+      `);
+            }
+        }
         let serializeFunc = "";
         if (this.currentClass.encodeStmts.length > 0) {
             const stmt = this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1];
-            this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1] = stmt.slice(0, stmt.length - 1);
+            this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1] =
+                stmt.slice(0, stmt.length - 1);
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return \`{${this.currentClass.encodeStmts.join("")}}\`;
       }
@@ -100,16 +122,18 @@ class AsJSONTransform extends BaseVisitor {
         }
         else {
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
       `;
         }
         const setKeyFunc = `
+      @inline
       __JSON_Set_Key(key: string, value: string): void {
         ${
-            // @ts-ignore
-            this.currentClass.setDataStmts.join("")}
+        // @ts-ignore
+        this.currentClass.setDataStmts.join("")}
       }
     `;
         const serializeMethod = SimpleParser.parseClassMember(serializeFunc, node);
@@ -127,18 +151,23 @@ export default class Transformer extends Transform {
     afterParse(parser) {
         // Create new transform
         const transformer = new AsJSONTransform();
-        // Loop over every source
-        const sources = parser.sources.filter(source => !isStdlib(source)).sort((_a, _b) => {
-            const a = _a.internalPath
-            const b = _b.internalPath
+        // Sort the sources so that user scripts are visited last
+        const sources = parser.sources
+            .filter((source) => !isStdlib(source))
+            .sort((_a, _b) => {
+            const a = _a.internalPath;
+            const b = _b.internalPath;
             if (a[0] === "~" && b[0] !== "~") {
                 return -1;
-            } else if (a[0] !== "~" && b[0] === "~") {
+            }
+            else if (a[0] !== "~" && b[0] === "~") {
                 return 1;
-            } else {
+            }
+            else {
                 return 0;
             }
-        })
+        });
+        // Loop over every source
         for (const source of sources) {
             // Ignore all lib and std. Visit everything else.
             if (!isStdlib(source)) {
@@ -146,4 +175,4 @@ export default class Transformer extends Transform {
             }
         }
     }
-}
+}

package/transform/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-as/transform",
-  "version": "0.5.51",
+  "version": "0.5.52",
   "description": "JSON encoder/decoder for AssemblyScript",
   "main": "./lib/index.js",
   "author": "Jairus Tanaka",