json-as 1.2.5 → 1.3.0

package/assembly/serialize/index/arbitrary.ts

@@ -0,0 +1,70 @@
+import { JSON } from "../..";
+import { bs } from "../../../lib/as-bs";
+import { serializeArray } from "./array";
+import { serializeBool } from "./bool";
+import { serializeFloat } from "./float";
+import { serializeInteger } from "./integer";
+import { serializeMap } from "./map";
+import { serializeObject } from "./object";
+import { serializeString } from "./string";
+
+export function serializeArbitrary(src: JSON.Value): void {
+  switch (src.type) {
+    case JSON.Types.Null:
+      bs.proposeSize(8);
+      store<u64>(bs.offset, 30399761348886638);
+      bs.offset += 8;
+      break;
+    case JSON.Types.U8:
+      serializeInteger<u8>(src.get<u8>());
+      break;
+    case JSON.Types.U16:
+      serializeInteger<u16>(src.get<u16>());
+      break;
+    case JSON.Types.U32:
+      serializeInteger<u32>(src.get<u32>());
+      break;
+    case JSON.Types.U64:
+      serializeInteger<u64>(src.get<u64>());
+      break;
+    case JSON.Types.I8:
+      serializeInteger<i8>(src.get<i8>());
+      break;
+    case JSON.Types.I16:
+      serializeInteger<i16>(src.get<i16>());
+      break;
+    case JSON.Types.I32:
+      serializeInteger<i32>(src.get<i32>());
+      break;
+    case JSON.Types.I64:
+      serializeInteger<i64>(src.get<i64>());
+      break;
+    case JSON.Types.F32:
+      serializeFloat<f32>(src.get<f32>());
+      break;
+    case JSON.Types.F64:
+      serializeFloat<f64>(src.get<f64>());
+      break;
+    case JSON.Types.String:
+      serializeString(src.get<string>());
+      break;
+    case JSON.Types.Bool:
+      serializeBool(src.get<bool>());
+      break;
+    case JSON.Types.Array:
+      serializeArray(src.get<JSON.Value[]>());
+      break;
+    case JSON.Types.Object:
+      serializeObject(src.get<JSON.Obj>());
+      break;
+    case JSON.Types.Map:
+      serializeMap(src.get<Map<string, JSON.Value>>());
+      break;
+    default: {
+      const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
+      const ptr = src.get<usize>();
+      call_indirect<void>(fn, 0, ptr);
+      break;
+    }
+  }
+}

package/assembly/serialize/index/array.ts

@@ -0,0 +1 @@
+export { serializeArray } from "../simple/array";

package/assembly/serialize/index/bool.ts

@@ -0,0 +1 @@
+export { serializeBool } from "../simple/bool";

package/assembly/serialize/index/date.ts

@@ -0,0 +1 @@
+export { serializeDate } from "../simple/date";

package/assembly/serialize/index/float.ts

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

package/assembly/serialize/index/integer.ts

@@ -0,0 +1 @@
+export { serializeInteger } from "../simple/integer";

package/assembly/serialize/index/map.ts

@@ -0,0 +1 @@
+export { serializeMap } from "../simple/map";

package/assembly/serialize/index/object.ts

