json-as 0.5.52 → 0.5.54

package/.github/workflows/nodejs.yml

@@ -0,0 +1,25 @@
+name: Node.js CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v2
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+
+      - name: Install dependencies
+        if: steps.node-cache.outputs.cache-hit != 'true'
+        run: yarn
+
+      - name: Test to see if the project compiles
+        run: yarn build:test
+
+      - name: Perform tests
+        run: yarn run test:aspect

package/README.md

@@ -68,29 +68,6 @@ const stringified = JSON.stringify<Player>(player);
 const parsed = JSON.parse<Player>(stringified);
 ```
 
-## Deviations from the spec
-
-This implementation does not hold strongly to the JSON specification. Rather, design and behavior are inspired by the JSON implementation found in Google's v8 engine.
-
-- No support for dynamic types
-- Unsafe by design--parser assumes valid JSON
-- Partial whitespace support--parser prefers speed over handling whitespace effectively. Users may use the `removeWhitespace` function provided by `json-as/src/util.ts`
-- Is not based off of the official spec, but rather the behavior of the JSON C implementation found in google's v8 engine
-- Support for scientific notation on integers. Float support coming soon.
-
-## Implemented features
-
-Fully supports:
-
-- Strings
-- Integers
-- Floats (Scientific notation not implemented)
-- Booleans
-- Arrays
-- Objects
-- Date
-- Null
-
 ## Performance
 
 Here are some benchmarks I took with `tinybench` (JavaScript) and `astral` (AssemblyScript).

package/assembly/__benches__/as-json.ts

@@ -1,64 +1,10 @@
 import { JSON } from "..";
-import { backSlashCode, quoteCode } from "../src/chars";
-import { atoi_fast, parseSciInteger, snip_fast, unsafeCharCodeAt } from "../src/util";
-import { HASH } from "util/hash";
-
-
-let last = 1;
-let char = 0;
-let inStr = false;
-let key: string | null = null;
-let pos = 0;
-
+import { snip_fast } from "../src/util";
 @json
 class Vec3 {
   x: i32;
   y: i32;
   z: i32;
-  @inline __JSON_Deserialize(
-    data: string,
-    to: Vec3
-  ): Vec3 {
-    for (; pos < data.length - 1; pos++) {
-      char = unsafeCharCodeAt(data, pos);
-      if (inStr === false && char === quoteCode) {
-        if (key != null) {
-          if (unsafeCharCodeAt(key!, 0) == 120) {
-            to.x = parseSciInteger<i32>(data.substring(last, pos - 1));
-          } else if (unsafeCharCodeAt(key!, 0) == 121) {
-            to.y = parseSciInteger<i32>(data.substring(last, pos - 1));
-          } else if (unsafeCharCodeAt(key!, 0) == 122) {
-            to.z = parseSciInteger<i32>(data.substring(last, pos - 1));
-          }
-        }
-        last = ++pos;
-        inStr = true;
-      } else if (
-        char === quoteCode &&
-        unsafeCharCodeAt(data, pos - 1) != backSlashCode
-      ) {
-        inStr = false;
-        key = data.substring(last, pos);
-        last = pos += 2;
-      }
-    }
-    if (key != null) {
-      if (unsafeCharCodeAt(key!, 0) == 120) {
-        to.x = parseSciInteger<i32>(data.substring(last, pos - 1));
-      } else if (unsafeCharCodeAt(key!, 0) == 121) {
-        to.y = parseSciInteger<i32>(data.substring(last, pos - 1));
-      } else if (unsafeCharCodeAt(key!, 0) == 122) {
-        to.z = parseSciInteger<i32>(data.substring(last, pos - 1));
-      }
-    }
-
-    last = 1;
-    char = 0;
-    inStr = false;
-    key = null;
-    pos = 0;
-    return to;
-  }
 }
 
 const vec: Vec3 = {
@@ -70,7 +16,7 @@ const vec: Vec3 = {
 bench("Parse Number SNIP", () => {
   blackbox<i32>(snip_fast<i32>("12345"));
 });
-
+/*
 bench("Parse Number ATOI", () => {
   blackbox<i32>(atoi_fast<i32>("12345"));
 })
@@ -82,15 +28,15 @@ bench("Parse Number STDLIB", () => {
 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)", () => {
-  blackbox<Vec3>(vec.__JSON_Deserialize('{"x":0,"y":0,"z":0}', vec));
-});*/
+//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]));
@@ -126,12 +72,12 @@ bench("Parse Boolean", () => {
 
 bench("Stringify Integer", () => {
   blackbox(JSON.stringify(blackbox(314)));
-});
+});*/
 
 bench("Parse Integer", () => {
   blackbox(JSON.parse<i32>(blackbox("314")));
 });
-
+/*
 bench("Stringify Float", () => {
   blackbox(JSON.stringify(blackbox(3.14)));
 });

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

@@ -46,10 +46,10 @@ describe("Ser/de Numbers", () => {
   it("should ser/de integers", () => {
     canSerde<i32>(0);
 
-    canSerde<u32>(100);
-    canSerde<u64>(101);
-    canSerde<i32>(-100);
-    canSerde<i64>(-101);
+    canSerde<u32>(100, "100");
+    canSerde<u64>(101, "101");
+    canSerde<i32>(-100, "-100");
+    canSerde<i64>(-101, "-101");
   });
 
   it("should ser/de floats", () => {
@@ -68,15 +68,6 @@ describe("Ser/de Numbers", () => {
     canSerde<boolean>(true);
     canSerde<boolean>(false);
   });
-
-  it("should ser/de BigInt objects", () => {
-    canSerde<i32>(0);
-
-    canSerde<u32>(100);
-    canSerde<u64>(101);
-    canSerde<i32>(-100);
-    canSerde<i64>(-101);
-  });
 });
 
 describe("Ser/de Array", () => {

package/assembly/src/json.ts

@@ -35,14 +35,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 +48,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 +107,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,20 +138,17 @@ export namespace JSON {
       );
     }
   }
-  // @ts-ignore
-  @inline function parseObjectValue<
-    T
-  >(data: string): T {
+  // @ts-ignore: Decorator
+  @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);
+          const char = unsafeCharCodeAt(data, ++i);
           result += data.slice(last, i - 1);
           if (char === 34) {
             result += '"';
@@ -223,10 +215,8 @@ export namespace JSON {
   }
 }
 
-// @ts-ignore
-@inline function serializeString(
-  data: string
-): string {
+// @ts-ignore: Decorator
+@inline function serializeString(data: string): string {
   // @ts-ignore
   //if (data.length === 0) return "\"\"";
   /*
@@ -309,10 +299,8 @@ export namespace JSON {
   return result + '"';
 }
 
-// @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 +363,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,7 +384,7 @@ 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>>())
@@ -406,17 +392,16 @@ export namespace JSON {
   let key = "";
   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) {
@@ -440,7 +425,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) {
@@ -464,7 +449,7 @@ 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
@@ -510,7 +495,7 @@ export namespace JSON {
     } 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(
@@ -527,10 +512,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 +541,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 +560,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 +586,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 +601,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 +610,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 +620,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 +638,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;

package/assembly/src/util.ts

@@ -1,27 +1,23 @@
 import { StringSink } from "as-string-sink/assembly";
-import { CharCode, isSpace } from "util/string";
+import { isSpace } from "util/string";
 import { backSlashCode, quoteCode } from "./chars";
 
-// @ts-ignore
-@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,143 +58,169 @@ 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
-// 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;
+/** 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 {
-            for (let i = 0; i < exp; i++) {
-              val = (val * 10) 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;
           }
-          return -val as T;
-        } else if (high > 57) {
+        }
+      }
+      // 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.
-          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;
-            }
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+            return -(val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
           } else {
-            for (let i = 0; i < exp; i++) {
-              val = (val * 10) as T;
-            }
+            // Inlined this operation instead of using a loop
+            return -(val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) as T;
           }
-          return -val as T;
         } else {
-          val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+          val = (val * 10) + (ch - 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;
+      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;
           }
-        } else {
-          for (let i = 0; i < exp; i++) {
-            val = (val * 10) 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 {
-        val = (val * 10) + (ch - 48) as T;
       }
+      return val 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) {
-        ch = load<u32>(changetype<usize>(str) + <usize>offset);
+        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.
-          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;
-            }
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+            return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
           } else {
-            for (let i = 0; i < exp; i++) {
-              val = (val * 10) as T;
-            }
+            // Inlined this operation instead of using a loop
+            return (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) 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;
-            }
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
+            return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
           } else {
-            for (let i = 0; i < exp; i++) {
-              val = (val * 10) as T;
-            }
+            // Inlined this operation instead of using a loop
+            return (val * (10 ** (atoi_fast<u32>(str, offset + 4) + 1))) as T;
           }
-          return val as T;
         } else {
           // Optimized with multiplications and shifts.
           val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
@@ -208,22 +229,16 @@ export function snip_fast<T extends number>(str: string, offset: u32 = 0): T {
     }
     // Cover the remaining numbers with 16 bit loads.
     for (; offset < len; offset += 2) {
-      ch = load<u16>(changetype<usize>(str) + <usize>offset);
+      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) {
-        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;
-          }
+        if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+          return (val / (10 ** (atoi_fast<u32>(str, offset + 6) - 1))) as T;
         } else {
-          for (let i = 0; i < exp; i++) {
-            val = (val * 10) as T;
-          }
+          // Inlined this operation instead of using a loop
+          return (val * (10 ** (atoi_fast<u32>(str, offset + 2) + 1))) as T;
         }
-        return val as T;
       } else {
         val = (val * 10) + (ch - 48) as T;
       }
@@ -234,29 +249,32 @@ export function snip_fast<T extends number>(str: string, offset: u32 = 0): 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: u32 = 0): T {
+@inline export function atoi_fast<T extends number>(str: string, offset: u32 = 0): T {
   // @ts-ignore
   let val: T = 0;
   const len = u32(str.length << 1);
-  if (load<u16>(changetype<usize>(str) + <usize>offset) === 45) {
-    offset += 2;
-    for (; offset < len; offset += 2) {
-      // @ts-ignore
-      val = (val << 1) + (val << 3) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48);
+  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
-    return -val;
   } else {
     for (; offset < len; offset += 2) {
-      // @ts-ignore
-      val = (val << 1) + (val << 3) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48);
+      val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48)) as T;
     }
-    return val;
+    return val as T;
   }
 }
 
@@ -269,8 +287,7 @@ export function atoi_fast<T extends number>(str: string, offset: u32 = 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;
@@ -299,22 +316,21 @@ 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++) {
+    for (let i: T = <T>0; i < num; i++) {
       res *= 10;
     }
   } else {
-    for (let i: T = 0; i < num; i++) {
+    for (let i: T = <T>0; i < num; i++) {
       res /= 10;
     }
   }

package/assembly/test.ts

@@ -1,89 +1,6 @@
-import { snip_fast } from "./src/util";
-
 import { JSON } from "./src/json";
-@json
-class Vec3 {
-  x!: f64;
-  y!: f64;
-  z!: f64;
-}
-
-@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,
-};
-
-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);
-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("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]]));
+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
+  ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.5.52",
+  "version": "0.5.54",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -13,8 +13,8 @@
   ],
   "license": "MIT",
   "scripts": {
-    "aspect": "asp",
-    "bench:astral": "astral -Ospeed --noAssert --uncheckedBehavior always --runtime stub",
+    "test:aspect": "asp",
+    "bench:astral": "astral --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior never --runtime stub",
     "build:test": "asc assembly/test.ts --target test",
     "build:transform": "tsc -p ./transform",
     "test:wasmtime": "wasmtime ./build/test.wasm",
@@ -27,13 +27,13 @@
     "@as-tral/cli": "^2.0.0",
     "@assemblyscript/wasi-shim": "^0.1.0",
     "assemblyscript": "^0.27.8",
-    "assemblyscript-prettier": "^1.0.7",
+    "assemblyscript-prettier": "^2.0.2",
     "benchmark": "^2.1.4",
     "kati": "^0.6.2",
     "microtime": "^3.1.1",
-    "prettier": "^2.8.4",
+    "prettier": "^3.0.1",
     "tinybench": "^2.5.0",
-    "typescript": "^4.9.5",
+    "typescript": "^5.1.6",
     "visitor-as": "^0.11.4"
   },
   "dependencies": {

package/transform/package.json

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

package/asconfig.json

@@ -1,15 +0,0 @@
-{
-  "targets": {
-    "test": {
-      "outFile": "build/test.wasm",
-      "sourceMap": false,
-      "optimizeLevel": 0,
-      "shrinkLevel": 0,
-      "converge": false,
-      "noAssert": false
-    }
-  },
-  "options": {
-    "transform": ["./transform"],
-    "bindings": "esm"}
-}