json-as 1.3.1 → 1.3.2

package/assembly/index.ts

@@ -17,15 +17,26 @@ import { serializeSet } from "./serialize/index/set";
 import { deserializeSet } from "./deserialize/index/set";
 import { serializeStaticArray } from "./serialize/index/staticarray";
 import { deserializeStaticArray } from "./deserialize/index/staticarray";
-
-import { NULL_WORD, QUOTE, NULL_WORD_U64, TRUE_WORD_U64, FALSE_WORD_U64 } from "./custom/chars";
-import { dtoa_buffered, itoa_buffered } from "util/number";
+import {
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+  NULL_WORD,
+  QUOTE,
+  NULL_WORD_U64,
+  TRUE_WORD_U64,
+  FALSE_WORD_U64,
+} from "./custom/chars";
+import { itoa_buffered } from "util/number";
 import { serializeBool } from "./serialize/index/bool";
 import { serializeInteger } from "./serialize/index/integer";
-import { serializeFloat } from "./serialize/index/float";
+import { serializeFloat, serializeFloat32, serializeFloat64 } from "./serialize/index/float";
+import { dragonbox_f32_buffered, dragonbox_f64_buffered } from "./util/dragonbox";
 import { serializeStruct } from "./serialize/index/struct";
 import { ptrToStr } from "./util/ptrToStr";
-import { atoi, bytes } from "./util";
+import { atoi, bytes, scanStringEnd } from "./util";
 import { deserializeArbitrary } from "./deserialize/index/arbitrary";
 import { serializeObject } from "./serialize/index/object";
 import { deserializeObject } from "./deserialize/index/object";
