json-as 0.9.11 → 0.9.12

package/CHANGELOG

@@ -17,8 +17,9 @@ v0.9.8a - Fix #80 - Empty Maps were not serialized to {}, instead, threw memory
 v0.9.8b - Fix #81 - Revert transform
 v0.9.9 - Fix #82 - Initialize maps
 v0.9.9a - Remove extraneous logs from transform
-v0.9.11 - Fix transform type checks. switch to nodekind checks
+v0.9.10 - Fix transform type checks. switch to nodekind checks
 v0.9.11 - Remove MpZ--implement custom serializers and deserializers in the works
+v0.9.12 - Add compat with aspect
 
 [UNRELEASED] v1.0.0
  - Allow nullable primitives

package/assembly/custom/bs.ts

@@ -0,0 +1,155 @@
+import { dtoa_buffered, itoa_buffered } from "util/number";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+@inline const MAX_LEN: usize = 65536;
+const STORE: usize[] = [];
+let STORE_LEN: usize = 0;
+const CACHE = memory.data(i32(MAX_LEN));
+// Configurable amount of referenceable strings
+let POINTER = changetype<usize>(CACHE);
+@inline const MAX_CACHE = CACHE + MAX_LEN;
+
+export namespace bs {
+    @inline export function write_int<T extends number>(num: T): void {
+        POINTER += itoa_buffered(POINTER, num) << 1;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_int_u<T extends number>(num: T): void {
+        POINTER += itoa_buffered(POINTER, num) << 1;
+    }
+
+    @inline export function write_fl<T extends number>(num: T): void {
+        POINTER += dtoa_buffered(POINTER, num) << 1;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_fl_u<T extends number>(num: T): void {
+        POINTER += dtoa_buffered(POINTER, num) << 1;
+    }
+
+    @inline export function write_b(buf: usize, bytes: usize = changetype<OBJECT>(buf - TOTAL_OVERHEAD).rtSize): void {
+        memory.copy(POINTER, buf, bytes);
+        POINTER += bytes;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_b_u(buf: usize, bytes: usize = changetype<OBJECT>(buf - TOTAL_OVERHEAD).rtSize): void {
+        memory.copy(POINTER, buf, bytes);
+        POINTER += bytes;
+    }
+
+    @inline export function write_s(str: string, bytes: usize = changetype<OBJECT>(changetype<usize>(str) - TOTAL_OVERHEAD).rtSize): void {
+        memory.copy(POINTER, changetype<usize>(str), bytes);
+        POINTER += bytes;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_s_u(str: string, bytes: usize = changetype<OBJECT>(changetype<usize>(str) - TOTAL_OVERHEAD).rtSize): void {
+        memory.copy(POINTER, changetype<usize>(str), bytes);
+        POINTER += bytes;
+    }
+
+    @inline export function write_s_se(str: string, start: usize, end: usize): void {
+        const bytes = end - start;
+        memory.copy(POINTER, changetype<usize>(str) + start, bytes);
+        POINTER += bytes;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_s_se_u(str: string, start: usize, end: usize): void {
+        const bytes = end - start;
+        memory.copy(POINTER, changetype<usize>(str) + start, bytes);
+        POINTER += bytes;
+    }
+
+    @inline export function write_16(char: i32): void {
+        store<u16>(POINTER, char);
+        POINTER += 2;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_16_u(char: i32): void {
+        store<u16>(POINTER, char);
+        //POINTER += 2;
+    }
+
+    @inline export function write_32(chars: i32): void {
+        store<u32>(POINTER, chars);
+        POINTER += 4;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_32_u(chars: i32): void {
+        store<u32>(POINTER, chars);
+        //POINTER += 4;
+    }
+
+    @inline export function write_64(chars: i64): void {
+        store<u64>(POINTER, chars);
+        POINTER += 8;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+
+    @inline export function write_64_u(chars: i64): void {
+        store<u64>(POINTER, chars);
+        POINTER += 8;
+    }
+
+    @inline export function write_128(chars: v128): void {
+        store<v128>(POINTER, chars);
+        POINTER += 16;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function write_128_u(chars: v128): void {
+        store<v128>(POINTER, chars);
+        //POINTER += 16;
+       //if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+    @inline export function shrink(): void {
+        const len = POINTER - CACHE;
+        STORE_LEN += len;
+        const out = __new(
+            len,
+            idof<ArrayBuffer>()
+        );
+        memory.copy(out, CACHE, len);
+        bs.reset();
+        STORE.push(out);
+    }
+    @inline export function out<T>(): T {
+        const len = POINTER - CACHE;
+        let out = __new(
+            len + STORE_LEN,
+            idof<T>()
+        );
+
+        memory.copy(out, CACHE, len);
+        if (STORE_LEN) {
+            out += len;
+            for (let i = 0; i < STORE.length; i++) {
+                const ptr = changetype<usize>(unchecked(STORE[i]));
+                const storeLen = changetype<OBJECT>(ptr - TOTAL_OVERHEAD).rtSize;
+                memory.copy(out, ptr, storeLen);
+                //__unpin(ptr);
+                out += storeLen;
+            }
+            STORE_LEN = 0;
+        }
+        bs.reset();
+
+        return changetype<T>(out);
+    }
+
+    @inline export function out_u<T>(): T {
+        const len = POINTER - CACHE;
+        const out = __new(
+            len + STORE_LEN,
+            idof<T>()
+        );
+
+        memory.copy(out, CACHE, len);
+        bs.reset();
+
+        return changetype<T>(out);
+    }
+
+    @inline export function _out(out: usize): void {
+        memory.copy(out, CACHE, POINTER - CACHE);
+    }
+    @inline export function reset(): void {
+        POINTER = CACHE;
+    }
+}

package/assembly/{util.ts → custom/util.ts}

@@ -362,3 +362,31 @@ export function containsCodePoint(str: string, code: u32, start: i32, end: i32):
   }
   return false;
 }
+
+export function _intTo16(int: i32): i32 {
+  if (int < 10) {
+    // 0-10
+    return 48 + int;
+  } else {
+    // a-f
+    return 87 + int;
+  }
+}
+
+@inline export function intTo16(int: i32): i32 {
+  const high = int >> 4;
+  const low = int & 0x0F;
+  if (low < 10) {
+    if (high < 10) {
+      return ((48 + low) << 16) | 48 + high;
+    } else {
+      return ((48 + low) << 16) | 87 + high;
+    }
+  } else {
+    if (high < 10) {
+      return ((87 + low) << 16) | 48 + high;
+    } else {
+      return ((87 + low) << 16) | 87 + high;
+    }
+  }
+}

package/assembly/deserialize/array/array.ts

@@ -1,6 +1,6 @@
-import { BRACKET_LEFT, BRACKET_RIGHT } from "../../chars";
+import { BRACKET_LEFT, BRACKET_RIGHT } from "../../custom/chars";
 import { JSON } from "../..";
-import { unsafeCharCodeAt } from "../../util";
+import { unsafeCharCodeAt } from "../../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeArrayArray<T extends unknown[][]>(data: string): T {

package/assembly/deserialize/array/bool.ts

@@ -1,5 +1,5 @@
-import { CHAR_E, CHAR_F, CHAR_T } from "../../chars";
-import { unsafeCharCodeAt } from "../../util";
+import { CHAR_E, CHAR_F, CHAR_T } from "../../custom/chars";
+import { unsafeCharCodeAt } from "../../custom/util";
 import { deserializeBoolean } from "../bool";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/array/float.ts

@@ -1,6 +1,6 @@
 import { isSpace } from "util/string";
-import { unsafeCharCodeAt } from "../../util";
-import { COMMA, BRACKET_RIGHT } from "../../chars";
+import { unsafeCharCodeAt } from "../../custom/util";
+import { COMMA, BRACKET_RIGHT } from "../../custom/chars";
 import { deserializeFloat } from "../float";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/array/integer.ts

@@ -1,6 +1,6 @@
 import { isSpace } from "util/string";
-import { unsafeCharCodeAt } from "../../util";
-import { COMMA, BRACKET_RIGHT } from "../../chars";
+import { unsafeCharCodeAt } from "../../custom/util";
+import { COMMA, BRACKET_RIGHT } from "../../custom/chars";
 import { deserializeInteger } from "../integer";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/array/map.ts

@@ -1,6 +1,6 @@
-import { BRACE_LEFT, BRACE_RIGHT } from "../../chars";
+import { BRACE_LEFT, BRACE_RIGHT } from "../../custom/chars";
 import { JSON } from "../..";
-import { unsafeCharCodeAt } from "../../util";
+import { unsafeCharCodeAt } from "../../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeMapArray<T extends unknown[]>(data: string): T {

package/assembly/deserialize/array/object.ts

@@ -1,6 +1,6 @@
-import { BRACE_LEFT, BRACE_RIGHT } from "../../chars";
+import { BRACE_LEFT, BRACE_RIGHT } from "../../custom/chars";
 import { JSON } from "../..";
-import { unsafeCharCodeAt } from "../../util";
+import { unsafeCharCodeAt } from "../../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeObjectArray<T extends unknown[]>(data: string): T {

package/assembly/deserialize/array/string.ts

@@ -1,5 +1,5 @@
-import { BACK_SLASH, QUOTE } from "../../chars";
-import { unsafeCharCodeAt } from "../../util";
+import { BACK_SLASH, QUOTE } from "../../custom/chars";
+import { unsafeCharCodeAt } from "../../custom/util";
 import { deserializeString } from "../string";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/array.ts

@@ -1,4 +1,4 @@
-import { isMap } from "../util";
+import { isMap } from "../custom/util";
 import { deserializeArrayArray } from "./array/array";
 import { deserializeBooleanArray } from "./array/bool";
 import { deserializeFloatArray } from "./array/float";

package/assembly/deserialize/bool.ts

@@ -1,5 +1,5 @@
-import { CHAR_F, CHAR_T } from "../chars";
-import { unsafeCharCodeAt } from "../util";
+import { CHAR_F, CHAR_T } from "../custom/chars";
+import { unsafeCharCodeAt } from "../custom/util";
 
 /**
  * Deserialize a string to type boolean

package/assembly/deserialize/integer.ts

@@ -1,4 +1,4 @@
-import { snip_fast } from "../util";
+import { snip_fast } from "../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeInteger<T>(data: string): T {

package/assembly/deserialize/map.ts

@@ -1,5 +1,5 @@
 import { Virtual } from "as-virtual/assembly";
-import { containsCodePoint, unsafeCharCodeAt } from "../util";
+import { containsCodePoint, unsafeCharCodeAt } from "../custom/util";
 import {
     CHAR_A,
     BACK_SLASH,
@@ -18,7 +18,7 @@ import {
     CHAR_S,
     CHAR_T,
     CHAR_U
-} from "../chars";
+} from "../custom/chars";
 import { deserializeBoolean } from "./bool";
 import { JSON } from "..";
 import { deserializeString } from "./string";
@@ -72,8 +72,6 @@ import { deserializeFloat } from "./float";
                     depth--;
                     if (depth === 0) {
                         ++objectValueIndex;
-                        console.log("Index: " + nameof<indexof<T>>());
-                        console.log("Value: " + nameof<valueof<T>>());
                         map.set(deserializeMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, objectValueIndex)));
                         outerLoopIndex = objectValueIndex;
                         isKey = false;
@@ -181,4 +179,4 @@ function deserializeMapKey<T>(key: Virtual<string>): T {
     }
 
     throw new Error(`JSON: Cannot parse JSON object to a Map with a key of type ${nameof<T>()}`);
-}
+}

package/assembly/deserialize/object.ts

@@ -1,5 +1,5 @@
-import {  unsafeCharCodeAt } from "../util";
-import { CHAR_A, BACK_SLASH, COMMA, CHAR_E, CHAR_F, CHAR_L, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, CHAR_R, BRACE_RIGHT, BRACKET_RIGHT, CHAR_S, CHAR_T, CHAR_U } from "../chars";
+import { unsafeCharCodeAt } from "../custom/util";
+import { CHAR_A, BACK_SLASH, COMMA, CHAR_E, CHAR_F, CHAR_L, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, CHAR_R, BRACE_RIGHT, BRACKET_RIGHT, CHAR_S, CHAR_T, CHAR_U } from "../custom/chars";
 import { isSpace } from "util/string";
 
 // @ts-ignore: Decorator valid here

package/assembly/deserialize/string.ts

@@ -13,9 +13,9 @@ import {
     CHAR_T,
     TAB,
     CHAR_U
-} from "../chars";
-import { Sink } from "../sink";
-import { unsafeCharCodeAt } from "../util";
+} from "../custom/chars";
+import { Sink } from "../custom/sink";
+import { unsafeCharCodeAt } from "../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function deserializeString(data: string, start: i32 = 0, end: i32 = 0): string {

package/assembly/index.ts

@@ -13,7 +13,7 @@ import { deserializeFloat } from "./deserialize/float";
 import { deserializeObject } from "./deserialize/object";
 import { deserializeMap } from "./deserialize/map";
 import { deserializeDate } from "./deserialize/date";
-import { NULL_WORD } from "./chars";
+import { NULL_WORD } from "./custom/chars";
 import { deserializeInteger } from "./deserialize/integer";
 import { deserializeString } from "./deserialize/string";
 

package/assembly/serialize/array.ts

@@ -6,8 +6,8 @@ import {
     BRACKET_LEFT_WORD,
     BRACKET_RIGHT,
     BRACKET_RIGHT_WORD
-} from "../chars";
-import { Sink } from "../sink";
+} from "../custom/chars";
+import { Sink } from "../custom/sink";
 import { serializeString } from "./string";
 
 // @ts-ignore: Decorator valid here

package/assembly/serialize/map.ts

@@ -1,6 +1,6 @@
-import { COLON, COMMA, BRACE_LEFT_WORD, BRACE_RIGHT } from "../chars";
+import { COLON, COMMA, BRACE_LEFT_WORD, BRACE_RIGHT } from "../custom/chars";
 import { JSON } from "..";
-import { Sink } from "../sink";
+import { Sink } from "../custom/sink";
 
 // @ts-ignore: Decorator valid here
 @inline export function serializeMap<T extends Map<any, any>>(data: T): string {

package/assembly/serialize/string.ts

@@ -5,69 +5,80 @@ import {
     FORM_FEED,
     NEW_LINE,
     QUOTE,
-    QUOTE_WORD,
     TAB
-} from "../chars";
-import { Sink } from "../sink";
-import { unsafeCharCodeAt } from "../util";
+} from "../custom/chars";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { bs } from "../custom/bs";
+import { _intTo16, intTo16 } from "../custom/util";
 
 // @ts-ignore: Decorator valid here
 @inline export function serializeString(data: string): string {
-    if (data.length === 0) {
-        return QUOTE_WORD + QUOTE_WORD;
+    const len = data.length << 1;
+    if (len === 0) {
+        bs.write_16(2228258); /* {} */
+        return bs.out<string>();
     }
 
-    let result = Sink.fromString(QUOTE_WORD, data.length);
+    bs.write_16(QUOTE);
 
     let last: i32 = 0;
-    for (let i = 0; i < data.length; i++) {
-        const char = unsafeCharCodeAt(<string>data, i);
-        if (char === QUOTE || char === BACK_SLASH) {
-            result.write(<string>data, last, i);
-            result.writeCodePoint(BACK_SLASH);
-            last = i;
-        } else if (16 > char) {
-            result.write(<string>data, last, i);
-            last = i + 1;
-            switch (char) {
-                case BACKSPACE: {
-                    result.write("\\b");
-                    break;
-                }
-                case TAB: {
-                    result.write("\\t");
-                    break;
-                }
-                case NEW_LINE: {
-                    result.write("\\n");
-                    break;
-                }
-                case FORM_FEED: {
-                    result.write("\\f");
-                    break;
-                }
-                case CARRIAGE_RETURN: {
-                    result.write("\\r");
-                    break;
-                }
-                default: {
+    for (let i = 0; i < len; i += 2) {
+        const char = load<u16>(changetype<usize>(data) + i);
+        if (char < 35) {
+            if (char === QUOTE) {
+                bs.write_s_se(<string>data, last, i);
+                bs.write_16(BACK_SLASH);
+                last = i;
+                continue;
+            } else if (char < 32) {
+                if (char < 16) {
+                    bs.write_s_se(<string>data, last, i);
+                    last = i + 2;
+                    switch (char) {
+                        case BACKSPACE: {
+                            bs.write_32(6422620);
+                            continue;
+                        }
+                        case TAB: {
+                            bs.write_32(7602268);
+                            continue;
+                        }
+                        case NEW_LINE: {
+                            bs.write_32(7209052);
+                            continue;
+                        }
+                        case FORM_FEED: {
+                            bs.write_32(6684764);
+                            continue;
+                        }
+                        case CARRIAGE_RETURN: {
+                            bs.write_32(7471196);
+                            continue;
+                        }
+                        default: {
+                            // all chars 0-31 must be encoded as a four digit unicode escape sequence
+                            // \u0000 to \u000f handled here
+                            bs.write_64(13511005048209500) /* \\u00 */
+                            bs.write_32((_intTo16(char) << 16) | 48); /* 0_ */
+                            continue;
+                        }
+                    }
+                } else {
+                    bs.write_s_se(<string>data, last, i);
+                    last = i + 2;
                     // all chars 0-31 must be encoded as a four digit unicode escape sequence
-                    // \u0000 to \u000f handled here
-                    result.write("\\u000");
-                    result.write(char.toString(16));
-                    break;
+                    // \u0010 to \u001f handled here
+                    bs.write_64(13511005048209500) /* \\u00 */
+                    bs.write_32((intTo16(char) << 16) | 48); /* 0_ */
                 }
             }
-        } else if (32 > char) {
-            result.write(<string>data, last, i);
-            last = i + 1;
-            // all chars 0-31 must be encoded as a four digit unicode escape sequence
-            // \u0010 to \u001f handled here
-            result.write("\\u00");
-            result.write(char.toString(16));
+        } else if (char === BACK_SLASH) {
+            bs.write_s_se(<string>data, last, i);
+            bs.write_16(BACK_SLASH);
+            last = i;
         }
     }
-    result.write(<string>data, last);
-    result.writeCodePoint(QUOTE);
-    return result.toString();
+    bs.write_s_se_u(<string>data, last, changetype<OBJECT>(changetype<usize>(data) - TOTAL_OVERHEAD).rtSize);
+    bs.write_16(QUOTE);
+    return bs.out<string>();
 }

package/assembly/test.ts

@@ -1,38 +1,42 @@
-import { JSON } from ".";
-@json
-class Vec3 {
-  x: f32 = 0.0;
-  y: f32 = 0.0;
-  z: f32 = 0.0;
-}
+// import { JSON } from ".";
+import { bs } from "./custom/bs";
+// @json
+// class Vec3 {
+//   x: f32 = 0.0;
+//   y: f32 = 0.0;
+//   z: f32 = 0.0;
+// }
 
-@json
-class Player {
-  @alias("first name")
-  firstName!: string;
-  lastName!: string;
-  lastActive!: i32[];
-  // Drop in a code block, function, or expression that evaluates to a boolean
-  @omitif("this.age < 18")
-  age!: i32;
-  @omitnull()
-  pos!: Vec3 | null;
-  isVerified!: boolean;
-}
+// @json
+// class Player {
+//   @alias("first name")
+//   firstName!: string;
+//   lastName!: string;
+//   lastActive!: i32[];
+//   // Drop in a code block, function, or expression that evaluates to a boolean
+//   @omitif("this.age < 18")
+//   age!: i32;
+//   @omitnull()
+//   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 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 stringified = JSON.stringify<Player>(player);
+// const stringified = JSON.stringify<Player>(player);
 
-const parsed = JSON.parse<Player>(stringified);
+// const parsed = JSON.parse<Player>(stringified);
+
+bs.write_32(6422620);
+console.log(bs.out<string>())

package/bench/benchmark.ts

@@ -1,19 +1,32 @@
-import { bench, blackbox } from "as-bench/assembly/bench";
-import { __atoi_fast } from "../assembly/util";
-import { JSON } from "../assembly";
+import { bench } from "as-bench/assembly/bench";
+import { serializeString } from "../assembly/serialize/string";
+import { bs } from "../assembly/custom/bs";
 
 @json
 class Vec3 {
     x: i32;
     y: i32;
     z: i32;
+    __SERIALIZE_BS(): void {
+        bs.write_128_u(i16x8(123, 34, 120, 34, 58, 49, 44, 34)); /* {"x":1," */
+        bs.write_128_u(i16x8(121, 34, 58, 50, 44, 34, 122, 34)); /* y":2,"z" */
+        bs.write_32_u(3342394); /* :3 */
+        bs.write_16_u(125); /* } */
+    }
 }
-
+const out = memory.data(1000);
 const vec: Vec3 = {
     x: 3,
     y: 1,
     z: 8,
 }
+bench("Stringify Vec3", () => {
+    vec.__SERIALIZE_BS();
+    //bs.reset()
+})
+bench("Stringify String", () => {
+    serializeString('Hello World');
+});
 /*
 bench("Parse Number SNIP", () => {
     blackbox<i32>(snip_fast<i32>("12345"));
@@ -29,7 +42,7 @@ bench("Parse Number STDLIB", () => {
 
 bench("Stringify Object (Vec3)", () => {
     blackbox<string>(JSON.stringify(vec));
-});*/
+});
 
 bench("Parse Object (Vec3)", () => {
     blackbox<Vec3>(JSON.parse<Vec3>('{"x":0,"y":0,"z":0}'));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "json-as",
-  "version": "0.9.11",
-  "description": "JSON encoder/decoder for AssemblyScript",
+  "version": "0.9.12",
+  "description": "The only JSON library you'll need for AssemblyScript. SIMD enabled",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
   "contributors": [
@@ -18,7 +18,7 @@
     "test": "ast test",
     "pretest": "rm -rf ./build/ && ast build",
     "build:test": "rm -rf ./build/ && JSON_DEBUG=true asc assembly/test.ts --transform ./transform -o ./build/test.wasm",
-    "build:bench": "asc bench/benchmark.ts -o bench/benchmark.wasm --transform ./transform --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior always --runtime stub",
+    "build:bench": "asc bench/benchmark.ts -o bench/benchmark.wasm --transform ./transform --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior always --runtime stub --enable simd",
     "bench:wasmtime": "wasmtime ./bench/benchmark.wasm",
     "bench:wasmer": "wasmer --llvm ./bench/benchmark.wasm",
     "build:transform": "tsc -p ./transform",
@@ -32,8 +32,8 @@
     "@assemblyscript/wasi-shim": "^0.1.0",
     "as-bench": "^0.0.0-alpha",
     "as-console": "^7.0.0",
-    "as-test": "0.1.7",
-    "assemblyscript": "^0.27.28",
+    "as-test": "0.1.9",
+    "assemblyscript": "^0.27.29",
     "assemblyscript-prettier": "^3.0.1",
     "benchmark": "^2.1.4",
     "microtime": "^3.1.1",

package/transform/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@json-as/transform",
-  "version": "0.9.11",
-  "description": "JSON encoder/decoder for AssemblyScript",
+  "version": "0.9.12",
+  "description": "The only JSON library you'll need for AssemblyScript. SIMD enabled",
   "main": "./lib/index.js",
   "author": "Jairus Tanaka",
   "contributors": [

package/assembly/serialize/unknown.ts

@@ -1,45 +0,0 @@
-import { JSON } from "..";
-import { Sink } from "../sink";
-import { __atoi_fast } from "../util";
-import { serializeBool } from "./bool";
-import { serializeFloat } from "./float";
-import { serializeInteger } from "./integer";
-import { serializeString } from "./string";
-
-/**
- * Serializes unknown values into their correct serializer and returns the data.
- *
- * @param data - The JSON.Value to be serialized.
- * @returns The serialized result.
- */
-// @ts-ignore: Decorator valid here
-@inline export function serializeUnknown(data: JSON.Value): string {
-    const type = data.type;
-    switch (type) {
-        case JSON.Types.String: {
-            return serializeString(data.get<string>());
-        }
-        case JSON.Types.Bool: {
-            return serializeBool(data.get<bool>());
-        }
-        case JSON.Types.U8: {
-            return serializeInteger(data.get<u8>());
-        }
-        case JSON.Types.U16: {
-            return serializeInteger(data.get<u16>());
-        }
-        case JSON.Types.U32: {
-            return serializeInteger(data.get<u32>());
-        }
-        case JSON.Types.U64: {
-            return serializeInteger(data.get<u64>());
-        }
-        case JSON.Types.F32: {
-            return serializeFloat(data.get<f32>());
-        }
-        case JSON.Types.F64: {
-            return serializeFloat(data.get<f64>());
-        }
-    }
-    return "ERROR"//serializeUnknownArray(data.get<JSON.Value[]>());
-}