json-as 0.5.51 → 0.5.54

package/assembly/src/util.ts

@@ -2,26 +2,22 @@ import { StringSink } from "as-string-sink/assembly";
 import { isSpace } from "util/string";
 import { backSlashCode, quoteCode } from "./chars";
 
-// @ts-ignore
-@inline
-export function unsafeCharCodeAt(data: string, pos: i32): i32 {
+// @ts-ignore: Decorator
+@inline 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 {
+// @ts-ignore: Decorator
+@inline export function removeWhitespace(data: string): string {
   const result = new StringSink();
   let instr = false;
   for (let i = 0; i < data.length; i++) {
     const char = data.charCodeAt(i);
     if (instr === false && char === quoteCode) instr = true;
     else if (
-      instr === true &&
-      char === quoteCode &&
-      data.charCodeAt(i - 1) !== backSlashCode
-    )
-      instr = false;
+      instr === true && char === quoteCode
+      && data.charCodeAt(i - 1) !== backSlashCode
+    ) instr = false;
 
     if (instr === false) {
       if (!isSpace(char)) result.write(data.charAt(i));
@@ -32,9 +28,8 @@ export function removeWhitespace(data: string): string {
   return result.toString();
 }
 
-// @ts-ignore
-@inline
-export function escapeChar(char: string): string {
+// @ts-ignore: Decorator
+@inline export function escapeChar(char: string): string {
   switch (unsafeCharCodeAt(char, 0)) {
     case 0x22:
       return '\\"';
@@ -63,56 +58,224 @@ export function escapeChar(char: string): string {
  * @returns depth of array
  */
 
-// @ts-ignore
-@inline
-export function getArrayDepth<T>(depth: i32 = 1): i32 {
-  // @ts-ignore
+// @ts-ignore: Decorator
+@inline export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
   if (!isArray<T>()) {
     return 0;
-    // @ts-ignore
   } else if (isArray<valueof<T>>()) {
     depth++;
-    // @ts-ignore
     return getArrayDepth<valueof<T>>(depth);
   } else {
     return depth;
   }
 }
 
+/** 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.
+ * The reason why we only load 4 bytes at a time is that numbers in the 32-bit range are 7 chars long at most.
+ * Using SIMD or 64 bit loads would only work well when parsing large 128+ numbers.
+ * 
+ * Here are some benchmarks
+ * Parsing: "12345" 
+ * Results are spread over 5000ms
+ * 
+ * SNIP: 270M iterations
+ * ATOI: 285M iterations
+ * ParseInt: 176M iterations 
+ * 
+ * @param str - Any number. Can include scientific notation.
+*/
+// @ts-ignore: Decorator
+@inline export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u32 = 0): T {
+  if (isSigned<T>()) {
+    const firstChar: u32 = load<u16>(changetype<usize>(str));
+    if (firstChar === 48) return 0 as T;
+    const isNegative = firstChar === 45; // Check if the number is negative
+    let val: T = 0 as T;
+    if (len == 0) len = u32(str.length << 1);
+    if (isNegative) {
+      offset += 2;
+      if (len >= 4) {
+        // 32-bit route
+        for (; offset < (len - 3); offset += 4) {
+          const 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.
+            if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+              return -(val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+            } else {
+              // Inlined this operation instead of using a loop
+              return -(val * (10 ** (atoi_fast<u32>(str, offset + 2) + 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;
+            } else {
+              // Inlined this operation instead of using a loop
+              return -(val * (10 ** (atoi_fast<u32>(str, offset + 4) + 1))) 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) {
+        const 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.
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+            return -(val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+          } else {
+            // Inlined this operation instead of using a loop
+            return -(val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) 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) {
+          const 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.
+            if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+              return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+            } else {
+              // Inlined this operation instead of using a loop
+              return (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 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;
+            } else {
+              // Inlined this operation instead of using a loop
+              return (val * (10 ** (atoi_fast<u32>(str, offset + 4) + 1))) 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) {
+        const 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) {
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+            val = (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+          } else {
+            // Inlined this operation instead of using a loop
+            val = (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) as T;
+          }
+          return val as T;
+        } else {
+          val = (val * 10) + (ch - 48) as T;
+        }
+      }
+      return val as T;
+    }
+  } else {
+    const firstChar: u32 = load<u16>(changetype<usize>(str));
+    if (firstChar === 48) return 0 as T;
+    let val: T = 0 as T;
+    if (len == 0) len = u32(str.length << 1);
+    if (len >= 4) {
+      // Duplet 16 bit lane load
+      for (; offset < (len - 3); offset += 4) {
+        const 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.
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+            return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+          } else {
+            // Inlined this operation instead of using a loop
+            return (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 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;
+          } else {
+            // Inlined this operation instead of using a loop
+            return (val * (10 ** (atoi_fast<u32>(str, offset + 4) + 1))) 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) {
+      const 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) {
+        if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+          return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
+        } else {
+          // Inlined this operation instead of using a loop
+          return (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) 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
  */
 
 // @ts-ignore
-@inline
-export function atoi_fast<T extends number>(str: string, offset: i32 = 0): T {
+@inline 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) {
-    offset += 2;
-    for (; offset < str.length << 1; 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
+  const len = 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;
+      }
+      return -val as T;
+    } else {
+      for (; offset < len; offset += 2) {
+        val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48)) as T;
+      }
+      return val as T;
     }
-    // @ts-ignore
-    val = -val;
   } else {
-    for (; offset < str.length << 1; 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
+    for (; offset < len; offset += 2) {
+      val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48)) as T;
     }
+    return val as T;
   }
-  return val;
 }
 
 /**
@@ -124,8 +287,7 @@ export function atoi_fast<T extends number>(str: string, offset: i32 = 0): T {
  */
 
 // @ts-ignore
-@inline
-export function parseSciInteger<T extends number>(str: string): T {
+@inline export function parseSciInteger<T extends number>(str: string): T {
   // @ts-ignore
   let val: T = 0;
   let offset = 0;
@@ -154,25 +316,24 @@ export function parseSciInteger<T extends number>(str: string): T {
     // We use load because in this case, there is no need to have bounds-checking
   }
   if (firstChar === 45) {
-    val = -val;
+    val = -val as T;
   }
   return val;
 }
 
 // @ts-ignore
-@inline
-function sciNote<T extends number>(num: T): T {
+@inline 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 = <T>0; i < num; i++) {
+      res *= 10;
+    }
+  } else {
+    for (let i: T = <T>0; i < num; i++) {
+      res /= 10;
     }
+  }
   // @ts-ignore
   return res;
 }

package/assembly/test.ts

@@ -1,279 +1,6 @@
 import { JSON } from "./src/json";
-import { atoi_fast, parseSciInteger } from "./src/util";
-import * as a from "util/number";
-// "st\"ring\" w\"\"ith quotes\""
 
-@json
-class Vec3 {
-  x!: f32;
-  y!: f32;
-  z!: f32;
-}
-
-@json
-class Player {
-  firstName!: string;
-  lastName!: string;
-  lastActive!: i32[];
-  age!: i32;
-  pos!: Vec3 | null;
-  isVerified!: boolean;
-}
-
-const player: Player = {
-  firstName: "Emmet",
-  lastName: "West",
-  lastActive: [8, 27, 2022],
-  age: 23,
-  pos: {
-    x: 3.4,
-    y: 1.2,
-    z: 8.3,
-  },
-  isVerified: true,
-};
-
-const vec: Vec3 = {
-  x: 3,
-  y: 1,
-  z: 8,
-};
-
-const serializedPlayer = JSON.stringify<Player>(player);
-console.log(serializedPlayer);
-const parsedPlayer = JSON.parse<Player>(serializedPlayer);
-console.log(JSON.stringify(parsedPlayer));
-
-const serializedVec3 = JSON.stringify(vec);
-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(JSON.parse<u32>("100").toString());
+console.log(JSON.stringify<u32>(100));
+console.log(JSON.stringify(JSON.parse<u32>(JSON.stringify(100))))
+console.log((100).toString())

package/bench-results/INTEGER-PARSING.md

@@ -0,0 +1,52 @@
+# Comparison between integer parsing algorithms
+
+SNIP: 261M iterations over 5000ms
+ATOI: 285M iterations over 5000ms
+
+
+### Log
+
+```
+yarn run v1.22.19
+$ astral -Ospeed --noAssert --uncheckedBehavior always --runtime stub
+Compiling assembly/__benches__/as-json.ts
+
+Benchmarking Parse Number SNIP: Warming up for 3000ms
+Benchmarking Parse Number SNIP: Collecting 100 samples in estimated 5000ms (261M iterations)
+Benchmarking Parse Number SNIP: Analyzing
+Parse Number SNIP       time: [18.146ns 18.381ns 18.624ns]
+                        change: [-13.073% -10.614% -8.1347%] (p = 0.00 < 0.05)
+                        Performance has improved.
+Found 9 outliers among 100 measurements (9%)
+  8 (8%) high mild
+  1 (1%) high severe
+
+Benchmarking Parse Number ATOI: Warming up for 3000ms
+Benchmarking Parse Number ATOI: Collecting 100 samples in estimated 5000ms (285M iterations)
+Benchmarking Parse Number ATOI: Analyzing
+Parse Number ATOI       time: [16.962ns 17.219ns 17.501ns]
+                        change: [-3.5659% -0.8496% +2.0516%] (p = 0.00 < 0.05)
+                        Change within noise threshold.
+Found 7 outliers among 100 measurements (7%)
+  2 (2%) high mild
+  5 (5%) high severe
+
+Benchmarking Parse Number STDLIB: Warming up for 3000ms
+Benchmarking Parse Number STDLIB: Collecting 100 samples in estimated 5000ms (176M iterations)
+Benchmarking Parse Number STDLIB: Analyzing
+Parse Number STDLIB     time: [28.298ns 28.763ns 29.383ns]
+                        change: [-3.3724% -1.5367% +0.1796%] (p = 0.00 < 0.05)
+                        Change within noise threshold.
+Found 5 outliers among 100 measurements (5%)
+  3 (3%) high mild
+  2 (2%) high severe
+
+Benchmarking Parse Number OLD: Warming up for 3000ms
+Benchmarking Parse Number OLD: Collecting 100 samples in estimated 5000ms (171M iterations)
+Benchmarking Parse Number OLD: Analyzing
+Parse Number OLD        time: [28.888ns 29.341ns 29.804ns]
+                        change: [-2.123% -0.5458% +1.1939%] (p = 0.00 < 0.05)
+                        Change within noise threshold.
+Found 3 outliers among 100 measurements (3%)
+  3 (3%) high mild
+  ```