json-as 1.3.6 → 1.3.7

package/assembly/serialize/index/typedarray.ts

@@ -1,12 +1,21 @@
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { JSON } from "../..";
-export { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typedarray";
-import { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typedarray";
+export {
+  serializeArrayBufferUnsafe,
+  serializeTypedArray,
+} from "../simple/typedarray";
+import {
+  serializeArrayBufferUnsafe,
+  serializeTypedArray,
+} from "../simple/typedarray";
 
 
 @inline export function serializeDynamic(type: u16, data: usize): void {
   if (type == JSON.Types.ArrayBuffer) {
-    serializeArrayBufferUnsafe(data, changetype<OBJECT>(data - TOTAL_OVERHEAD).rtSize);
+    serializeArrayBufferUnsafe(
+      data,
+      changetype<OBJECT>(data - TOTAL_OVERHEAD).rtSize,
+    );
   } else if (type == JSON.Types.TypedArray) {
     const id = changetype<OBJECT>(data - TOTAL_OVERHEAD).rtId;
     if (id == idof<Int8Array>()) {
@@ -14,7 +23,9 @@ import { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typed
     } else if (id == idof<Uint8Array>()) {
       serializeTypedArray<Uint8Array>(changetype<Uint8Array>(data));
     } else if (id == idof<Uint8ClampedArray>()) {
-      serializeTypedArray<Uint8ClampedArray>(changetype<Uint8ClampedArray>(data));
+      serializeTypedArray<Uint8ClampedArray>(
+        changetype<Uint8ClampedArray>(data),
+      );
     } else if (id == idof<Int16Array>()) {
       serializeTypedArray<Int16Array>(changetype<Int16Array>(data));
     } else if (id == idof<Uint16Array>()) {
@@ -35,8 +46,12 @@ import { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typed
       serializeTypedArray<Int8Array>(changetype<Int8Array>(data));
     } else if (changetype<Uint8Array>(data) instanceof Uint8Array) {
       serializeTypedArray<Uint8Array>(changetype<Uint8Array>(data));
-    } else if (changetype<Uint8ClampedArray>(data) instanceof Uint8ClampedArray) {
-      serializeTypedArray<Uint8ClampedArray>(changetype<Uint8ClampedArray>(data));
+    } else if (
+      changetype<Uint8ClampedArray>(data) instanceof Uint8ClampedArray
+    ) {
+      serializeTypedArray<Uint8ClampedArray>(
+        changetype<Uint8ClampedArray>(data),
+      );
     } else if (changetype<Int16Array>(data) instanceof Int16Array) {
       serializeTypedArray<Int16Array>(changetype<Int16Array>(data));
     } else if (changetype<Uint16Array>(data) instanceof Uint16Array) {
@@ -62,5 +77,8 @@ import { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typed
 
 @inline export function serializeArrayBuffer(data: ArrayBuffer): void {
   const dataStart = changetype<usize>(data);
-  serializeArrayBufferUnsafe(dataStart, changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize);
+  serializeArrayBufferUnsafe(
+    dataStart,
+    changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize,
+  );
 }

package/assembly/serialize/simd/string.ts

@@ -39,7 +39,9 @@ export function serializeString_SIMD(src: string): void {
       const lt20 = i16x8.lt_u(block, SPLAT_0020);
       const gteD8 = i8x16.gt_u(block, SPLAT_FFD8);
 
-      const mask = i8x16.bitmask(v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8))));
+      const mask = i8x16.bitmask(
+        v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8))),
+      );
       if (mask != 0) break;
 
       store<v128>(dst, block);
@@ -83,7 +85,9 @@ 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));
 
-    let mask = i8x16.bitmask(v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8))));
+    let mask = i8x16.bitmask(
+      v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8))),
+    );
 
     if (mask == 0) {
       store<v128>(bs.offset, block);

package/assembly/serialize/simple/array.ts

@@ -53,7 +53,180 @@ function serializeArrayElement<T>(value: T): void {
   JSON.__serialize<T>(value);
 }
 
+// ---------------------------------------------------------------------------
+// Specialized fast paths
+// ---------------------------------------------------------------------------
+//
+// `bool[]` and `u8[]` / `i8[]` serializers fold the element write and the
+// trailing comma into a single per-element store. The outer dispatcher
+// emits `[` once, the loop emits `VALUE,` once per element, and the closing
+// `]` overwrites the trailing comma. This eliminates the separate
+// comma-store + advance per element that the generic `serializeArray` does.
+
+// `"true,"` packed UTF-16: `t,r,u,e,,` lanes 0..4 = bytes 0..9.
+@inline const TRUE_COMMA_LO: u64 = 0x0065_0075_0072_0074;
+
+
+@inline const TRUE_COMMA_HI: u16 = 0x002c;
+// `"false,"` packed UTF-16: `f,a,l,s,e,,` lanes 0..5 = bytes 0..11.
+@inline const FALSE_COMMA_LO: u64 = 0x0073_006c_0061_0066;
+
+
+@inline const FALSE_COMMA_HI: u32 = 0x002c_0065;
+
+function serializeBoolArrayFast(src: bool[]): void {
+  const len = src.length;
+  // Worst case: every element is `"false,"` = 12 bytes; plus 4 for `[]`.
+  bs.proposeSize(4 + <u32>len * 12);
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+  if (len == 0) {
+    store<u16>(bs.offset, BRACKET_RIGHT);
+    bs.offset += 2;
+    return;
+  }
+
+  const dataStart = src.dataStart;
+  for (let i: i32 = 0; i < len; i++) {
+    if (load<bool>(dataStart + <usize>i)) {
+      store<u64>(bs.offset, TRUE_COMMA_LO);
+      store<u16>(bs.offset, TRUE_COMMA_HI, 8);
+      bs.offset += 10;
+    } else {
+      store<u64>(bs.offset, FALSE_COMMA_LO);
+      store<u32>(bs.offset, FALSE_COMMA_HI, 8);
+      bs.offset += 12;
+    }
+  }
+  // Overwrite the final trailing comma with `]`.
+  store<u16>(bs.offset - 2, BRACKET_RIGHT);
+}
+
+// 256-entry table mapping `u8` value -> UTF-16 chars of `"DDD,"` packed in a
+// u64. Unused lanes hold garbage that the next element's store overwrites.
+const U8_SERIALIZE_LUT: usize = memory.data(2048); // 256 * sizeof<u64>
+// 256-entry table mapping `u8` value -> byte count of the packed encoding.
+const U8_SERIALIZE_LEN_LUT: usize = memory.data(256);
+let _u8LutInited: bool = false;
+
+function initU8Lut(): void {
+  for (let i: i32 = 0; i < 256; i++) {
+    let chars: u64;
+    let bytes: u8;
+    if (i < 10) {
+      chars = u64(0x30 + i) | (u64(0x2c) << 16);
+      bytes = 4;
+    } else if (i < 100) {
+      const d0 = i / 10;
+      const d1 = i % 10;
+      chars = u64(0x30 + d0) | (u64(0x30 + d1) << 16) | (u64(0x2c) << 32);
+      bytes = 6;
+    } else {
+      const d0 = i / 100;
+      const d1 = (i / 10) % 10;
+      const d2 = i % 10;
+      chars =
+        u64(0x30 + d0) |
+        (u64(0x30 + d1) << 16) |
+        (u64(0x30 + d2) << 32) |
+        (u64(0x2c) << 48);
+      bytes = 8;
+    }
+    store<u64>(U8_SERIALIZE_LUT + ((<usize>i) << 3), chars);
+    store<u8>(U8_SERIALIZE_LEN_LUT + <usize>i, bytes);
+  }
+  _u8LutInited = true;
+}
+
+
+@inline function ensureU8Lut(): void {
+  if (!_u8LutInited) initU8Lut();
+}
+
+function serializeU8ArrayFast(src: u8[]): void {
+  const len = src.length;
+  // Worst case: every element is 3 digits + comma = 8 bytes; plus 4 for `[]`.
+  bs.proposeSize(4 + <u32>len * 8);
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+  if (len == 0) {
+    store<u16>(bs.offset, BRACKET_RIGHT);
+    bs.offset += 2;
+    return;
+  }
+  ensureU8Lut();
+
+  const dataStart = src.dataStart;
+  for (let i: i32 = 0; i < len; i++) {
+    const v = <usize>load<u8>(dataStart + <usize>i);
+    const chars = load<u64>(U8_SERIALIZE_LUT + (v << 3));
+    const byteCount = <usize>load<u8>(U8_SERIALIZE_LEN_LUT + v);
+    store<u64>(bs.offset, chars);
+    bs.offset += byteCount;
+  }
+  store<u16>(bs.offset - 2, BRACKET_RIGHT);
+}
+
+function serializeI8ArrayFast(src: i8[]): void {
+  const len = src.length;
+  // Worst case: every element is `-DDD,` = 5 chars = 10 bytes; plus 4 for `[]`.
+  bs.proposeSize(4 + <u32>len * 10);
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+  if (len == 0) {
+    store<u16>(bs.offset, BRACKET_RIGHT);
+    bs.offset += 2;
+    return;
+  }
+  ensureU8Lut();
+
+  const dataStart = src.dataStart;
+  for (let i: i32 = 0; i < len; i++) {
+    let signed = load<i8>(dataStart + <usize>i);
+    let absVal: u32;
+    if (signed < 0) {
+      store<u16>(bs.offset, 0x2d); // '-'
+      bs.offset += 2;
+      absVal = <u32>-(<i32>signed);
+    } else {
+      absVal = <u32>signed;
+    }
+    const chars = load<u64>(U8_SERIALIZE_LUT + ((<usize>absVal) << 3));
+    const byteCount = <usize>load<u8>(U8_SERIALIZE_LEN_LUT + <usize>absVal);
+    store<u64>(bs.offset, chars);
+    bs.offset += byteCount;
+  }
+  store<u16>(bs.offset - 2, BRACKET_RIGHT);
+}
+
 export function serializeArray<T extends any[]>(src: T): void {
+  // Specialized fast paths fold the per-element comma into the element write,
+  // saving one `store<u16>` + advance per iteration. AS folds the type checks
+  // at compile time so the non-matching branches don't ship.
+  if (isBoolean<valueof<T>>()) {
+    // @ts-expect-error: T is bool[]
+    serializeBoolArrayFast(changetype<bool[]>(src));
+    return;
+  }
+  if (
+    isInteger<valueof<T>>() &&
+    !isSigned<valueof<T>>() &&
+    sizeof<valueof<T>>() == 1
+  ) {
+    // @ts-expect-error: T is u8[]
+    serializeU8ArrayFast(changetype<u8[]>(src));
+    return;
+  }
+  if (
+    isInteger<valueof<T>>() &&
+    isSigned<valueof<T>>() &&
+    sizeof<valueof<T>>() == 1
+  ) {
+    // @ts-expect-error: T is i8[]
+    serializeI8ArrayFast(changetype<i8[]>(src));
+    return;
+  }
+
   const len = src.length;
   const end = len - 1;
   let i = 0;
@@ -63,7 +236,12 @@ export function serializeArray<T extends any[]>(src: T): void {
     bs.offset += 4;
     return;
   }
-  if (isBoolean<valueof<T>>() || isInteger<valueof<T>>() || isFloat<valueof<T>>() || isString<valueof<T>>()) {
+  if (
+    isBoolean<valueof<T>>() ||
+    isInteger<valueof<T>>() ||
+    isFloat<valueof<T>>() ||
+    isString<valueof<T>>()
+  ) {
     reservePrimitiveArray<valueof<T>>(len);
   } else {
     bs.proposeSize(4 + <u32>(len - 1) * 2);

package/assembly/serialize/simple/float.ts

@@ -1,5 +1,8 @@
 import { bs } from "../../../lib/as-bs";
-import { dragonbox_f32_buffered, dragonbox_f64_buffered } from "../../util/dragonbox";
+import {
+  dragonbox_f32_buffered,
+  dragonbox_f64_buffered,
+} from "../../util/dragonbox";
 
 
 @inline

package/assembly/serialize/simple/integer.ts

@@ -1,20 +1,19 @@
 import { bs } from "../../../lib/as-bs";
-import { itoa_buffered } from "util/number";
+import { ensureItoaPairs, itoaFast } from "../../util/itoa-fast";
 
 
 @inline
 export function serializeIntegerUnsafe<T extends number>(data: T): void {
-  const bytesWritten = itoa_buffered(bs.offset, data) << 1;
-  bs.offset += bytesWritten;
+  ensureItoaPairs();
+  const charsWritten = itoaFast<T>(bs.offset, data);
+  bs.offset += (<usize>charsWritten) << 1;
 }
 
 // @ts-ignore: inline
 @inline export function serializeInteger<T extends number>(data: T): void {
+  ensureItoaPairs();
   bs.ensureSize(sizeof<T>() << 3);
-  const bytesWritten = itoa_buffered(bs.offset, data) << 1;
-  bs.growSize(bytesWritten);
-  bs.offset += bytesWritten;
+  const charsWritten = itoaFast<T>(bs.offset, data);
+  bs.growSize((<u32>charsWritten) << 1);
+  bs.offset += (<usize>charsWritten) << 1;
 }
-
-// 32 {"x":,"y":,"z"}
-// 18 3.41.28.3

package/assembly/serialize/simple/map.ts

@@ -26,7 +26,9 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
     if (keyIsString) {
       JSON.__serialize(unchecked(keys[i]));
     } else {
-      JSON.__serialize<string>(JSON.internal.stringify<indexof<T>>(unchecked(keys[i])));
+      JSON.__serialize<string>(
+        JSON.internal.stringify<indexof<T>>(unchecked(keys[i])),
+      );
     }
     store<u16>(bs.offset, COLON);
     bs.offset += 2;
@@ -38,7 +40,9 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
   if (keyIsString) {
     JSON.__serialize(unchecked(keys[srcEnd]));
   } else {
-    JSON.__serialize<string>(JSON.internal.stringify<indexof<T>>(unchecked(keys[srcEnd])));
+    JSON.__serialize<string>(
+      JSON.internal.stringify<indexof<T>>(unchecked(keys[srcEnd])),
+    );
   }
   store<u16>(bs.offset, COLON);
   bs.offset += 2;

package/assembly/serialize/simple/raw.ts

@@ -11,6 +11,10 @@ import { bytes } from "../../util";
 @inline export function serializeRaw(data: JSON.Raw): void {
   const dataSize = bytes(data.data);
   bs.proposeSize(dataSize);
-  memory.copy(changetype<usize>(bs.offset), changetype<usize>(data.data), dataSize);
+  memory.copy(
+    changetype<usize>(bs.offset),
+    changetype<usize>(data.data),
+    dataSize,
+  );
   bs.offset += dataSize;
 }

package/assembly/serialize/simple/set.ts

@@ -38,7 +38,12 @@ export function serializeSet<T extends Set<any>>(src: T): void {
     bs.offset += 4;
     return;
   }
-  if (isBoolean<indexof<T>>() || isInteger<indexof<T>>() || isFloat<indexof<T>>() || isString<indexof<T>>()) {
+  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);

package/assembly/serialize/simple/staticarray.ts

@@ -40,7 +40,12 @@ export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
     bs.offset += 4;
     return;
   }
-  if (isBoolean<valueof<T>>() || isInteger<valueof<T>>() || isFloat<valueof<T>>() || isString<valueof<T>>()) {
+  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);

package/assembly/serialize/simple/string.ts

@@ -1,5 +1,4 @@
 import { bs } from "../../../lib/as-bs";
-import { _intTo16 } from "../../custom/util";
 import { bytes } from "../../util/bytes";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";

package/assembly/serialize/simple/typedarray.ts

@@ -25,9 +25,13 @@ function reserveTypedArray<T extends ArrayLike<number>>(len: i32): void {
 
 
 @inline
-function serializeTypedArrayElement<T extends ArrayLike<number>>(src: T, index: i32): void {
+function serializeTypedArrayElement<T extends ArrayLike<number>>(
+  src: T,
+  index: i32,
+): void {
   if (isFloat<valueof<T>>()) {
-    if (sizeof<valueof<T>>() == 4) serializeFloat32Unsafe(<f32>unchecked(src[index]));
+    if (sizeof<valueof<T>>() == 4)
+      serializeFloat32Unsafe(<f32>unchecked(src[index]));
     else serializeFloat64Unsafe(<f64>unchecked(src[index]));
   } else {
     serializeIntegerUnsafe<valueof<T>>(unchecked(src[index]));
@@ -59,7 +63,10 @@ export function serializeTypedArray<T extends ArrayLike<number>>(src: T): void {
   bs.offset += 2;
 }
 
-export function serializeArrayBufferUnsafe(srcStart: usize, byteLength: i32): void {
+export function serializeArrayBufferUnsafe(
+  srcStart: usize,
+  byteLength: i32,
+): void {
   const end = byteLength - 1;
 
   if (end == -1) {

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,7 +174,9 @@ export function serializeString_SWAR(src: string): void {
   bs.offset += 2;
 }
 
-export function serializeString_SWAR_ExperimentalTableEscapes(src: string): void {
+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;
@@ -308,9 +315,15 @@ 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;
 }
 

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);
 }