@@ -0,0 +1,46 @@
+import { bs } from "../../../lib/as-bs";
+import { JSON } from "../..";
+import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
+import { serializeArbitrary } from "./arbitrary";
+import { serializeString } from "./string";
+
+export function serializeObject(src: JSON.Obj): void {
+  const srcSize = src.size;
+  const srcEnd = srcSize - 1;
+
+  if (srcSize == 0) {
+    bs.proposeSize(4);
+    store<u32>(bs.offset, 8192123);
+    bs.offset += 4;
+    return;
+  }
+
+  const keys = src.keys();
+  const values = src.values();
+
+  bs.growSize(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/index/raw.ts

@@ -0,0 +1 @@
+export { serializeRaw } from "../simple/raw";

package/assembly/serialize/index/set.ts

@@ -0,0 +1 @@
+export { serializeSet } from "../simple/set";

package/assembly/serialize/index/staticarray.ts

@@ -0,0 +1 @@
+export { serializeStaticArray } from "../simple/staticarray";

package/assembly/serialize/index/string.ts

@@ -0,0 +1,15 @@
+import { JSONMode } from "../..";
+import { serializeString as serializeString_NAIVE } from "../simple/string";
+import { serializeString_SIMD } from "../simd/string";
+import { serializeString_SWAR } from "../swar/string";
+
+
+@inline export function serializeString(src: string): void {
+  if (JSON_MODE == JSONMode.SIMD) {
+    serializeString_SIMD(src);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    serializeString_NAIVE(src);
+  } else {
+    serializeString_SWAR(src);
+  }
+}

package/assembly/serialize/index/struct.ts

@@ -0,0 +1 @@
+export { serializeStruct } from "../simple/struct";

package/assembly/serialize/index/typedarray.ts

@@ -0,0 +1 @@
+export { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typedarray";

package/assembly/serialize/index.ts

@@ -0,0 +1,13 @@
+export * from "./index/arbitrary";
+export * from "./index/array";
+export * from "./index/bool";
+export * from "./index/date";
+export * from "./index/float";
+export * from "./index/integer";
+export * from "./index/map";
+export * from "./index/object";
+export * from "./index/raw";
+export * from "./index/set";
+export * from "./index/staticarray";
+export * from "./index/string";
+export * from "./index/struct";

package/assembly/serialize/simd/string.ts

@@ -9,11 +9,11 @@ import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const SPLAT_0022 = i16x8.splat(0x0022); // "
 // @ts-expect-error: @lazy is a valid decorator
-@lazy const SPLAT_005C = i16x8.splat(0x005C); // \
+@lazy const SPLAT_005C = i16x8.splat(0x005c); // \
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const SPLAT_0020 = i16x8.splat(0x0020); // space and control check
 // @ts-expect-error: @lazy is a valid decorator
-@lazy const SPLAT_FFD8 = i16x8.splat(i16(0xD7FE));
+@lazy const SPLAT_FFD8 = i16x8.splat(i16(0xd7fe));
 
 /**
  * Serializes strings into their JSON counterparts using SIMD operations
@@ -32,7 +32,7 @@ export function serializeString_SIMD(src: string): void {
     }
   }
 
-  const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize
+  const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize;
   const srcEnd = srcStart + srcSize;
   const srcEnd16 = srcEnd - 16;
 
@@ -58,71 +58,71 @@ export function serializeString_SIMD(src: string): void {
     // console.log("sieve  : " + mask_to_string_v128(sieve));
 
     if (!v128.any_true(sieve)) {
-        bs.offset += 16;
-        srcStart += 16;
-        continue;
+      bs.offset += 16;
+      srcStart += 16;
+      continue;
     }
 
     let mask = i8x16.bitmask(sieve);
 
-      do {
-        const laneIdx = ctz(mask);
-        const srcIdx = srcStart + laneIdx;
-
-        mask &= mask - 1;
-        // Even (0 2 4 6 8 10 12 14) -> Confirmed ASCII Escape
-        // Odd (1 3 5 7 9 11 13 15) -> Possibly a Unicode code unit or surrogate
-
-        if ((laneIdx & 1) === 0) {
-          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);
-            // memory.copy(dstIdx + 12, srcIdx + 2, 14 - laneIdx);
-            store<v128>(dstIdx, load<v128>(srcIdx, 2), 12); // unsafe. can overflow here
-            bs.offset += 10;
-          } else {
-            bs.growSize(2);
-            const dstIdx = bs.offset + laneIdx;
-            store<u32>(dstIdx, escaped);
-            store<v128>(dstIdx, load<v128>(srcIdx, 2), 4);
-            // memory.copy(dstIdx + 4, srcIdx + 2, 14 - laneIdx);
-            bs.offset += 2;
-          }
-          continue;
+    do {
+      const laneIdx = ctz(mask);
+      const srcIdx = srcStart + laneIdx;
+
+      mask &= mask - 1;
+      // Even (0 2 4 6 8 10 12 14) -> Confirmed ASCII Escape
+      // Odd (1 3 5 7 9 11 13 15) -> Possibly a Unicode code unit or surrogate
+
+      if ((laneIdx & 1) === 0) {
+        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);
+          // memory.copy(dstIdx + 12, srcIdx + 2, 14 - laneIdx);
+          store<v128>(dstIdx, load<v128>(srcIdx, 2), 12); // unsafe. can overflow here
+          bs.offset += 10;
+        } else {
+          bs.growSize(2);
+          const dstIdx = bs.offset + laneIdx;
+          store<u32>(dstIdx, escaped);
+          store<v128>(dstIdx, load<v128>(srcIdx, 2), 4);
+          // memory.copy(dstIdx + 4, srcIdx + 2, 14 - laneIdx);
+          bs.offset += 2;
         }
+        continue;
+      }
 
-        const code = load<u16>(srcIdx - 1);
-        // console.log("\nb->" + mask_to_string_v128(block));
-        // console.log("h->" + mask_to_string_v128(sieve));
-        // console.log("z->" + mask_to_string_v128(i8x16.ge_u(block,SPLAT_FFD8)));
-        // console.log("m->" + mask.toString(2));
-        // console.log("l->" + laneIdx.toString());
-        // console.log("c->" + code.toString(16));
-        if (code < 0xD800 || code > 0xDFFF) continue;
-
-        if (code <= 0xDBFF && srcIdx + 1 <= srcEnd - 2) {
-          const next = load<u16>(srcIdx, 1);
-          if (next >= 0xDC00 && next <= 0xDFFF) {
-            // paired surrogate
-            mask &= mask - 1;
-            continue;
-          }
+      const code = load<u16>(srcIdx - 1);
+      // console.log("\nb->" + mask_to_string_v128(block));
+      // console.log("h->" + mask_to_string_v128(sieve));
+      // console.log("z->" + mask_to_string_v128(i8x16.ge_u(block,SPLAT_FFD8)));
+      // console.log("m->" + mask.toString(2));
+      // console.log("l->" + laneIdx.toString());
+      // console.log("c->" + code.toString(16));
+      if (code < 0xd800 || code > 0xdfff) continue;
+
+      if (code <= 0xdbff && srcIdx + 1 <= srcEnd - 2) {
+        const next = load<u16>(srcIdx, 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          // paired surrogate
+          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, load<u64>(changetype<usize>(code.toString(16))), 4);
-        // memory.copy(dstIdx + 12, srcIdx + 1, 15 - laneIdx);
-        store<v128>(dstIdx, load<v128>(srcIdx, 1), 12);
-        bs.offset += 10;
-      } while (mask !== 0);
+      bs.growSize(10);
+      // unpaired high/low surrogate
+      const dstIdx = bs.offset + laneIdx - 1;
+      store<u32>(dstIdx, U_MARKER); // \u
+      store<u64>(dstIdx, load<u64>(changetype<usize>(code.toString(16))), 4);
+      // memory.copy(dstIdx + 12, srcIdx + 1, 15 - laneIdx);
+      store<v128>(dstIdx, load<v128>(srcIdx, 1), 12);
+      bs.offset += 10;
+    } while (mask !== 0);
 
     srcStart += 16;
     bs.offset += 16;
@@ -146,16 +146,16 @@ export function serializeString_SIMD(src: string): void {
       continue;
     }
 
-    if (code < 0xD800 || code > 0xDFFF) {
+    if (code < 0xd800 || code > 0xdfff) {
       store<u16>(bs.offset, code);
       bs.offset += 2;
       srcStart += 2;
       continue;
     }
 
-    if (code <= 0xDBFF && srcStart + 2 <= srcEnd - 2) {
+    if (code <= 0xdbff && srcStart + 2 <= srcEnd - 2) {
       const next = load<u16>(srcStart, 2);
-      if (next >= 0xDC00 && next <= 0xDFFF) {
+      if (next >= 0xdc00 && next <= 0xdfff) {
         // valid surrogate pair
         store<u16>(bs.offset, code);
         store<u16>(bs.offset + 2, next);
@@ -182,14 +182,14 @@ export function serializeString_SIMD(src: string): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
   // write hex digits (lowercase, matches tests)
-  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xF));
-  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xF));
-  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xF));
-  store<u16>(bs.offset + 10, hexNibble(code & 0xF));
+  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xf));
+  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xf));
+  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xf));
+  store<u16>(bs.offset + 10, hexNibble(code & 0xf));
   bs.offset += 12;
 }
 
 // @ts-expect-error: @inline is a valid decorator
 @inline function hexNibble(n: u16): u16 {
-  return n < 10 ? (48 + n) : (87 + n);
+  return n < 10 ? 48 + n : 87 + n;
 }

package/assembly/serialize/simple/string.ts

@@ -49,12 +49,12 @@ import { serializeStruct } from "./struct";
       continue;
     }
     // srcPtr += 2;
-    if (code < 0xD800 || code > 0xDFFF) continue;
+    if (code < 0xd800 || code > 0xdfff) continue;
 
-    if (code <= 0xDBFF) {
+    if (code <= 0xdbff) {
       if (srcPtr <= srcEnd - 2) {
         const next = load<u16>(srcPtr);
-        if (next >= 0xDC00 && next <= 0xDFFF) {
+        if (next >= 0xdc00 && next <= 0xdfff) {
           srcPtr += 2;
           continue;
         }
@@ -72,7 +72,6 @@ import { serializeStruct } from "./struct";
     bs.offset += 12;
     lastPtr = srcPtr;
     continue;
-
   }
   const remBytes = srcEnd - lastPtr;
   memory.copy(bs.offset, lastPtr, remBytes);
@@ -86,14 +85,14 @@ import { serializeStruct } from "./struct";
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
   // write hex digits (lowercase, matches tests)
-  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xF));
-  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xF));
-  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xF));
-  store<u16>(bs.offset + 10, hexNibble(code & 0xF));
+  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xf));
+  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xf));
+  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xf));
+  store<u16>(bs.offset + 10, hexNibble(code & 0xf));
   bs.offset += 12;
 }
 
 // @ts-ignore: inline
 @inline function hexNibble(n: u16): u16 {
-  return n < 10 ? (48 + n) : (87 + n);
-}
+  return n < 10 ? 48 + n : 87 + n;
+}

package/assembly/serialize/simple/typedarray.ts

@@ -0,0 +1,63 @@
+import { bs } from "../../../lib/as-bs";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
+import { serializeFloat } 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]));
+  } 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;
+  if (end == -1) {
+    store<u32>(bs.offset, 6094939);
+    bs.offset += 4;
+    return;
+  }
+
+  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;
+  }
+
+  serializeTypedArrayElement(src, end);
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}
+
+export function serializeArrayBufferUnsafe(srcStart: usize, byteLength: i32): void {
+  const end = byteLength - 1;
+
+  bs.proposeSize(4);
+  if (end == -1) {
+    store<u32>(bs.offset, 6094939);
+    bs.offset += 4;
+    return;
+  }
+
+  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;
+  }
+
+  serializeInteger<u8>(load<u8>(srcStart + <usize>end));
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/swar/string.ts

@@ -23,7 +23,7 @@ export function serializeString_SWAR(src: string): void {
     }
   }
 
-  const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize
+  const srcSize = changetype<OBJECT>(srcStart - TOTAL_OVERHEAD).rtSize;
   const srcEnd = srcStart + srcSize;
   const srcEnd8 = srcEnd - 8;
 
@@ -35,7 +35,7 @@ export function serializeString_SWAR(src: string): void {
     let block = load<u64>(srcStart);
     store<u64>(bs.offset, block);
 
-    let mask = detect_escapable_u64_swar_unsafe(block);
+    let mask = detect_escapable_u64_swar_safe(block);
 
     if (mask === 0) {
       srcStart += 8;
@@ -48,8 +48,8 @@ export function serializeString_SWAR(src: string): void {
       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 & (0xFF << (laneIdx + 1 << 3))) === 0) {
-      mask &= ~(0xFFFF << (laneIdx << 3));
+      if ((laneIdx & 1) === 0) {
+        mask &= ~(0xffff << (laneIdx << 3));
         const code = load<u16>(srcIdx);
         const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
 
@@ -69,14 +69,14 @@ export function serializeString_SWAR(src: string): void {
         }
         continue;
       }
-      mask &= ~(0xFFFF << (laneIdx << 3));
+      mask &= ~(0xffff << (laneIdx << 3));
 
       const code = load<u16>(srcIdx - 1);
-      if (code < 0xD800 || code > 0xDFFF) continue;
+      if (code < 0xd800 || code > 0xdfff) continue;
 
-      if (code <= 0xDBFF && srcIdx + 2 < srcEnd) {
+      if (code <= 0xdbff && srcIdx + 2 < srcEnd) {
         const next = load<u16>(srcIdx, 1);
-        if (next >= 0xDC00 && next <= 0xDFFF) {
+        if (next >= 0xdc00 && next <= 0xdfff) {
           // paired surrogate
           // mask &= ~(0xFF << ((laneIdx+2) << 3));
           mask &= mask - 1;
@@ -117,16 +117,16 @@ export function serializeString_SWAR(src: string): void {
       continue;
     }
 
-    if (code < 0xD800 || code > 0xDFFF) {
+    if (code < 0xd800 || code > 0xdfff) {
       store<u16>(bs.offset, code);
       bs.offset += 2;
       srcStart += 2;
       continue;
     }
 
-    if (code <= 0xDBFF && srcStart + 2 <= srcEnd - 2) {
+    if (code <= 0xdbff && srcStart + 2 <= srcEnd - 2) {
       const next = load<u16>(srcStart, 2);
-      if (next >= 0xDC00 && next <= 0xDFFF) {
+      if (next >= 0xdc00 && next <= 0xdfff) {
         // valid surrogate pair
         store<u16>(bs.offset, code);
         store<u16>(bs.offset + 2, next);
@@ -153,40 +153,34 @@ export function serializeString_SWAR(src: string): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
   // write hex digits (lowercase, matches tests)
-  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xF));
-  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xF));
-  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xF));
-  store<u16>(bs.offset + 10, hexNibble(code & 0xF));
+  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xf));
+  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xf));
+  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xf));
+  store<u16>(bs.offset + 10, hexNibble(code & 0xf));
   bs.offset += 12;
 }
 
 // @ts-expect-error: @inline is a valid decorator
 @inline function hexNibble(n: u16): u16 {
-  return n < 10 ? (48 + n) : (87 + n);
+  return n < 10 ? 48 + n : 87 + n;
 }
 
 // @ts-expect-error: @inline is a valid decorator
-@inline export function detect_escapable_u64_swar(block: u64): u64 {
-  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)
-  );
+@inline export function detect_escapable_u64_swar_safe(block: u64): u64 {
+  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);
   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;
 }
 
 // @ts-expect-error: @inline is a valid decorator
 @inline export function detect_escapable_u64_swar_unsafe(block: u64): u64 {
-  const lo = block & 0x00FF_00FF_00FF_00FF;
-  const ascii_mask = (
-    ((lo - 0x0020_0020_0020_0020) |                               // lt 0x20
-      ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) |    // eq 0x22
-      ((lo ^ 0x005C_005C_005C_005C) - 0x0001_0001_0001_0001))     // eq 0x5C
-    & (0x0080_0080_0080_0080 & ~lo)                               // replace each lane with 0x80
-  );
-  const hi = block & 0xFF00_FF00_FF00_FF00;                       // add possible non-ascii code units
+  const lo = block & 0x00ff_00ff_00ff_00ff;
+  const ascii_mask =
+    ((lo - 0x0020_0020_0020_0020) | // lt 0x20
+      ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) | // eq 0x22
+      ((lo ^ 0x005c_005c_005c_005c) - 0x0001_0001_0001_0001)) & // eq 0x5C
+    (0x0080_0080_0080_0080 & ~lo); // replace each lane with 0x80
+  const hi = block & 0xff00_ff00_ff00_ff00; // add possible non-ascii code units
   return ascii_mask | hi;
 }

package/assembly/test.ts

@@ -1,24 +1,24 @@
-import { JSON } from ".";
+function get_mask_chars(src: string, mask: u64): void {
+  const srcPtr = changetype<usize>(src);
+  while (mask != 0) {
+    const laneIdx = usize(ctz(mask) >> 3);
+    mask &= ~(0xffff << (laneIdx << 3));
+    // mask &= mask - 1;
+    console.log("Lane:  " + laneIdx.toString());
+    const srcIdx = srcPtr + laneIdx;
+    const chunk = load<u32>(srcIdx);
+    const code = <u16>(chunk >> 16);
 
-const s = new Set<string>();
-s.add("Hello");
-s.add("World");
-s.add("!");
-
-const serialized = JSON.stringify(s);
-console.log("Serialized: " + serialized);
-
-const deserialized = JSON.parse<Set<string>>(serialized);
-console.log("Deserialized: " + JSON.stringify(deserialized));
-
-@json
-class SetClass {
-    constructor(public items: Set<string>) {}
+    console.log("Chunk: " + String.fromCharCode(chunk & 0xffff) + String.fromCharCode(chunk >> 16));
+    console.log("Code:  " + String.fromCharCode(load<u16>(srcIdx)));
+  }
 }
 
-const setClass = new SetClass(s);
-const serializedClass = JSON.stringify(setClass);
-console.log("Serialized Class: " + serializedClass);
+function backslash_or_quote_mask(block: u64): u64 {
+  const b = block ^ 0x005c_005c_005c_005c;
+  const q = block ^ 0x0022_0022_0022_0022;
+  return (((q - 0x0001_0001_0001_0001) & ~q) | ((b - 0x0001_0001_0001_0001) & ~b)) & 0x0080_0080_0080_0080;
+}
 
-const deserializedClass = JSON.parse<SetClass>(serializedClass);
-console.log("Deserialized Class: " + JSON.stringify(deserializedClass));
+const input = '\\"a"';
+get_mask_chars(input, backslash_or_quote_mask(load<u64>(changetype<usize>(input))));