json-as 1.3.0 → 1.3.2

package/assembly/deserialize/index/array.ts

@@ -4,6 +4,7 @@ import { deserializeArrayArray } from "../simple/array/array";
 import { deserializeBooleanArray } from "../simple/array/bool";
 import { deserializeBoxArray } from "../simple/array/box";
 import { deserializeFloatArray } from "../simple/array/float";
+import { deserializeGenericArray } from "../simple/array/generic";
 import { deserializeIntegerArray as deserializeIntegerArray_NAIVE } from "../simple/array/integer";
 import { deserializeMapArray } from "../simple/array/map";
 import { deserializeObjectArray } from "../simple/array/object";
@@ -45,13 +46,17 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
       return deserializeObjectArray<T>(srcStart, srcEnd, dst);
     } else if (type instanceof JSON.Raw) {
       return deserializeRawArray(srcStart, srcEnd, dst) as T;
+    } else if (type instanceof Date) {
+      return deserializeGenericArray<T>(srcStart, srcEnd, dst);
+    } else if (type instanceof Set) {
+      return deserializeGenericArray<T>(srcStart, srcEnd, dst);
     } else if (type instanceof Map) {
       return deserializeMapArray<T>(srcStart, srcEnd, dst);
       // @ts-ignore: defined by transform
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
       return deserializeStructArray<T>(srcStart, srcEnd, dst);
       // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE)) {
+    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
       return deserializeStructArray<T>(srcStart, srcEnd, dst);
     }
     throw new Error("Could not parse array of type " + nameof<T>() + "!");

package/assembly/deserialize/index/float.ts

@@ -1 +1 @@
-export { deserializeFloat } from "../float";
+export { deserializeFloat } from "../simple/float";

package/assembly/deserialize/index/integer.ts

@@ -1 +1 @@
-export { deserializeInteger } from "../integer";
+export { deserializeInteger } from "../simple/integer";

package/assembly/deserialize/index/typedarray.ts

