json-as 1.3.6 → 1.3.8

package/assembly/serialize/swar/string.ts

@@ -25,7 +25,11 @@ export function serializeString_SWAR(src: string): void {
       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);
+      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;
@@ -35,7 +39,8 @@ export function serializeString_SWAR(src: string): void {
 
     while (srcStart <= srcEnd - 2) {
       const code = load<u16>(srcStart);
-      if (code > 0x7f || code == BACK_SLASH || code == QUOTE || code < 32) break;
+      if (code > 0x7f || code == BACK_SLASH || code == QUOTE || code < 32)
+        break;
       store<u16>(dst, code);
       srcStart += 2;
       dst += 2;
@@ -169,130 +174,6 @@ export function serializeString_SWAR(src: string): void {
   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;
-
-  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 (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;
-}
-
 // @ts-expect-error: @inline is a valid decorator
 @inline function write_u_escape(code: u16): void {
   bs.growSize(10);
@@ -308,21 +189,14 @@ export function serializeString_SWAR_ExperimentalTableEscapes(src: string): void
   // Setting bit 8 of each 16-bit lane (high byte LSB) prevents borrow from a
   // low byte underflow from propagating across lane boundaries into the next lane.
   const loSafe = lo | 0x0100_0100_0100_0100;
-  const ascii_mask = ((loSafe - 0x0020_0020_0020_0020) | ((loSafe ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) | ((loSafe ^ 0x005c_005c_005c_005c) - 0x0001_0001_0001_0001)) & (0x0080_0080_0080_0080 & ~lo);
+  const ascii_mask =
+    ((loSafe - 0x0020_0020_0020_0020) |
+      ((loSafe ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) |
+      ((loSafe ^ 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;
+  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 loSafe = lo | 0x0100_0100_0100_0100;
-  const ascii_mask =
-    ((loSafe - 0x0020_0020_0020_0020) | // lt 0x20
-      ((loSafe ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) | // eq 0x22
-      ((loSafe ^ 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/util/atoi-fast.ts

@@ -0,0 +1,81 @@
+// Back-compat shim. The canonical fast SWAR atoi/atou implementations live
+// in `deserialize/swar/integer.ts`, using the full tiered stride hierarchy
+// (parse16 -> parse8 -> parse4 -> scalar). These thin wrappers preserve the
+// original `(srcStart, srcEnd, [dstPtr])` signatures used by existing tests
+// and benches.
+
+import {
+  deserializeInteger_SWAR,
+  deserializeIntegerField_SWAR,
+  deserializeUnsigned_SWAR,
+  deserializeUnsignedField_SWAR,
+} from "../deserialize/swar/integer";
+
+/**
+ * Parse an unsigned integer by consuming the whole range as digits.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @param srcEnd   Pointer just past the last code unit.
+ * @returns The parsed value, truncated to `T`.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function atou<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  return deserializeUnsigned_SWAR<T>(srcStart, srcEnd);
+}
+
+/**
+ * Parse a signed integer by consuming the whole range as digits, with an
+ * optional leading `-`.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @param srcEnd   Pointer just past the last code unit.
+ * @returns The parsed value, truncated to `T`.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function atoi<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  return deserializeInteger_SWAR<T>(srcStart, srcEnd);
+}
+
+/**
+ * Scan an unsigned integer, stopping at the first non-digit. Writes the
+ * parsed value through `dstPtr` and returns the source position immediately
+ * after the last digit.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @param srcEnd   Pointer just past the last code unit.
+ * @param dstPtr   Destination pointer for the parsed value.
+ * @returns The source position immediately after the last digit consumed.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function atouScan<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstPtr: usize,
+): usize {
+  return deserializeUnsignedField_SWAR<T>(srcStart, srcEnd, dstPtr, 0);
+}
+
+/**
+ * Scan a signed integer, stopping at the first non-digit. Handles an
+ * optional leading `-`. Writes the parsed value through `dstPtr` and
+ * returns the source position immediately after the last digit.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @param srcEnd   Pointer just past the last code unit.
+ * @param dstPtr   Destination pointer for the parsed value.
+ * @returns The source position immediately after the last digit consumed.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function atoiScan<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstPtr: usize,
+): usize {
+  return deserializeIntegerField_SWAR<T>(srcStart, srcEnd, dstPtr, 0);
+}

package/assembly/util/concat.ts

@@ -4,6 +4,10 @@ export function concat(left: string, right: string): string {
   const rightSize: usize = bytes(right);
   const jointSize: usize = leftSize + rightSize;
   const jointPtr = __renew(changetype<usize>(left), jointSize);
-  memory.copy(changetype<usize>(left) + leftSize, changetype<usize>(right), rightSize);
+  memory.copy(
+    changetype<usize>(left) + leftSize,
+    changetype<usize>(right),
+    rightSize,
+  );
   return changetype<string>(jointPtr);
 }