json-as 1.3.2 → 1.3.4

package/assembly/serialize/simple/set.ts

@@ -1,6 +1,34 @@
 import { bs } from "../../../lib/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
+import { serializeBoolUnsafe } from "./bool";
+import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
+import { serializeIntegerUnsafe } from "./integer";
+import { serializeString } from "../index/string";
+
+
+@inline
+function maxIntegerBytes<T extends number>(): u32 {
+  if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
+  if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
+  if (sizeof<T>() == 4) return isSigned<T>() ? 22 : 20;
+  return isSigned<T>() ? 42 : 40;
+}
+
+
+@inline
+function reservePrimitiveSet<T>(len: i32): void {
+  if (len <= 0) return;
+  if (isBoolean<T>()) {
+    bs.proposeSize(4 + <u32>len * 12);
+  } else if (isInteger<T>()) {
+    bs.proposeSize(4 + <u32>len * (maxIntegerBytes<T>() + 2));
+  } else if (isFloat<T>()) {
+    bs.proposeSize(4 + <u32>len * (sizeof<T>() == 4 ? 34 : 66));
+  } else {
+    bs.proposeSize(4 + <u32>(len - 1) * 2);
+  }
+}
 
 export function serializeSet<T extends Set<any>>(src: T): void {
   const srcSize = src.size;
@@ -10,7 +38,11 @@ export function serializeSet<T extends Set<any>>(src: T): void {
     bs.offset += 4;
     return;
   }
-  bs.proposeSize(4 + <u32>(srcSize - 1) * 2);
+  if (isBoolean<indexof<T>>() || isInteger<indexof<T>>() || isFloat<indexof<T>>() || isString<indexof<T>>()) {
+    reservePrimitiveSet<indexof<T>>(srcSize);
+  } else {
+    bs.proposeSize(4 + <u32>(srcSize - 1) * 2);
+  }
 
   const values = src.values();
   store<u16>(bs.offset, BRACKET_LEFT);
@@ -19,15 +51,37 @@ export function serializeSet<T extends Set<any>>(src: T): void {
   const end = srcSize - 1;
   for (let i = 0; i < end; i++) {
     const block = unchecked(values[i]);
-    // @ts-ignore: type
-    JSON.__serialize<indexof<T>>(block);
+    if (isString<indexof<T>>()) {
+      serializeString(block as string);
+    } else if (isBoolean<indexof<T>>()) {
+      serializeBoolUnsafe(<bool>block);
+    } else if (isInteger<indexof<T>>()) {
+      serializeIntegerUnsafe<indexof<T>>(block);
+    } else if (isFloat<indexof<T>>()) {
+      if (sizeof<indexof<T>>() == 4) serializeFloat32Unsafe(<f32>block);
+      else serializeFloat64Unsafe(<f64>block);
+    } else {
+      // @ts-ignore: type
+      JSON.__serialize<indexof<T>>(block);
+    }
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   const lastBlock = unchecked(values[end]);
-  // @ts-ignore: type
-  JSON.__serialize<indexof<T>>(lastBlock);
+  if (isString<indexof<T>>()) {
+    serializeString(lastBlock as string);
+  } else if (isBoolean<indexof<T>>()) {
+    serializeBoolUnsafe(<bool>lastBlock);
+  } else if (isInteger<indexof<T>>()) {
+    serializeIntegerUnsafe<indexof<T>>(lastBlock);
+  } else if (isFloat<indexof<T>>()) {
+    if (sizeof<indexof<T>>() == 4) serializeFloat32Unsafe(<f32>lastBlock);
+    else serializeFloat64Unsafe(<f64>lastBlock);
+  } else {
+    // @ts-ignore: type
+    JSON.__serialize<indexof<T>>(lastBlock);
+  }
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/staticarray.ts

@@ -1,6 +1,34 @@
 import { bs } from "../../../lib/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
+import { serializeBoolUnsafe } from "./bool";
+import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
+import { serializeIntegerUnsafe } from "./integer";
+import { serializeString } from "../index/string";
+
+
+@inline
+function maxIntegerBytes<T extends number>(): u32 {
+  if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
+  if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
+  if (sizeof<T>() == 4) return isSigned<T>() ? 22 : 20;
+  return isSigned<T>() ? 42 : 40;
+}
+
+
+@inline
+function reservePrimitiveStaticArray<T>(len: i32): void {
+  if (len <= 0) return;
+  if (isBoolean<T>()) {
+    bs.proposeSize(4 + <u32>len * 12);
+  } else if (isInteger<T>()) {
+    bs.proposeSize(4 + <u32>len * (maxIntegerBytes<T>() + 2));
+  } else if (isFloat<T>()) {
+    bs.proposeSize(4 + <u32>len * (sizeof<T>() == 4 ? 34 : 66));
+  } else {
+    bs.proposeSize(4 + <u32>(len - 1) * 2);
+  }
+}
 
 export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
   const len = src.length;
@@ -12,20 +40,46 @@ export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
     bs.offset += 4;
     return;
   }
-  bs.proposeSize(4 + <u32>(len - 1) * 2);
+  if (isBoolean<valueof<T>>() || isInteger<valueof<T>>() || isFloat<valueof<T>>() || isString<valueof<T>>()) {
+    reservePrimitiveStaticArray<valueof<T>>(len);
+  } else {
+    bs.proposeSize(4 + <u32>(len - 1) * 2);
+  }
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
 
   while (i < end) {
     const block = unchecked(src[i++]);
-    JSON.__serialize<valueof<T>>(block);
+    if (isString<valueof<T>>()) {
+      serializeString(block as string);
+    } else if (isBoolean<valueof<T>>()) {
+      serializeBoolUnsafe(<bool>block);
+    } else if (isInteger<valueof<T>>()) {
+      serializeIntegerUnsafe<valueof<T>>(block);
+    } else if (isFloat<valueof<T>>()) {
+      if (sizeof<valueof<T>>() == 4) serializeFloat32Unsafe(<f32>block);
+      else serializeFloat64Unsafe(<f64>block);
+    } else {
+      JSON.__serialize<valueof<T>>(block);
+    }
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   const lastBlock = unchecked(src[end]);
-  JSON.__serialize<valueof<T>>(lastBlock);
+  if (isString<valueof<T>>()) {
+    serializeString(lastBlock as string);
+  } else if (isBoolean<valueof<T>>()) {
+    serializeBoolUnsafe(<bool>lastBlock);
+  } else if (isInteger<valueof<T>>()) {
+    serializeIntegerUnsafe<valueof<T>>(lastBlock);
+  } else if (isFloat<valueof<T>>()) {
+    if (sizeof<valueof<T>>() == 4) serializeFloat32Unsafe(<f32>lastBlock);
+    else serializeFloat64Unsafe(<f64>lastBlock);
+  } else {
+    JSON.__serialize<valueof<T>>(lastBlock);
+  }
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/typedarray.ts

@@ -1,16 +1,36 @@
 import { bs } from "../../../lib/as-bs";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
-import { serializeFloat32, serializeFloat64 } from "./float";
-import { serializeInteger } from "./integer";
+import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
+import { serializeIntegerUnsafe } from "./integer";
+
+
+@inline
+function maxIntegerBytes<T extends number>(): u32 {
+  if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
+  if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
+  if (sizeof<T>() == 4) return isSigned<T>() ? 22 : 20;
+  return isSigned<T>() ? 42 : 40;
+}
+
+
+@inline
+function reserveTypedArray<T extends ArrayLike<number>>(len: i32): void {
+  if (len <= 0) return;
+  if (isFloat<valueof<T>>()) {
+    bs.proposeSize(4 + <u32>len * (sizeof<valueof<T>>() == 4 ? 34 : 66));
+  } else {
+    bs.proposeSize(4 + <u32>len * (maxIntegerBytes<valueof<T>>() + 2));
+  }
+}
 
 
 @inline
 function serializeTypedArrayElement<T extends ArrayLike<number>>(src: T, index: i32): void {
   if (isFloat<valueof<T>>()) {
-    if (sizeof<valueof<T>>() == 4) serializeFloat32(<f32>unchecked(src[index]));
-    else serializeFloat64(<f64>unchecked(src[index]));
+    if (sizeof<valueof<T>>() == 4) serializeFloat32Unsafe(<f32>unchecked(src[index]));
+    else serializeFloat64Unsafe(<f64>unchecked(src[index]));
   } else {
-    serializeInteger<valueof<T>>(unchecked(src[index]));
+    serializeIntegerUnsafe<valueof<T>>(unchecked(src[index]));
   }
 }
 
@@ -23,7 +43,7 @@ export function serializeTypedArray<T extends ArrayLike<number>>(src: T): void {
     bs.offset += 4;
     return;
   }
-  bs.proposeSize(4 + <u32>(len - 1) * 2);
+  reserveTypedArray<T>(len);
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
@@ -48,18 +68,18 @@ export function serializeArrayBufferUnsafe(srcStart: usize, byteLength: i32): vo
     bs.offset += 4;
     return;
   }
-  bs.proposeSize(4 + <u32>(end) * 2);
+  bs.proposeSize(4 + <u32>byteLength * 8);
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
 
   for (let i = 0; i < end; i++) {
-    serializeInteger<u8>(load<u8>(srcStart + <usize>i));
+    serializeIntegerUnsafe<u8>(load<u8>(srcStart + <usize>i));
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
-  serializeInteger<u8>(load<u8>(srcStart + <usize>end));
+  serializeIntegerUnsafe<u8>(load<u8>(srcStart + <usize>end));
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/swar/string.ts

@@ -1,5 +1,5 @@
-import { bs, sc } from "../../../lib/as-bs";
-import { BACK_SLASH } from "../../custom/chars";
+import { bs } from "../../../lib/as-bs";
+import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { u16_to_hex4_swar } from "../../util/swar";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
@@ -11,18 +11,166 @@ import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
 export function serializeString_SWAR(src: string): void {
   let srcStart = changetype<usize>(src);
+  const srcInitial = srcStart;
+  const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize;
+  const srcEnd = srcStart + srcSize;
+  do {
+    const srcEnd8Fast = srcEnd - 8;
+    bs.proposeSize(srcSize + 4);
+
+    const dstStart = bs.offset;
+    let dst = dstStart + 2;
+
+    while (srcStart < srcEnd8Fast) {
+      const block = load<u64>(srcStart);
+      if ((block & 0xff00_ff00_ff00_ff00) != 0) break;
+      const lo = block & 0x00ff_00ff_00ff_00ff;
+      const asciiMask = ((lo - 0x0020_0020_0020_0020) | ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) | ((lo ^ 0x005c_005c_005c_005c) - 0x0001_0001_0001_0001)) & (0x0080_0080_0080_0080 & ~lo);
+      if (asciiMask != 0) break;
+      store<u64>(dst, block);
+      srcStart += 8;
+      dst += 8;
+    }
+    if (srcStart < srcEnd8Fast) break;
+
+    while (srcStart <= srcEnd - 2) {
+      const code = load<u16>(srcStart);
+      if (code > 0x7f || code == BACK_SLASH || code == QUOTE || code < 32) break;
+      store<u16>(dst, code);
+      srcStart += 2;
+      dst += 2;
+    }
+    if (srcStart <= srcEnd - 2) break;
+
+    store<u16>(dstStart, QUOTE);
+    store<u16>(dst, QUOTE);
+    bs.offset = dst + 2;
+    return;
+  } while (false);
+
+  srcStart = srcInitial;
+  const srcEnd8 = srcEnd - 8;
+
+  bs.proposeSize(srcSize + 4);
+  store<u16>(bs.offset, 34); // "
+  bs.offset += 2;
+
+  while (srcStart < srcEnd8) {
+    const block = load<u64>(srcStart);
+    let mask = detect_escapable_u64_swar_safe(block);
+    store<u64>(bs.offset, block);
+
+    if (mask === 0) {
+      srcStart += 8;
+      bs.offset += 8;
+      continue;
+    }
+
+    do {
+      const laneIdx = usize(ctz(mask) >> 3);
+      const srcIdx = srcStart + laneIdx;
+      // Even (0 2 4 6) -> Confirmed ASCII Escape
+      // Odd (1 3 5 7) -> Possibly a Unicode code unit or surrogate
+      if ((laneIdx & 1) === 0) {
+        mask &= mask - 1;
+        const code = load<u16>(srcIdx);
+        const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
+
+        if ((escaped & 0xffff) != BACK_SLASH) {
+          bs.growSize(10);
+          const dstIdx = bs.offset + laneIdx;
+          store<u64>(dstIdx, U00_MARKER);
+          store<u32>(dstIdx, escaped, 8);
+          store<u64>(dstIdx, load<u64>(srcIdx, 2), 12);
+          bs.offset += 10;
+        } else {
+          bs.growSize(2);
+          const dstIdx = bs.offset + laneIdx;
+          store<u32>(dstIdx, escaped);
+          store<u64>(dstIdx, load<u64>(srcIdx, 2), 4);
+          bs.offset += 2;
+        }
+        continue;
+      }
+      mask &= mask - 1;
+
+      const code = load<u16>(srcIdx - 1);
+      if (code < 0xd800 || code > 0xdfff) continue;
+
+      if (code <= 0xdbff && srcIdx + 2 < srcEnd) {
+        const next = load<u16>(srcIdx, 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          // paired surrogate
+          // mask &= ~(0xFF << ((laneIdx+2) << 3));
+          mask &= mask - 1;
+          continue;
+        }
+      }
+
+      bs.growSize(10);
+
+      // unpaired high/low surrogate
+      const dstIdx = bs.offset + laneIdx - 1;
+      store<u32>(dstIdx, U_MARKER); // \u
+      store<u64>(dstIdx, u16_to_hex4_swar(code), 4);
+      store<u64>(dstIdx, load<u64>(srcIdx, 1), 12);
+      bs.offset += 10;
+    } while (mask !== 0);
+
+    srcStart += 8;
+    bs.offset += 8;
+  }
+
+  while (srcStart <= srcEnd - 2) {
+    const code = load<u16>(srcStart);
+
+    if (code == BACK_SLASH || code == QUOTE || code < 32) {
+      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
+      if ((escaped & 0xffff) != BACK_SLASH) {
+        bs.growSize(10);
+        store<u64>(bs.offset, U00_MARKER);
+        store<u32>(bs.offset, escaped, 8);
+        bs.offset += 12;
+      } else {
+        bs.growSize(2);
+        store<u32>(bs.offset, escaped);
+        bs.offset += 4;
+      }
+      srcStart += 2;
+      continue;
+    }
+
+    if (code < 0xd800 || code > 0xdfff) {
+      store<u16>(bs.offset, code);
+      bs.offset += 2;
+      srcStart += 2;
+      continue;
+    }
 
-  if (isDefined(JSON_CACHE)) {
-    const e = unchecked(sc.entries[i32((srcStart >> 4) & sc.CACHE_MASK)]);
-    if (e.key == srcStart) {
-      bs.offset += e.len;
-      bs.stackSize += e.len;
-      bs.cacheOutput = e.ptr;
-      bs.cacheOutputLen = e.len;
-      return;
+    if (code <= 0xdbff && srcStart + 2 <= srcEnd - 2) {
+      const next = load<u16>(srcStart, 2);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        // valid surrogate pair
+        store<u16>(bs.offset, code);
+        store<u16>(bs.offset + 2, next);
+        bs.offset += 4;
+        srcStart += 4;
+        continue;
+      }
     }
+
+    // unpaired high/low surrogate
+    write_u_escape(code);
+    srcStart += 2;
+    continue;
   }
 
+  store<u16>(bs.offset, 34); // "
+  bs.offset += 2;
+}
+
+export function serializeString_SWAR_ExperimentalTableEscapes(src: string): void {
+  let srcStart = changetype<usize>(src);
   const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize;
   const srcEnd = srcStart + srcSize;
   const srcEnd8 = srcEnd - 8;
@@ -32,10 +180,9 @@ export function serializeString_SWAR(src: string): void {
   bs.offset += 2;
 
   while (srcStart < srcEnd8) {
-    let block = load<u64>(srcStart);
-    store<u64>(bs.offset, block);
-
+    const block = load<u64>(srcStart);
     let mask = detect_escapable_u64_swar_safe(block);
+    store<u64>(bs.offset, block);
 
     if (mask === 0) {
       srcStart += 8;
@@ -49,7 +196,7 @@ export function serializeString_SWAR(src: string): void {
       // Even (0 2 4 6) -> Confirmed ASCII Escape
       // Odd (1 3 5 7) -> Possibly a Unicode code unit or surrogate
       if ((laneIdx & 1) === 0) {
-        mask &= ~(0xffff << (laneIdx << 3));
+        mask &= mask - 1;
         const code = load<u16>(srcIdx);
         const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
 
@@ -69,7 +216,7 @@ export function serializeString_SWAR(src: string): void {
         }
         continue;
       }
-      mask &= ~(0xffff << (laneIdx << 3));
+      mask &= mask - 1;
 
       const code = load<u16>(srcIdx - 1);
       if (code < 0xd800 || code > 0xdfff) continue;
@@ -101,7 +248,7 @@ export function serializeString_SWAR(src: string): void {
   while (srcStart <= srcEnd - 2) {
     const code = load<u16>(srcStart);
 
-    if (code == 92 || code == 34 || code < 32) {
+    if (code == BACK_SLASH || code == QUOTE || code < 32) {
       const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
       if ((escaped & 0xffff) != BACK_SLASH) {
         bs.growSize(10);
@@ -144,8 +291,6 @@ export function serializeString_SWAR(src: string): void {
 
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
-
-  if (isDefined(JSON_CACHE)) sc.insertCached(changetype<usize>(src), srcStart, srcSize);
 }
 
 // @ts-expect-error: @inline is a valid decorator
@@ -158,8 +303,10 @@ export function serializeString_SWAR(src: string): void {
 
 // @ts-expect-error: @inline is a valid decorator
 @inline export function detect_escapable_u64_swar_safe(block: u64): u64 {
+  const hi = block & 0xff00_ff00_ff00_ff00;
   const lo = block & 0x00ff_00ff_00ff_00ff;
   const ascii_mask = ((lo - 0x0020_0020_0020_0020) | ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) | ((lo ^ 0x005c_005c_005c_005c) - 0x0001_0001_0001_0001)) & (0x0080_0080_0080_0080 & ~lo);
+  if (hi == 0) return ascii_mask;
   const hi_mask = ((block - 0x0100_0100_0100_0100) & ~block & 0x8000_8000_8000_8000) ^ 0x8000_8000_8000_8000;
   return (ascii_mask & (~hi_mask >> 8)) | hi_mask;
 }

package/assembly/tsconfig.json

@@ -19,6 +19,6 @@
     "noUnusedParameters": false,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": false,
-  },
+    "noUncheckedIndexedAccess": false
+  }
 }