@@ -1 +1,15 @@
+import { bytes } from "../../util";
 export { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";
+import { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";
+
+
+@inline export function parseArrayBuffer(data: string): ArrayBuffer {
+  const dataSize = bytes(data);
+  const dataPtr = changetype<usize>(data);
+  return deserializeArrayBuffer(dataPtr, dataPtr + dataSize, 0);
+}
+
+
+@inline export function __deserializeArrayBuffer(srcStart: usize, srcEnd: usize, dst: usize = 0): ArrayBuffer {
+  return deserializeArrayBuffer(srcStart, srcEnd, dst);
+}

package/assembly/deserialize/index/unsigned.ts

@@ -1 +1 @@
-export { deserializeUnsigned } from "../unsigned";
+export { deserializeUnsigned } from "../simple/unsigned";

package/assembly/deserialize/simd/string.ts

@@ -1,5 +1,6 @@
 import { bs } from "../../../lib/as-bs";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { __heap_base } from "memory";
 import { QUOTE } from "../../custom/chars";
 import { BACK_SLASH } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
@@ -81,11 +82,13 @@ import { deserializeStringField_SWAR } from "../swar/string";
 
   const current = load<usize>(dstFieldPtr);
   let stringPtr: usize;
-  if (current != 0 && changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
-    stringPtr = current;
-  } else if (current != 0 && current != changetype<usize>("")) {
-    stringPtr = __renew(current, byteLength);
-    store<usize>(dstFieldPtr, stringPtr);
+  if (current >= __heap_base) {
+    if (changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
+      stringPtr = current;
+    } else {
+      stringPtr = __renew(current, byteLength);
+      store<usize>(dstFieldPtr, stringPtr);
+    }
   } else {
     stringPtr = __new(byteLength, idof<string>());
     store<usize>(dstFieldPtr, stringPtr);
@@ -93,16 +96,18 @@ import { deserializeStringField_SWAR } from "../swar/string";
   memory.copy(stringPtr, srcStart, byteLength);
 }
 
+// @ts-expect-error: @inline is a valid decorator
+
 // todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
 // @ts-expect-error: @inline is a valid decorator
 @inline function deserializeEscapedString_SIMD(payloadStart: usize, escapeStart: usize, srcEnd: usize): string {
   const prefixLen = <u32>(escapeStart - payloadStart);
   let srcStart = escapeStart;
   const srcEnd16 = srcEnd - 16;
+  const outStart = bs.offset - bs.buffer;
   bs.ensureSize(u32(srcEnd - srcStart));
-  bs.offset = bs.buffer;
   if (prefixLen != 0) {
-    memory.copy(bs.buffer, payloadStart, prefixLen);
+    memory.copy(bs.offset, payloadStart, prefixLen);
     bs.offset += prefixLen;
   }
 
@@ -111,16 +116,14 @@ import { deserializeStringField_SWAR } from "../swar/string";
     store<v128>(bs.offset, block);
 
     const eq5C = i16x8.eq(block, SPLAT_5C);
+    let mask = i16x8.bitmask(eq5C);
 
-    // Early exit
-    if (!v128.any_true(eq5C)) {
+    if (mask == 0) {
       srcStart += 16;
       bs.offset += 16;
       continue;
     }
 
-    let mask = i16x8.bitmask(eq5C);
-
     let srcChg: usize = 0;
     let lastLane: usize = 0;
     do {
@@ -195,7 +198,7 @@ import { deserializeStringField_SWAR } from "../swar/string";
     bs.offset += 2;
   }
 
-  return bs.out<string>();
+  return bs.sliceOut<string>(outStart);
 }
 
 export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
@@ -207,14 +210,14 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 
   while (srcStart < srcEnd16) {
     const block = load<v128>(srcStart);
-    const eq5C = i16x8.eq(block, SPLAT_5C);
+    const mask = i16x8.bitmask(i16x8.eq(block, SPLAT_5C));
 
-    if (!v128.any_true(eq5C)) {
+    if (mask == 0) {
       srcStart += 16;
       continue;
     }
 
-    const laneIdx = usize(ctz(i16x8.bitmask(eq5C)) << 1);
+    const laneIdx = usize(ctz(mask) << 1);
     return inline.always(deserializeEscapedString_SIMD(payloadStart, srcStart + laneIdx, srcEnd));
   }
 
@@ -229,7 +232,8 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 }
 
 // @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeStringField_SIMD<T extends string | null>(srcStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
+@inline export function deserializeStringField_SIMD<T extends string | null>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const dstFieldPtr = dstObj + dstOffset;
   if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) abort("Expected leading quote");
 
   const quotedStart = srcStart;

package/assembly/deserialize/simple/arbitrary.ts

@@ -1,7 +1,7 @@
 import { JSON } from "../..";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
-import { deserializeFloat } from "../float";
+import { deserializeFloat } from "./float";
 import { deserializeString } from "./string";
 import { deserializeObject } from "./object";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";

package/assembly/deserialize/simple/array/generic.ts

@@ -0,0 +1,42 @@
+import { JSON } from "../../..";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { isSpace } from "../../../util";
+import { scanValueEnd } from "../../swar/array/shared";
+
+export function deserializeGenericArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+  out.length = 0;
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
+  if (srcStart >= srcEnd) throw new Error("Input string had zero length or was all whitespace");
+  if (load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Expected '[' at start of array");
+  srcStart += 2;
+
+  while (srcStart < srcEnd) {
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+
+    if (load<u16>(srcStart) == BRACKET_RIGHT) return out;
+
+    const valueEnd = scanValueEnd(srcStart, srcEnd);
+    if (!valueEnd || valueEnd <= srcStart) break;
+
+    out.push(JSON.__deserialize<valueof<T>>(srcStart, valueEnd));
+    srcStart = valueEnd;
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+
+    const code = load<u16>(srcStart);
+    if (code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACKET_RIGHT) return out;
+    break;
+  }
+
+  throw new Error("Failed to parse JSON!");
+}

package/assembly/deserialize/simple/array.ts

@@ -3,6 +3,7 @@ import { deserializeArbitraryArray } from "./array/arbitrary";
 import { deserializeArrayArray } from "./array/array";
 import { deserializeBooleanArray } from "./array/bool";
 import { deserializeFloatArray } from "./array/float";
+import { deserializeGenericArray } from "./array/generic";
 import { deserializeIntegerArray } from "./array/integer";
 import { deserializeMapArray } from "./array/map";
 import { deserializeStructArray } from "./array/struct";
@@ -42,6 +43,12 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
     } else if (type instanceof JSON.Raw) {
       // @ts-ignore: type
       return deserializeRawArray(srcStart, srcEnd, dst);
+    } else if (type instanceof Date) {
+      // @ts-ignore: type
+      return deserializeGenericArray<T>(srcStart, srcEnd, dst);
+    } else if (type instanceof Set) {
+      // @ts-ignore: type
+      return deserializeGenericArray<T>(srcStart, srcEnd, dst);
     } else if (type instanceof Map) {
       // @ts-ignore: type
       return deserializeMapArray<T>(srcStart, srcEnd, dst);
@@ -49,7 +56,7 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
       return deserializeStructArray<T>(srcStart, srcEnd, dst);
       // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE)) {
+    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
       return deserializeStructArray<T>(srcStart, srcEnd, dst);
     }
     throw new Error("Could not parse array of type " + nameof<T>() + "!");

package/assembly/deserialize/{float.ts → simple/float.ts}

@@ -1,7 +1,26 @@
-import { ptrToStr } from "../util/ptrToStr";
+import { ptrToStr } from "../../util/ptrToStr";
 
 // @ts-ignore: inline
 @inline function pow10Fast(exponent: u32): f64 {
+  if (exponent == 0) return 1.0;
+  if (exponent == 1) return 10.0;
+  if (exponent == 2) return 100.0;
+  if (exponent == 3) return 1e3;
+  if (exponent == 4) return 1e4;
+  if (exponent == 5) return 1e5;
+  if (exponent == 6) return 1e6;
+  if (exponent == 7) return 1e7;
+  if (exponent == 8) return 1e8;
+  if (exponent == 9) return 1e9;
+  if (exponent == 10) return 1e10;
+  if (exponent == 11) return 1e11;
+  if (exponent == 12) return 1e12;
+  if (exponent == 13) return 1e13;
+  if (exponent == 14) return 1e14;
+  if (exponent == 15) return 1e15;
+  if (exponent == 16) return 1e16;
+  if (exponent == 17) return 1e17;
+  if (exponent == 18) return 1e18;
   let result = 1.0;
   if (exponent & 1) result *= 1e1;
   if (exponent & 2) result *= 1e2;
@@ -100,7 +119,8 @@ import { ptrToStr } from "../util/ptrToStr";
 }
 
 // @ts-ignore: inline
-@inline export function deserializeFloatField<T extends number>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+@inline export function deserializeFloatField<T extends number>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const fieldPtr = dstObj + dstOffset;
   let negative = false;
   if (load<u16>(srcStart) == 45) {
     negative = true;

package/assembly/deserialize/{integer.ts → simple/integer.ts}

@@ -1,4 +1,4 @@
-import { atoi } from "../util/atoi";
+import { atoi } from "../../util/atoi";
 
 // @ts-ignore: inline
 @inline export function deserializeInteger<T>(srcStart: usize, srcEnd: usize): T {
@@ -6,7 +6,8 @@ import { atoi } from "../util/atoi";
 }
 
 // @ts-ignore: inline
-@inline export function deserializeIntegerField<T extends number>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+@inline export function deserializeIntegerField<T extends number>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const fieldPtr = dstObj + dstOffset;
   let negative = false;
   if (load<u16>(srcStart) == 45) {
     negative = true;

package/assembly/deserialize/simple/map.ts

@@ -1,17 +1,17 @@
 import { JSON } from "../..";
 import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
 import { isSpace, isUnescapedQuote, scanStringEnd } from "../../util";
+import { scanValueEnd } from "../swar/array/shared";
 
 // @ts-ignore: Decorator is valid here
-@inline function normalizeQuotes<T>(start: usize, end: usize): T {
-  if (isString<T>()) return JSON.__deserialize<T>(start - 2, end + 2);
-  return JSON.__deserialize<T>(start, end);
+@inline function deserializeMapKey<T>(start: usize, end: usize): T {
+  const keyText = JSON.__deserialize<string>(start - 2, end + 2);
+  if (isString<T>()) return changetype<T>(keyText);
+  return JSON.parse<T>(keyText);
 }
 
 export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
   const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
-  // @ts-ignore: type
-  if (!isString<indexof<T>>() && !isInteger<indexof<T>>() && !isFloat<indexof<T>>()) throw new Error("Map key must also be a valid JSON key!");
 
   let keyStart: usize = 0;
   let keyEnd: usize = 0;
@@ -53,7 +53,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         srcStart = scanStringEnd(srcStart, srcEnd);
         if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON object");
         // @ts-ignore: type
-        out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart + 2));
+        out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart + 2));
         srcStart += 2;
         keyStart = 0;
         continue;
@@ -65,7 +65,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
           if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
             // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
             // @ts-ignore: type
-            out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
             // while (isSpace(load<u16>((srcStart += 2)))) {
             //   /* empty */
             // }
@@ -89,7 +89,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
             if (--depth == 0) {
               // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
               // @ts-ignore: type
-              out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+              out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>(srcStart))) {
@@ -113,7 +113,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
             if (--depth == 0) {
               // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
               // @ts-ignore: type
-              out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+              out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
               // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
               keyStart = 0;
               // while (isSpace(load<u16>((srcStart += 2)))) {
@@ -128,7 +128,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         if (load<u64>(srcStart) == 28429475166421108) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
           // @ts-ignore: type
-          out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -140,7 +140,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         if (load<u64>(srcStart, 2) == 28429466576093281) {
           // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
           // @ts-ignore: type
-          out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 10)));
+          out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 10)));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           //   /* empty */
           // }
