json-as 0.5.54 → 0.5.56

package/assembly/src/util.ts

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

package/assembly/test.ts

@@ -1,6 +1,68 @@
-import { JSON } from "./src/json";
+import { bench, blackbox } from "../../../WebAssembly/benchmark-wasm/assembly/bench";
+import { JSON, serializeString } from "./src/json";
+// @ts-ignore
+@json
+class Vec3 {
+    x: f64;
+    y: f64;
+    z: f64;
+}
 
-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())
+// @ts-ignore
+@json
+class Player {
+    firstName: string;
+    lastName: string;
+    lastActive: i32[];
+    age: i32;
+    pos: Vec3 | null;
+    isVerified: boolean;
+}
+
+const vec: Vec3 = {
+    x: 3.4,
+    y: 1.2,
+    z: 8.3,
+}
+
+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,
+}
+
+console.log("Original: " + JSON.stringify(vec));
+//console.log("Revised: " + vec.__JSON_Deserialize('{"x":3,"y":1,"z":8}').__JSON_Serialize());
+console.log("Implemented: " + JSON.stringify(JSON.parse<Vec3>('{"x":3.4,"y":1.2,"z":8.3}')));
+
+console.log("Original: " + JSON.stringify(player));
+//console.log("Revised: " + vec.__JSON_Deserialize('{"x":3,"y":1,"z":8}').__JSON_Serialize());
+console.log("Implemented: " + JSON.stringify(JSON.parse<Player>('{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}')));
+
+console.log("Serialized String: " + serializeString('st"ring" w""ith quotes"'));
+
+bench("New Stringify String", () => {
+    blackbox<string>(serializeString(blackbox<string>('st"ring" w""ith quotes"')));
+});
+/*
+// 9,325,755
+bench("Stringify Object (Vec3)", () => {
+    blackbox<string>(vec.__JSON_Serialize());
+});
+
+// 17,747,531 -> 55,517,015
+/*bench("New Parse Object (Vec3)", () => {
+    blackbox<Vec3>(vec.__JSON_Deserialize(blackbox<string>('{"x":0,"y":0,"z":0}')));
+});
+
+// 17,747,531
+bench("Old Parse Object (Vec3)", () => {
+    blackbox<Vec3>(JSON.parse<Vec3>(blackbox<string>('{"x":3.4,"y":1.2,"z":8.3}')));
+});*/

package/bench/benchmark.ts

