json-as 0.5.52 → 0.5.56

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/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.56",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -13,32 +13,38 @@
   ],
   "license": "MIT",
   "scripts": {
-    "aspect": "asp",
-    "bench:astral": "astral -Ospeed --noAssert --uncheckedBehavior always --runtime stub",
-    "build:test": "asc assembly/test.ts --target test",
+    "test:aspect": "asp",
+    "bench:astral": "astral --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior never --runtime stub",
+    "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-prettier": "^1.0.7",
+    "assemblyscript": "^0.27.9",
+    "assemblyscript-prettier": "^2.0.2",
     "benchmark": "^2.1.4",
     "kati": "^0.6.2",
     "microtime": "^3.1.1",
-    "prettier": "^2.8.4",
+    "prettier": "^3.0.2",
     "tinybench": "^2.5.0",
-    "typescript": "^4.9.5",
+    "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",

package/transform/lib/index.js

@@ -90,22 +90,39 @@ class AsJSONTransform extends BaseVisitor {
                     "i16",
                     "u32",
                     "i32",
-                    "f32",
                     "u64",
                     "i64",
+                ].includes(type.toLowerCase())) {
+                    this.currentClass.encodeStmts.push(`"${name}":\${this.${name}.toString()},`);
+                    // @ts-ignore
+                    this.currentClass.setDataStmts.push(`if (key.equals("${name}")) {
+        this.${name} = __atoi_fast<${type}>(data, val_start << 1, val_end << 1);
+        return;
+      }
+      `);
+                }
+                else // @ts-ignore
+                 if ([
+                    "f32",
                     "f64",
                 ].includes(type.toLowerCase())) {
                     this.currentClass.encodeStmts.push(`"${name}":\${this.${name}.toString()},`);
+                    // @ts-ignore
+                    this.currentClass.setDataStmts.push(`if (key.equals("${name}")) {
+        this.${name} = __parseObjectValue<${type}>(data.slice(val_start, val_end));
+        return;
+      }
+      `);
                 }
                 else {
                     this.currentClass.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
-                }
-                // @ts-ignore
-                this.currentClass.setDataStmts.push(`if (key == "${name}") {
-        this.${name} = JSON.parseObjectValue<${type}>(value);
+                    // @ts-ignore
+                    this.currentClass.setDataStmts.push(`if (key.equals("${name}")) {
+        this.${name} = __parseObjectValue<${type}>(val_start ? data.slice(val_start, val_end) : data);
         return;
       }
       `);
+                }
             }
         }
         let serializeFunc = "";
@@ -114,23 +131,20 @@ class AsJSONTransform extends BaseVisitor {
             this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1] =
                 stmt.slice(0, stmt.length - 1);
             serializeFunc = `
-      @inline
-      __JSON_Serialize(): string {
+      @inline __JSON_Serialize(): string {
         return \`{${this.currentClass.encodeStmts.join("")}}\`;
       }
       `;
         }
         else {
             serializeFunc = `
-      @inline
-      __JSON_Serialize(): string {
+      @inline __JSON_Serialize(): string {
         return "{}";
       }
       `;
         }
         const setKeyFunc = `
-      @inline
-      __JSON_Set_Key(key: string, value: string): void {
+      @inline __JSON_Set_Key<T>(key: T, data: string, val_start: i32, val_end: i32): void {
         ${
         // @ts-ignore
         this.currentClass.setDataStmts.join("")}
@@ -141,6 +155,7 @@ class AsJSONTransform extends BaseVisitor {
         const setDataMethod = SimpleParser.parseClassMember(setKeyFunc, node);
         node.members.push(setDataMethod);
         this.schemasList.push(this.currentClass);
+        //console.log(toString(node));
     }
     visitSource(node) {
         super.visitSource(node);

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/transform/src/index.ts

@@ -23,7 +23,7 @@ class AsJSONTransform extends BaseVisitor {
   public currentClass!: SchemaData;
   public sources: Source[] = [];
 
-  visitMethodDeclaration(): void {}
+  visitMethodDeclaration(): void { }
   visitClassDeclaration(node: ClassDeclaration): void {
     const className = node.name.text;
     if (!node.decorators?.length) return;
@@ -65,8 +65,8 @@ class AsJSONTransform extends BaseVisitor {
       } else {
         console.error(
           "Class extends " +
-            this.currentClass.parent +
-            ", but parent class not found. Maybe add the @json decorator over parent class?"
+          this.currentClass.parent +
+          ", but parent class not found. Maybe add the @json decorator over parent class?"
         );
       }
     }
@@ -103,28 +103,52 @@ class AsJSONTransform extends BaseVisitor {
             "i16",
             "u32",
             "i32",
-            "f32",
             "u64",
             "i64",
-            "f64",
           ].includes(type.toLowerCase())
         ) {
           this.currentClass.encodeStmts.push(
             `"${name}":\${this.${name}.toString()},`
           );
-        } else {
+          // @ts-ignore
+          this.currentClass.setDataStmts.push(
+            `if (key.equals("${name}")) {
+        this.${name} = __atoi_fast<${type}>(data, val_start << 1, val_end << 1);
+        return;
+      }
+      `
+          );
+        } else // @ts-ignore
+          if (
+            [
+              "f32",
+              "f64",
+            ].includes(type.toLowerCase())
+          ) {
+            this.currentClass.encodeStmts.push(
+              `"${name}":\${this.${name}.toString()},`
+            );
+            // @ts-ignore
+            this.currentClass.setDataStmts.push(
+              `if (key.equals("${name}")) {
+        this.${name} = __parseObjectValue<${type}>(data.slice(val_start, val_end));
+        return;
+      }
+      `
+            );
+          } else {
           this.currentClass.encodeStmts.push(
             `"${name}":\${JSON.stringify<${type}>(this.${name})},`
           );
-        }
-        // @ts-ignore
-        this.currentClass.setDataStmts.push(
-          `if (key == "${name}") {
-        this.${name} = JSON.parseObjectValue<${type}>(value);
+          // @ts-ignore
+          this.currentClass.setDataStmts.push(
+            `if (key.equals("${name}")) {
+        this.${name} = __parseObjectValue<${type}>(val_start ? data.slice(val_start, val_end) : data);
         return;
       }
       `
-        );
+          );
+        }
       }
     }
 