@@ -101,13 +112,9 @@ export namespace JSON {
       }
       return data.toString();
     } else if (isFloat<T>(data)) {
-      if (out) {
-        out = changetype<string>(__renew(changetype<usize>(out), 64));
-
-        const bytes = dtoa_buffered(changetype<usize>(out), data) << 1;
-        return (out = changetype<string>(__renew(changetype<usize>(out), bytes)));
-      }
-      return data.toString();
+      out = out ? changetype<string>(__renew(changetype<usize>(out), 64)) : changetype<string>(__new(64, idof<string>()));
+      const bytes = (sizeof<T>() == 4 ? dragonbox_f32_buffered(changetype<usize>(out), <f32>data) : dragonbox_f64_buffered(changetype<usize>(out), <f64>data)) << 1;
+      return changetype<string>(__renew(changetype<usize>(out), bytes));
     } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
       if (out) {
         out = changetype<string>(__renew(changetype<usize>(out), 8));
@@ -234,12 +241,16 @@ export namespace JSON {
         // @ts-expect-error
         return out.__DESERIALIZE_CUSTOM(data);
         // @ts-expect-error: Defined by transform
-      } else if (isDefined(type.__DESERIALIZE)) {
+      } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
         const out = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
         // @ts-expect-error: Defined by transform
         if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
         // @ts-expect-error: Defined by transform
-        out.__DESERIALIZE(dataPtr, dataPtr + dataSize, out);
+        if (isDefined(type.__DESERIALIZE_FAST)) {
+          // @ts-expect-error: Defined by transform
+          out.__DESERIALIZE_FAST(dataPtr, dataPtr + dataSize, out);
+          // @ts-expect-error: Defined by transform
+        } else out.__DESERIALIZE_SLOW(dataPtr, dataPtr + dataSize, out);
         return out;
       }
       if (type instanceof StaticArray) {
@@ -842,7 +853,9 @@ export namespace JSON {
       serializeInteger<T>(data);
     } else if (isFloat<T>(data)) {
       // @ts-expect-error
-      serializeFloat<T>(data);
+      if (sizeof<T>() == 4) serializeFloat32(<f32>data);
+      // @ts-expect-error
+      else serializeFloat64(<f64>data);
     } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
       bs.proposeSize(8);
       store<u64>(bs.offset, NULL_WORD_U64);
@@ -940,12 +953,14 @@ export namespace JSON {
         // @ts-expect-error: Defined by transform
         return out.__DESERIALIZE_CUSTOM(ptrToStr(srcStart, srcEnd));
         // @ts-expect-error: Defined by transform
-      } else if (isDefined(type.__DESERIALIZE)) {
+      } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
         const out = changetype<nonnull<T>>(dst || __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
         // @ts-expect-error: Defined by transform
         if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
         // @ts-expect-error: Defined by transform
-        out.__DESERIALIZE(srcStart, srcEnd, out);
+        if (isDefined(type.__DESERIALIZE_FAST)) out.__DESERIALIZE_FAST(srcStart, srcEnd, out);
+        // @ts-expect-error: Defined by transform
+        else out.__DESERIALIZE_SLOW(srcStart, srcEnd, out);
         return out;
       }
       if (type instanceof StaticArray) {
@@ -1010,6 +1025,48 @@ export namespace JSON {
       return code == 0x20 || code - 9 <= 4;
     }
     // @ts-expect-error: decorator
+    @inline export function scanValueEnd(srcStart: usize, srcEnd: usize): usize {
+      if (srcStart >= srcEnd) return 0;
+      let ptr = srcStart;
+      while (ptr < srcEnd && isSpace(load<u16>(ptr))) ptr += 2;
+      if (ptr >= srcEnd) return 0;
+      const first = load<u16>(ptr);
+
+      if (first == QUOTE) {
+        const endQuote = scanStringEnd(ptr, srcEnd);
+        return endQuote >= srcEnd ? 0 : endQuote + 2;
+      }
+
+      if (first == BRACE_LEFT || first == BRACKET_LEFT) {
+        let depth: i32 = 1;
+        ptr += 2;
+        while (ptr < srcEnd) {
+          const code = load<u16>(ptr);
+          if (code == QUOTE) {
+            const endQuote = scanStringEnd(ptr, srcEnd);
+            if (endQuote >= srcEnd) return 0;
+            ptr = endQuote + 2;
+            continue;
+          }
+          if (code == BRACE_LEFT || code == BRACKET_LEFT) {
+            depth++;
+          } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
+            if (--depth == 0) return ptr + 2;
+          }
+          ptr += 2;
+        }
+        return 0;
+      }
+
+      while (ptr < srcEnd) {
+        const code = load<u16>(ptr);
+        if (code == COMMA || code == BRACKET_RIGHT || code == BRACE_RIGHT || isSpace(code)) return ptr;
+        ptr += 2;
+      }
+
+      return ptr;
+    }
+    // @ts-expect-error: decorator
     @inline export function ptrToStr(start: usize, end: usize): string {
       const size = end - start;
       const out = __new(size, idof<string>());

package/assembly/serialize/index/arbitrary.ts

@@ -2,7 +2,7 @@ import { JSON } from "../..";
 import { bs } from "../../../lib/as-bs";
 import { serializeArray } from "./array";
 import { serializeBool } from "./bool";
-import { serializeFloat } from "./float";
+import { serializeFloat32, serializeFloat64 } from "./float";
 import { serializeInteger } from "./integer";
 import { serializeMap } from "./map";
 import { serializeObject } from "./object";
@@ -41,10 +41,10 @@ export function serializeArbitrary(src: JSON.Value): void {
       serializeInteger<i64>(src.get<i64>());
       break;
     case JSON.Types.F32:
-      serializeFloat<f32>(src.get<f32>());
+      serializeFloat32(src.get<f32>());
       break;
     case JSON.Types.F64:
-      serializeFloat<f64>(src.get<f64>());
+      serializeFloat64(src.get<f64>());
       break;
     case JSON.Types.String:
       serializeString(src.get<string>());

package/assembly/serialize/index/float.ts

@@ -1 +1 @@
-export { serializeFloat } from "../simple/float";
+export { serializeFloat, serializeFloat32, serializeFloat64 } from "../simple/float";

package/assembly/serialize/index/object.ts

@@ -18,29 +18,25 @@ export function serializeObject(src: JSON.Obj): void {
   const keys = src.keys();
   const values = src.values();
 
-  bs.growSize(2);
+  bs.proposeSize(4 + <u32>(srcSize - 1) * 2 + <u32>srcSize * 2);
   store<u16>(bs.offset, BRACE_LEFT);
   bs.offset += 2;
 
   for (let i = 0; i < srcEnd; i++) {
     serializeString(unchecked(keys[i]));
-    bs.growSize(2);
     store<u16>(bs.offset, COLON);
     bs.offset += 2;
 
     serializeArbitrary(unchecked(values[i]));
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   serializeString(unchecked(keys[srcEnd]));
-  bs.growSize(2);
   store<u16>(bs.offset, COLON);
   bs.offset += 2;
   serializeArbitrary(unchecked(values[srcEnd]));
 
-  bs.growSize(2);
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simd/string.ts

@@ -55,16 +55,15 @@ export function serializeString_SIMD(src: string): void {
     // console.log("lt20   : " + mask_to_string_v128(lt20) + " -> " + mask_to_string_v128(SPLAT_0020));
     // console.log("gteD8  : " + mask_to_string_v128(gteD8) + " -> " + mask_to_string_v128(SPLAT_FFD8));
 
-    const sieve = v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8)));
-    // console.log("sieve  : " + mask_to_string_v128(sieve));
+    let mask = i8x16.bitmask(v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8))));
 