@@ -0,0 +1,206 @@
+import { bench, blackbox } from "../../../WebAssembly/benchmark-wasm/assembly/bench";
+import { __atoi_fast, snip_fast, unsafeCharCodeAt } from "../assembly/src/util";
+import { JSON } from "../assembly";
+import { backSlashCode, commaCode, eCode, fCode, leftBraceCode, leftBracketCode, nCode, nullWord, quoteCode, rCode, rightBraceCode, rightBracketCode, tCode, trueWord, uCode } from "../assembly/src/chars";
+import { isSpace } from "util/string";
+class Vec3 {
+    x: i32;
+    y: i32;
+    z: i32;
+    @inline
+    __JSON_Serialize(): string {
+        return `{"x":${this.x.toString()},"y":${this.y.toString()},"z":${this.z.toString()}}`;
+    }
+    @inline
+    __JSON_Set_Key(key: string, value: string): void {
+        if (key == "x") {
+            this.x = ____parseObjectValue<i32>(value);
+            return;
+        }
+        if (key == "y") {
+            this.y = ____parseObjectValue<i32>(value);
+            return;
+        }
+        if (key == "z") {
+            this.z = ____parseObjectValue<i32>(value);
+            return;
+        }
+    }
+    @inline
+    __JSON_Deserialize(data: string): Vec3 {
+        let schema: nonnull<Vec3> = changetype<nonnull<Vec3>>(
+            __new(offsetof<nonnull<Vec3>>(), idof<nonnull<Vec3>>())
+        );
+        let key = "";
+        let isKey = false;
+        let depth = 0;
+        let outerLoopIndex = 1;
+        for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
+            const char = unsafeCharCodeAt(data, outerLoopIndex);
+            if (char === leftBracketCode) {
+                for (
+                    let arrayValueIndex = outerLoopIndex;
+                    arrayValueIndex < data.length - 1;
+                    arrayValueIndex++
+                ) {
+                    const char = unsafeCharCodeAt(data, arrayValueIndex);
+                    if (char === leftBracketCode) {
+                        depth++;
+                    } else if (char === rightBracketCode) {
+                        depth--;
+                        if (depth === 0) {
+                            ++arrayValueIndex;
+                            // @ts-ignore
+                            schema.__JSON_Set_Key(
+                                key,
+                                data.slice(outerLoopIndex, arrayValueIndex)
+                            );
+                            outerLoopIndex = arrayValueIndex;
+                            isKey = false;
+                            break;
+                        }
+                    }
+                }
+            } else if (char === leftBraceCode) {
+                for (
+                    let objectValueIndex = outerLoopIndex;
+                    objectValueIndex < data.length - 1;
+                    objectValueIndex++
+                ) {
+                    const char = unsafeCharCodeAt(data, objectValueIndex);
+                    if (char === leftBraceCode) {
+                        depth++;
+                    } else if (char === rightBraceCode) {
+                        depth--;
+                        if (depth === 0) {
+                            ++objectValueIndex;
+                            // @ts-ignore
+                            schema.__JSON_Set_Key(
+                                key,
+                                data.slice(outerLoopIndex, objectValueIndex)
+                            );
+                            outerLoopIndex = objectValueIndex;
+                            isKey = false;
+                            break;
+                        }
+                    }
+                }
+            } else if (char === quoteCode) {
+                for (
+                    let stringValueIndex = ++outerLoopIndex;
+                    stringValueIndex < data.length - 1;
+                    stringValueIndex++
+                ) {
+                    const char = unsafeCharCodeAt(data, stringValueIndex);
+                    if (
+                        char === quoteCode &&
+                        unsafeCharCodeAt(data, stringValueIndex - 1) !== backSlashCode
+                    ) {
+                        if (isKey === false) {
+                            key = data.slice(outerLoopIndex, stringValueIndex);
+                            isKey = true;
+                        } else {
+                            // @ts-ignore
+                            schema.__JSON_Set_Key(
+                                key,
+                                data.slice(outerLoopIndex, stringValueIndex)
+                            );
+                            isKey = false;
+                        }
+                        outerLoopIndex = ++stringValueIndex;
+                        break;
+                    }
+                }
+            } else if (char == nCode) {
+                // @ts-ignore
+                schema.__JSON_Set_Key(key, nullWord);
+                isKey = false;
+            } else if (
+                char === tCode &&
+                unsafeCharCodeAt(data, ++outerLoopIndex) === rCode &&
+                unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+                unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+            ) {
+                // @ts-ignore
+                schema.__JSON_Set_Key(key, trueWord);
+                isKey = false;
+            } else if (
+                char === fCode &&
+                unsafeCharCodeAt(data, ++outerLoopIndex) === "a".charCodeAt(0) &&
+                unsafeCharCodeAt(data, ++outerLoopIndex) === "l".charCodeAt(0) &&
+                unsafeCharCodeAt(data, ++outerLoopIndex) === "s".charCodeAt(0) &&
+                unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+            ) {
+                // @ts-ignore
+                schema.__JSON_Set_Key(key, "false");
+                isKey = false;
+            } else if ((char >= 48 && char <= 57) || char === 45) {
+                let numberValueIndex = ++outerLoopIndex;
+                for (; numberValueIndex < data.length; numberValueIndex++) {
+                    const char = unsafeCharCodeAt(data, numberValueIndex);
+                    if (char === commaCode || char === rightBraceCode || isSpace(char)) {
+                        // @ts-ignore
+                        schema.__JSON_Set_Key(
+                            key,
+                            data.slice(outerLoopIndex - 1, numberValueIndex)
+                        );
+                        outerLoopIndex = numberValueIndex;
+                        isKey = false;
+                        break;
+                    }
+                }
+            }
+        }
+        return schema;
+    }
+}
+
+const vec: Vec3 = {
+    x: 3,
+    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("Stringify Object (Vec3)", () => {
+    blackbox<string>(vec.__JSON_Serialize());
+});*/
+
+bench("Parse Object (Vec3)", () => {
+    blackbox<Vec3>(vec.__JSON_Deserialize('{"x":0,"y":0,"z":0}'));
+});
+
+bench("Stringify Number Array", () => {
+    blackbox<string>(JSON.stringify<i32[]>([1, 2, 3]));
+});
+
+bench("Parse Number Array", () => {
+    blackbox<i32[]>(JSON.parse<i32[]>(blackbox("[1,2,3]")));
+});
+
+bench("Stringify String", () => {
+    blackbox<string>(JSON.stringify(blackbox('Hello "World!')));
+});
+
+bench("Parse String", () => {
+    blackbox<string>(JSON.parse<string>(blackbox('"Hello "World!"')));
+});
+
+bench("Stringify Boolean Array", () => {
+    blackbox(JSON.stringify<boolean[]>([true, false, true]));
+});
+
+bench("Stringify String Array", () => {
+    blackbox(JSON.stringify<string[]>(["a", "b", "c"]));
+});

package/bench/tsconfig.json

@@ -0,0 +1,99 @@
+{
+    "extends": "assemblyscript/std/assembly.json",
+    "include": [
+        "./**/*.ts"
+    ],
+    "compilerOptions": {
+        /* Visit https://aka.ms/tsconfig to read more about this file */
+        /* Projects */
+        // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+        // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+        // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+        // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+        // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+        // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+        /* Language and Environment */
+        "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+        // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+        // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+        "experimentalDecorators": true, /* Enable experimental support for TC39 stage 2 draft decorators. */
+        "emitDecoratorMetadata": true, /* Emit design-type metadata for decorated declarations in source files. */
+        // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+        // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+        // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+        // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+        // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+        // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+        // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+        /* Modules */
+        "module": "commonjs" /* Specify what module code is generated. */,
+        // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+        // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+        // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+        // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+        // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+        // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+        // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+        // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+        // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+        // "resolveJsonModule": true,                        /* Enable importing .json files. */
+        // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+        /* JavaScript Support */
+        // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+        // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+        // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+        /* Emit */
+        // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+        // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+        // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+        // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+        // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+        // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+        // "removeComments": true,                           /* Disable emitting comments. */
+        // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+        // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+        // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+        // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+        // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+        // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+        // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+        // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+        // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+        // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+        // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+        // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+        // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+        // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+        // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+        // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+        /* Interop Constraints */
+        // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+        // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+        "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+        // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+        "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+        /* Type Checking */
+        "strict": false /* Enable all strict type-checking options. */,
+        // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+        "strictNullChecks": true, /* When type checking, take into account 'null' and 'undefined'. */
+        // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+        // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+        // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+        // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+        // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+        // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */
+        "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */
+        "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */
+        // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+        // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+        // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+        // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+        // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+        // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+        // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+        // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+        /* Completeness */
+        // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+        "skipLibCheck": true /* Skip type checking all .d.ts files. */
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.5.54",
+  "version": "0.5.56",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -15,30 +15,36 @@
   "scripts": {
     "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:test": "asc assembly/test.ts -o build/test.wasm --transform ./transform/lib/index.js --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 3 --shrinkLevel 0 --noAssert --uncheckedBehavior always --converge --runtime stub",
+    "build:test:debug": "asc assembly/test.ts -o build/test.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 0 --shrinkLevel 0 --noAssert --uncheckedBehavior always --runtime stub",
+    "build:bench": "asc bench/benchmark.ts -o bench/benchmark.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior always --runtime stub",
+    "bench:wasmtime": "wasmtime ./bench/benchmark.wasm",
+    "bench:wavm": "wavm run ./bench/benchmark.wasm",
     "build:transform": "tsc -p ./transform",
     "test:wasmtime": "wasmtime ./build/test.wasm",
+    "test:wavm": "wavm run ./build/test.wasm",
     "test:lunatic": "lunatic ./build/test.wasm",
     "test:wasm3": "wasm3 ./build/test.wasm",
     "prettier": "as-prettier -w ."
   },
   "devDependencies": {
     "@as-pect/cli": "^8.0.1",
-    "@as-tral/cli": "^2.0.0",
+    "@as-tral/cli": "^2.0.1",
     "@assemblyscript/wasi-shim": "^0.1.0",
-    "assemblyscript": "^0.27.8",
+    "assemblyscript": "^0.27.9",
     "assemblyscript-prettier": "^2.0.2",
     "benchmark": "^2.1.4",
     "kati": "^0.6.2",
     "microtime": "^3.1.1",
-    "prettier": "^3.0.1",
+    "prettier": "^3.0.2",
     "tinybench": "^2.5.0",
     "typescript": "^5.1.6",
     "visitor-as": "^0.11.4"
   },
   "dependencies": {
     "as-string-sink": "^0.5.3",
-    "as-variant": "^0.4.1"
+    "as-variant": "^0.4.1",
+    "as-virtual": "^0.1.8"
   },
   "repository": {
     "type": "git",