@@ -133,32 +157,29 @@ class AsJSONTransform extends BaseVisitor {
     if (this.currentClass.encodeStmts.length > 0) {
       const stmt =
         this.currentClass.encodeStmts[
-          this.currentClass.encodeStmts.length - 1
+        this.currentClass.encodeStmts.length - 1
         ]!;
       this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1] =
         stmt!.slice(0, stmt.length - 1);
       serializeFunc = `
-      @inline
-      __JSON_Serialize(): string {
+      @inline __JSON_Serialize(): string {
         return \`{${this.currentClass.encodeStmts.join("")}}\`;
       }
       `;
     } else {
       serializeFunc = `
-      @inline
-      __JSON_Serialize(): string {
+      @inline __JSON_Serialize(): string {
         return "{}";
       }
       `;
     }
 
     const setKeyFunc = `
-      @inline
-      __JSON_Set_Key(key: string, value: string): void {
+      @inline __JSON_Set_Key<T>(key: T, data: string, val_start: i32, val_end: i32): void {
         ${
-          // @ts-ignore
-          this.currentClass.setDataStmts.join("")
-        }
+      // @ts-ignore
+      this.currentClass.setDataStmts.join("")
+      }
       }
     `;
 
@@ -169,6 +190,7 @@ class AsJSONTransform extends BaseVisitor {
     node.members.push(setDataMethod);
 
     this.schemasList.push(this.currentClass);
+    //console.log(toString(node));
   }
   visitSource(node: Source): void {
     super.visitSource(node);