@@ -152,7 +152,7 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
         if (load<u64>(srcStart) == 30399761348886638) {
           // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
           // @ts-ignore: type
-          out.set(normalizeQuotes<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          out.set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
           // while (isSpace(load<u16>((srcStart += 2)))) {
           /* empty */
           // }
@@ -169,3 +169,51 @@ export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd:
   }
   return out;
 }
+
+@inline export function deserializeMapInto<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, out: T): usize {
+  changetype<nonnull<T>>(out).clear();
+
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACE_LEFT) throw new Error("Failed to parse JSON!");
+  srcStart += 2;
+  if (srcStart >= srcEnd) throw new Error("Failed to parse JSON!");
+  if (load<u16>(srcStart) == BRACE_RIGHT) return srcStart + 2;
+
+  while (srcStart < srcEnd) {
+    if (load<u16>(srcStart) != QUOTE) break;
+
+    const keyStart = srcStart + 2;
+    const keyEnd = scanStringEnd(srcStart, srcEnd);
+    if (keyEnd >= srcEnd) break;
+
+    srcStart = keyEnd + 2;
+    if (srcStart >= srcEnd || load<u16>(srcStart) != COLON) break;
+    srcStart += 2;
+
+    const valueEnd = scanValueEnd(srcStart, srcEnd);
+    if (!valueEnd || valueEnd <= srcStart) break;
+
+    // @ts-ignore: type
+    changetype<nonnull<T>>(out).set(deserializeMapKey<indexof<T>>(keyStart, keyEnd), JSON.__deserialize<valueof<T>>(srcStart, valueEnd));
+    srcStart = valueEnd;
+
+    if (srcStart >= srcEnd) break;
+    const code = load<u16>(srcStart);
+    if (code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACE_RIGHT) return srcStart + 2;
+    break;
+  }
+
+  throw new Error("Failed to parse JSON!");
+}
+
+@inline export function deserializeMapField<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  let out = load<T>(dstObj, dstOffset);
+  if (!changetype<usize>(out)) {
+    out = changetype<T>(instantiate<T>());
+    store<T>(dstObj, out, dstOffset);
+  }
+  return deserializeMapInto<T>(srcStart, srcEnd, out);
+}

package/assembly/deserialize/simple/object.ts

@@ -7,7 +7,7 @@ import { deserializeString_SWAR } from "../swar/string";
 import { deserializeArbitrary } from "./arbitrary";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
-import { deserializeFloat } from "../float";
+import { deserializeFloat } from "./float";
 import { deserializeString } from "./string";
 
 export function deserializeObject(srcStart: usize, srcEnd: usize, dst: usize): JSON.Obj {