-    if (!v128.any_true(sieve)) {
+    if (mask == 0) {
       bs.offset += 16;
       srcStart += 16;
       continue;
     }
 
-    let mask = i8x16.bitmask(sieve);
+    bs.growSize(popcnt(mask) * 10 + 12);
 
     do {
       const laneIdx = ctz(mask);
@@ -110,7 +109,7 @@ export function serializeString_SIMD(src: string): void {
         const next = load<u16>(srcIdx, 1);
         if (next >= 0xdc00 && next <= 0xdfff) {
           // paired surrogate
-          mask &= mask - 1;
+          mask &= ~(0b11 << (laneIdx + 1));
           continue;
         }
       }

package/assembly/serialize/simple/arbitrary.ts

@@ -2,7 +2,7 @@ import { JSON } from "../..";
 import { bs } from "../../../lib/as-bs";
 import { serializeArray } from "./array";
 import { serializeBool } from "./bool";
-import { serializeFloat } from "./float";
+import { serializeFloat32, serializeFloat64 } from "./float";
 import { serializeInteger } from "./integer";
 import { serializeMap } from "./map";
 import { serializeObject } from "./object";
@@ -41,10 +41,10 @@ export function serializeArbitrary(src: JSON.Value): void {
       serializeInteger<i64>(src.get<i64>());
       break;
     case JSON.Types.F32:
-      serializeFloat<f32>(src.get<f32>());
+      serializeFloat32(src.get<f32>());
       break;
     case JSON.Types.F64:
-      serializeFloat<f64>(src.get<f64>());
+      serializeFloat64(src.get<f64>());
       break;
     case JSON.Types.String:
       serializeString(src.get<string>());

package/assembly/serialize/simple/array.ts

@@ -1,16 +1,29 @@
 import { bs } from "../../../lib/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
+import { serializeFloat32, serializeFloat64 } from "./float";
+
+@inline
+function serializeArrayElement<T>(value: T): void {
+  if (isFloat<T>()) {
+    if (sizeof<T>() == 4) serializeFloat32(<f32>value);
+    else serializeFloat64(<f64>value);
+    return;
+  }
+  JSON.__serialize<T>(value);
+}
 
 export function serializeArray<T extends any[]>(src: T): void {
-  bs.proposeSize(4);
-  const end = src.length - 1;
+  const len = src.length;
+  const end = len - 1;
   let i = 0;
   if (end == -1) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939);
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(len - 1) * 2);
   // {} = 4
   // xi, = n << 1
 
@@ -19,15 +32,13 @@ export function serializeArray<T extends any[]>(src: T): void {
 
   while (i < end) {
     const block = unchecked(src[i++]);
-    JSON.__serialize<valueof<T>>(block);
-    bs.growSize(2);
+    serializeArrayElement<valueof<T>>(block);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   const lastBlock = unchecked(src[end]);
-  JSON.__serialize<valueof<T>>(lastBlock);
-  // bs.growSize(2);
+  serializeArrayElement<valueof<T>>(lastBlock);
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/float.ts

@@ -1,10 +1,24 @@
 import { bs } from "../../../lib/as-bs";
-import { dtoa_buffered } from "util/number";
+import { dragonbox_f32_buffered, dragonbox_f64_buffered } from "../../util/dragonbox";
 
-// @ts-ignore: inline
-@inline export function serializeFloat<T extends number>(data: T): void {
+@inline
+export function serializeFloat32(data: f32): void {
   bs.ensureSize(64);
-  const size = dtoa_buffered(bs.offset, data) << 1;
+  const size = dragonbox_f32_buffered(bs.offset, data) << 1;
   bs.stackSize += size;
   bs.offset += size;
 }
+
+@inline
+export function serializeFloat64(data: f64): void {
+  bs.ensureSize(64);
+  const size = dragonbox_f64_buffered(bs.offset, data) << 1;
+  bs.stackSize += size;
+  bs.offset += size;
+}
+
+// @ts-ignore: inline
+@inline export function serializeFloat<T extends number>(data: T): void {
+  if (sizeof<T>() == 4) serializeFloat32(<f32>data);
+  else serializeFloat64(<f64>data);
+}

package/assembly/serialize/simple/map.ts

@@ -15,52 +15,35 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
 
   let keys = src.keys();
   let values = src.values();
+  const keyIsString = isString<indexof<T>>();
 
-  bs.proposeSize(4);
+  bs.proposeSize(4 + <u32>(srcSize - 1) * 2 + <u32>srcSize * 2);
 
   store<u16>(bs.offset, BRACE_LEFT);
   bs.offset += 2;
 
   for (let i = 0; i < srcEnd; i++) {
-    // @ts-ignore: Valid
-    if (!isString<indexof<T>>()) {
-      bs.growSize(6);
-      store<u16>(bs.offset, 34);
-      bs.offset += 2;
+    if (keyIsString) {
       JSON.__serialize(unchecked(keys[i]));
-      store<u16>(bs.offset, 34);
-      store<u16>(bs.offset, COLON, 2);
-      bs.offset += 4;
     } else {
-      JSON.__serialize(unchecked(keys[i]));
-      bs.growSize(2);
-      store<u16>(bs.offset, COLON);
-      bs.offset += 2;
+      JSON.__serialize<string>(JSON.internal.stringify<indexof<T>>(unchecked(keys[i])));
     }
+    store<u16>(bs.offset, COLON);
+    bs.offset += 2;
     JSON.__serialize(unchecked(values[i]));
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
-  // @ts-ignore: Valid
-  if (!isString<indexof<T>>()) {
-    bs.growSize(6);
-    store<u16>(bs.offset, 34);
-    bs.offset += 2;
+  if (keyIsString) {
     JSON.__serialize(unchecked(keys[srcEnd]));
-    store<u16>(bs.offset, 34);
-    store<u16>(bs.offset, COLON, 2);
-    bs.offset += 4;
   } else {
-    JSON.__serialize(unchecked(keys[srcEnd]));
-    bs.growSize(2);
-    store<u16>(bs.offset, COLON);
-    bs.offset += 2;
+    JSON.__serialize<string>(JSON.internal.stringify<indexof<T>>(unchecked(keys[srcEnd])));
   }
+  store<u16>(bs.offset, COLON);
+  bs.offset += 2;
 
   JSON.__serialize(unchecked(values[srcEnd]));
-  // bs.growSize(2);
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/object.ts

@@ -18,29 +18,25 @@ export function serializeObject(src: JSON.Obj): void {
   const keys = src.keys();
   const values = src.values();
 
-  bs.growSize(2);
+  bs.proposeSize(4 + <u32>(srcSize - 1) * 2 + <u32>srcSize * 2);
   store<u16>(bs.offset, BRACE_LEFT);
   bs.offset += 2;
 
   for (let i = 0; i < srcEnd; i++) {
     serializeString_SWAR(unchecked(keys[i]));
-    bs.growSize(2);
     store<u16>(bs.offset, COLON);
     bs.offset += 2;
 
     serializeArbitrary(unchecked(values[i]));
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   serializeString_SWAR(unchecked(keys[srcEnd]));
-  bs.growSize(2);
   store<u16>(bs.offset, COLON);
   bs.offset += 2;
   serializeArbitrary(unchecked(values[srcEnd]));
 
-  bs.growSize(2);
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/set.ts

@@ -3,25 +3,24 @@ import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
 
 export function serializeSet<T extends Set<any>>(src: T): void {
-  bs.proposeSize(4);
   const srcSize = src.size;
   if (srcSize == 0) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939); // []
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(srcSize - 1) * 2);
 
   const values = src.values();
-  const end = srcSize - 1;
-
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
 
+  const end = srcSize - 1;
   for (let i = 0; i < end; i++) {
     const block = unchecked(values[i]);
     // @ts-ignore: type
     JSON.__serialize<indexof<T>>(block);
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }

package/assembly/serialize/simple/staticarray.ts

@@ -3,14 +3,16 @@ import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
 
 export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
-  bs.proposeSize(4);
-  const end = src.length - 1;
+  const len = src.length;
+  const end = len - 1;
   let i = 0;
   if (end == -1) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939); // []
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(len - 1) * 2);
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
@@ -18,7 +20,6 @@ export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
   while (i < end) {
     const block = unchecked(src[i++]);
     JSON.__serialize<valueof<T>>(block);
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }

package/assembly/serialize/simple/typedarray.ts

@@ -1,33 +1,35 @@
 import { bs } from "../../../lib/as-bs";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
-import { serializeFloat } from "./float";
+import { serializeFloat32, serializeFloat64 } from "./float";
 import { serializeInteger } from "./integer";
 
 
 @inline
 function serializeTypedArrayElement<T extends ArrayLike<number>>(src: T, index: i32): void {
   if (isFloat<valueof<T>>()) {
-    serializeFloat<valueof<T>>(unchecked(src[index]));
+    if (sizeof<valueof<T>>() == 4) serializeFloat32(<f32>unchecked(src[index]));
+    else serializeFloat64(<f64>unchecked(src[index]));
   } else {
     serializeInteger<valueof<T>>(unchecked(src[index]));
   }
 }
 
 export function serializeTypedArray<T extends ArrayLike<number>>(src: T): void {
-  bs.proposeSize(4);
-  const end = src.length - 1;
+  const len = src.length;
+  const end = len - 1;
   if (end == -1) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939);
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(len - 1) * 2);
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
 
   for (let i = 0; i < end; i++) {
     serializeTypedArrayElement(src, i);
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
@@ -40,19 +42,19 @@ export function serializeTypedArray<T extends ArrayLike<number>>(src: T): void {
 export function serializeArrayBufferUnsafe(srcStart: usize, byteLength: i32): void {
   const end = byteLength - 1;
 
-  bs.proposeSize(4);
   if (end == -1) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939);
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(end) * 2);
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
 
   for (let i = 0; i < end; i++) {
     serializeInteger<u8>(load<u8>(srcStart + <usize>i));
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }

package/assembly/serialize/swar/string.ts

@@ -5,7 +5,6 @@ import { u16_to_hex4_swar } from "../../util/swar";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
 // @ts-expect-error: @lazy is a valid decorator
-// @ts-nocheck
 @lazy const U00_MARKER = 13511005048209500;
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const U_MARKER = 7667804;

package/assembly/tsconfig.json

@@ -2,6 +2,7 @@
   "extends": "assemblyscript/std/assembly.json",
   "include": ["./**/*.ts"],
   "compilerOptions": {
+    "allowImportingTsExtensions": true,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
 
@@ -18,6 +19,6 @@
     "noUnusedParameters": false,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": false
-  }
+    "noUncheckedIndexedAccess": false,
+  },
 }