json-as 1.3.5 → 1.3.7

package/assembly/deserialize/swar/array/integer.ts

@@ -1,5 +1,6 @@
-import { deserializeIntegerField } from "../../simple/integer";
-import { deserializeUnsignedField } from "../../simple/unsigned";
+import { deserializeIntegerField } from "../../index/integer";
+import { deserializeUnsignedField } from "../../index/unsigned";
+import { deserializeIntegerArray as deserializeIntegerArray_NAIVE } from "../../simple/array/integer";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
@@ -10,37 +11,10 @@ const ASCII_RANGE_MASK_4: u64 = 0xfff0fff0fff0fff0;
 const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
 
 
-@inline function pushSignedInteger<T extends number[]>(out: T, value: i64): void {
-  if (sizeof<valueof<T>>() == sizeof<i8>()) {
-    out.push(<valueof<T>>(<i8>value));
-  } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
-    out.push(<valueof<T>>(<i16>value));
-  } else if (sizeof<valueof<T>>() == sizeof<i32>()) {
-    out.push(<valueof<T>>(<i32>value));
-  } else if (sizeof<valueof<T>>() == sizeof<isize>()) {
-    out.push(<valueof<T>>(<isize>value));
-  } else {
-    out.push(<valueof<T>>value);
-  }
-}
-
-
-@inline function pushUnsignedInteger<T extends number[]>(out: T, value: u64): void {
-  if (sizeof<valueof<T>>() == sizeof<u8>()) {
-    out.push(<valueof<T>>(<u8>value));
-  } else if (sizeof<valueof<T>>() == sizeof<u16>()) {
-    out.push(<valueof<T>>(<u16>value));
-  } else if (sizeof<valueof<T>>() == sizeof<u32>()) {
-    out.push(<valueof<T>>(<u32>value));
-  } else if (sizeof<valueof<T>>() == sizeof<usize>()) {
-    out.push(<valueof<T>>(<usize>value));
-  } else {
-    out.push(<valueof<T>>value);
-  }
-}
-
-
-@inline function storeSignedInteger<T extends number[]>(slot: usize, value: i64): void {
+@inline function storeSignedInteger<T extends number[]>(
+  slot: usize,
+  value: i64,
+): void {
   if (sizeof<valueof<T>>() == sizeof<i8>()) {
     store<i8>(slot, <i8>value);
   } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
@@ -55,7 +29,10 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
 }
 
 
-@inline function storeUnsignedInteger<T extends number[]>(slot: usize, value: u64): void {
+@inline function storeUnsignedInteger<T extends number[]>(
+  slot: usize,
+  value: u64,
+): void {
   if (sizeof<valueof<T>>() == sizeof<u8>()) {
     store<u8>(slot, <u8>value);
   } else if (sizeof<valueof<T>>() == sizeof<u16>()) {
@@ -72,13 +49,29 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
 
 @inline function parse4DigitsASCII(block: u64): u32 {
   const digits = (block & ASCII_LANE_MASK_4) - ASCII_ZERO_4;
-  if (((digits | (digits + ASCII_RANGE_ADD_4)) & ASCII_RANGE_MASK_4) != 0) return U32.MAX_VALUE;
-
-  return <u32>(<u32>(digits & 0xffff) * 1000 + <u32>((digits >> 16) & 0xffff) * 100 + <u32>((digits >> 32) & 0xffff) * 10 + <u32>(digits >> 48));
+  if (((digits | (digits + ASCII_RANGE_ADD_4)) & ASCII_RANGE_MASK_4) != 0)
+    return U32.MAX_VALUE;
+
+  return <u32>(
+    (<u32>(digits & 0xffff) * 1000 +
+      <u32>((digits >> 16) & 0xffff) * 100 +
+      <u32>((digits >> 32) & 0xffff) * 10 +
+      <u32>(digits >> 48))
+  );
 }
 
-
-@inline function parseSignedIntegerScalar<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+// The four parse helpers below take a `slot` pointer (`writePtr`) and store
+// the value directly via `store<valueof<T>>(slot, ...)`. The outer dispatcher
+// owns the array's `out.length = maxElements` pre-allocation and the
+// `writePtr` advance, so the per-element `Array.push` capacity check and
+// length write are eliminated for every integer width, not just the u8/i8
+// narrow-lane path.
+
+@inline function parseSignedIntegerScalar<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  slot: usize,
+): usize {
   let negative = false;
   let code = load<u16>(srcStart);
   if (code == 45) {
@@ -100,12 +93,16 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  pushSignedInteger<T>(out, negative ? -(<i64>value) : <i64>value);
+  storeSignedInteger<T>(slot, negative ? -(<i64>value) : <i64>value);
   return srcStart;
 }
 
 
-@inline function parseUnsignedIntegerScalar<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline function parseUnsignedIntegerScalar<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  slot: usize,
+): usize {
   let digit = <u32>load<u16>(srcStart) - 48;
   if (digit > 9) return 0;
 
@@ -118,12 +115,16 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  pushUnsignedInteger<T>(out, value);
+  storeUnsignedInteger<T>(slot, value);
   return srcStart;
 }
 
 
-@inline function parseSignedIntegerSWAR<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline function parseSignedIntegerSWAR<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  slot: usize,
+): usize {
   let negative = false;
   let code = load<u16>(srcStart);
   if (code == 45) {
@@ -139,11 +140,16 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
   let value: u64 = digit;
   srcStart += 2;
 
-  while (srcStart + 6 < srcEnd) {
-    const parsed = parse4DigitsASCII(load<u64>(srcStart));
-    if (parsed == U32.MAX_VALUE) break;
-    value = value * 10000 + parsed;
-    srcStart += 8;
+  // i8 tops out at 3 digits (-128..127), so the 4-digit kernel can never fire
+  // and the failing load + range check just burns cycles. Gate on the lane
+  // width so AS folds the loop away at compile time.
+  if (sizeof<valueof<T>>() > 1) {
+    while (srcStart + 6 < srcEnd) {
+      const parsed = parse4DigitsASCII(load<u64>(srcStart));
+      if (parsed == U32.MAX_VALUE) break;
+      value = value * 10000 + parsed;
+      srcStart += 8;
+    }
   }
 
   while (srcStart < srcEnd) {
@@ -153,12 +159,40 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  pushSignedInteger<T>(out, negative ? -(<i64>value) : <i64>value);
+  storeSignedInteger<T>(slot, negative ? -(<i64>value) : <i64>value);
   return srcStart;
 }
 
 
-@inline function parseUnsignedIntegerSWAR<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline function parseUnsignedIntegerSWAR<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  slot: usize,
+): usize {
+  // Narrow-type path mirrors the NAIVE structure: a tight scan loop to find
+  // the element terminator, then a fixed-count fold with no per-digit break.
+  // TurboFan tends to schedule this better than a single combined
+  // scan-and-fold loop because the fold has no data-dependent exit.
+  if (sizeof<valueof<T>>() <= 2) {
+    const first = <u32>load<u16>(srcStart) - 48;
+    if (first > 9) return 0;
+    const lastIndex = srcStart;
+    srcStart += 2;
+    while (srcStart < srcEnd) {
+      const c = <u32>load<u16>(srcStart) - 48;
+      if (c > 9) break;
+      srcStart += 2;
+    }
+    let value: u64 = 0;
+    let p = lastIndex;
+    while (p < srcStart) {
+      value = value * 10 + (<u32>load<u16>(p) - 48);
+      p += 2;
+    }
+    storeUnsignedInteger<T>(slot, value);
+    return srcStart;
+  }
+
   let digit = <u32>load<u16>(srcStart) - 48;
   if (digit > 9) return 0;
 
@@ -179,12 +213,15 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
     srcStart += 2;
   }
 
-  pushUnsignedInteger<T>(out, value);
+  storeUnsignedInteger<T>(slot, value);
   return srcStart;
 }
 
 
-@inline function skipIntegerArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
+@inline function skipIntegerArrayWhitespace(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) {
     srcStart += 2;
   }
@@ -192,8 +229,14 @@ const ASCII_RANGE_ADD_4: u64 = 0x0006000600060006;
 }
 
 // @ts-ignore: Decorator valid here
-export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+export function deserializeIntegerArray_SLOW<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   let index = 0;
 
   out.length = 0;
@@ -231,7 +274,10 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
         srcStart += 2;
       }
 
-      storeSignedInteger<T>(ensureArrayElementSlot<T>(out, index), negative ? -(<i64>value) : <i64>value);
+      storeSignedInteger<T>(
+        ensureArrayElementSlot<T>(out, index),
+        negative ? -(<i64>value) : <i64>value,
+      );
     } else {
       let digit = <u32>code - 48;
       if (digit > 9) break;
@@ -265,8 +311,15 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
 }
 
 
-@inline function deserializeIntegerArrayImpl<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize, useSWAR: bool): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+@inline function deserializeIntegerArrayImpl<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+  useSWAR: bool,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   const originalSrcStart = srcStart;
   const reusableLength = out.length;
 
@@ -300,11 +353,13 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
           let value: u64 = digit;
           srcStart += 2;
 
-          while (srcStart + 6 < srcEnd) {
-            const parsed = parse4DigitsASCII(load<u64>(srcStart));
-            if (parsed == U32.MAX_VALUE) break;
-            value = value * 10000 + parsed;
-            srcStart += 8;
+          if (sizeof<valueof<T>>() > 1) {
+            while (srcStart + 6 < srcEnd) {
+              const parsed = parse4DigitsASCII(load<u64>(srcStart));
+              if (parsed == U32.MAX_VALUE) break;
+              value = value * 10000 + parsed;
+              srcStart += 8;
+            }
           }
 
           while (srcStart < srcEnd) {
@@ -315,7 +370,10 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
           }
 
           if (index >= reusableLength) break;
-          storeSignedInteger<T>(dataStart + <usize>index * sizeof<valueof<T>>(), negative ? -(<i64>value) : <i64>value);
+          storeSignedInteger<T>(
+            dataStart + <usize>index * sizeof<valueof<T>>(),
+            negative ? -(<i64>value) : <i64>value,
+          );
           index++;
           if (srcStart >= srcEnd) break;
 
@@ -338,11 +396,13 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
           let value: u64 = digit;
           srcStart += 2;
 
-          while (srcStart + 6 < srcEnd) {
-            const parsed = parse4DigitsASCII(load<u64>(srcStart));
-            if (parsed == U32.MAX_VALUE) break;
-            value = value * 10000 + parsed;
-            srcStart += 8;
+          if (sizeof<valueof<T>>() > 1) {
+            while (srcStart + 6 < srcEnd) {
+              const parsed = parse4DigitsASCII(load<u64>(srcStart));
+              if (parsed == U32.MAX_VALUE) break;
+              value = value * 10000 + parsed;
+              srcStart += 8;
+            }
           }
 
           while (srcStart < srcEnd) {
@@ -353,7 +413,10 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
           }
 
           if (index >= reusableLength) break;
-          storeUnsignedInteger<T>(dataStart + <usize>index * sizeof<valueof<T>>(), value);
+          storeUnsignedInteger<T>(
+            dataStart + <usize>index * sizeof<valueof<T>>(),
+            value,
+          );
           index++;
           if (srcStart >= srcEnd) break;
 
@@ -374,58 +437,229 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(srcStart: usize
     srcStart = originalSrcStart;
   }
 
-  out.length = 0;
+  // Worst-case sizing: every element is at least 1 digit + 1 delimiter = 2
+  // UTF-16 chars = 4 bytes. AS skips zero-fill on `length=` for unmanaged
+  // primitive types (every concrete `valueof<T>` here is an integer), so the
+  // over-allocation costs only a small amount of trimmed storage at the end.
+  // The parse helpers below store through `writePtr` directly, eliminating
+  // `Array.push`'s per-element capacity check + length write for every
+  // integer width.
+  const elementSize = sizeof<valueof<T>>();
+  const maxElements = i32((<usize>(srcEnd - srcStart)) >> 2);
+  if (maxElements > 0) out.length = maxElements;
+  const dataStart = out.dataStart;
+  let writePtr = dataStart;
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
     if (srcStart >= srcEnd) break;
-    if (load<u16>(srcStart) == BRACKET_RIGHT) return out;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return out;
+    }
 
     if (isSigned<valueof<T>>()) {
       while (srcStart < srcEnd) {
-        srcStart = useSWAR ? parseSignedIntegerSWAR<T>(srcStart, srcEnd, out) : parseSignedIntegerScalar<T>(srcStart, srcEnd, out);
-        if (!srcStart || srcStart >= srcEnd) break;
+        const next = useSWAR
+          ? parseSignedIntegerSWAR<T>(srcStart, srcEnd, writePtr)
+          : parseSignedIntegerScalar<T>(srcStart, srcEnd, writePtr);
+        if (!next) break;
+        writePtr += elementSize;
+        srcStart = next;
+        if (srcStart >= srcEnd) break;
 
         const code = load<u16>(srcStart);
         if (code == COMMA) {
           srcStart += 2;
           continue;
         }
-        if (code == BRACKET_RIGHT) return out;
+        if (code == BRACKET_RIGHT) {
+          out.length = i32(<usize>(writePtr - dataStart) / elementSize);
+          return out;
+        }
         break;
       }
     } else {
       while (srcStart < srcEnd) {
-        srcStart = useSWAR ? parseUnsignedIntegerSWAR<T>(srcStart, srcEnd, out) : parseUnsignedIntegerScalar<T>(srcStart, srcEnd, out);
-        if (!srcStart || srcStart >= srcEnd) break;
+        const next = useSWAR
+          ? parseUnsignedIntegerSWAR<T>(srcStart, srcEnd, writePtr)
+          : parseUnsignedIntegerScalar<T>(srcStart, srcEnd, writePtr);
+        if (!next) break;
+        writePtr += elementSize;
+        srcStart = next;
+        if (srcStart >= srcEnd) break;
 
         const code = load<u16>(srcStart);
         if (code == COMMA) {
           srcStart += 2;
           continue;
         }
-        if (code == BRACKET_RIGHT) return out;
+        if (code == BRACKET_RIGHT) {
+          out.length = i32(<usize>(writePtr - dataStart) / elementSize);
+          return out;
+        }
         break;
       }
     }
   } while (false);
 
-  return deserializeIntegerArray_SLOW<T>(originalSrcStart, srcEnd, changetype<usize>(out));
+  // Fast path bailed (whitespace, malformed numbers, etc). Hand off to the
+  // SLOW path which resets `out.length` to 0 and re-parses from the original
+  // input. The pre-allocated buffer is retained, so SLOW's per-element
+  // `ensureArrayElementSlot` grows-or-reuses through the existing capacity.
+  return deserializeIntegerArray_SLOW<T>(
+    originalSrcStart,
+    srcEnd,
+    changetype<usize>(out),
+  );
 }
 
 // @ts-ignore: Decorator valid here
-export function deserializeIntegerArray<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+export function deserializeIntegerArray<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
   return deserializeIntegerArrayImpl<T>(srcStart, srcEnd, dst, false);
 }
 
 // @ts-ignore: Decorator valid here
-export function deserializeIntegerArray_SWAR<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+export function deserializeIntegerArray_SWAR<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  // u8/i8 elements use a dedicated two-pass SWAR path: a 4-char-stride
+  // comma counter pre-sizes the array so the parse pass can drop the
+  // per-push capacity check and write through a direct pointer. The
+  // wider-lane SWAR kernel never amortizes itself for narrow elements
+  // (u8 max 3 digits) so we skip it entirely here.
+  if (sizeof<valueof<T>>() <= 1) {
+    return deserializeNarrowIntegerArray_SWAR<T>(srcStart, srcEnd, dst);
+  }
   return deserializeIntegerArrayImpl<T>(srcStart, srcEnd, dst, true);
 }
 
+/**
+ * Narrow-lane (u8/i8) integer-array deserializer.
+ *
+ * Two passes:
+ *   1) SWAR comma counter (4 chars per stride, popcnt over the lane mask)
+ *      sizes the array exactly so the parse pass can use unchecked stores.
+ *   2) Walks the input NAIVE-style (skip non-digits, scan to separator,
+ *      fold digits) but writes through a direct pointer, eliminating
+ *      `Array.push`'s per-element capacity check and length write.
+ *
+ * V8 already auto-SIMDs NAIVE's scalar scan loop tighter than a hand-rolled
+ * SWAR scan in pass 2, so we keep that pattern there and only pay SWAR cost
+ * on the pre-count - which is a tight load-mask-popcnt loop where V8's
+ * scalar code can't compete with the explicit 4-lane stride.
+ */
+function deserializeNarrowIntegerArray_SWAR<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+
+  // Worst-case sizing: every element is at least 1 digit + 1 delimiter = 2
+  // UTF-16 chars = 4 bytes, so the body inside `[...]` can't hold more than
+  // `(srcEnd - srcStart) / 4` elements. AS skips zero-fill on `length=` for
+  // unmanaged element types, so over-allocation is essentially free here
+  // and saves a full SWAR pass over the input.
+  const maxElements = i32((<usize>(srcEnd - srcStart)) >> 2);
+  if (maxElements > 0) out.length = maxElements;
+  const dataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
+  let writePtr = dataStart;
+
+  while (srcStart < srcEnd) {
+    // Fast paths: 1-, 2-, or 3-digit unsigned element followed by `,` packs
+    // into one u64 load (covers ~100% of the typical 0..255 cycle). Ordered
+    // 3 -> 2 -> 1 because 3-digit values dominate any wide-range payload;
+    // the 2- and 1-digit branches cover the rest of `out`.
+    if (!isSigned<valueof<T>>() && srcStart + 6 < srcEnd) {
+      const block = load<u64>(srcStart);
+      if (((block >> 48) & 0xffff) == COMMA) {
+        const digits = (block & 0x0000_00ff_00ff_00ff) - 0x0000_0030_0030_0030;
+        const oor =
+          (digits | (digits + 0x0000_0006_0006_0006)) & 0x0000_fff0_fff0_fff0;
+        if (oor == 0) {
+          const d0 = <u32>(digits & 0xffff);
+          const d1 = <u32>((digits >> 16) & 0xffff);
+          const d2 = <u32>((digits >> 32) & 0xffff);
+          store<valueof<T>>(writePtr, <valueof<T>>(d0 * 100 + d1 * 10 + d2));
+          writePtr += elementSize;
+          srcStart += 8;
+          continue;
+        }
+      } else if (((block >> 32) & 0xffff) == COMMA) {
+        const digits = (block & 0x0000_0000_00ff_00ff) - 0x0000_0000_0030_0030;
+        const oor =
+          (digits | (digits + 0x0000_0000_0006_0006)) & 0x0000_0000_fff0_fff0;
+        if (oor == 0) {
+          const d0 = <u32>(digits & 0xffff);
+          const d1 = <u32>((digits >> 16) & 0xffff);
+          store<valueof<T>>(writePtr, <valueof<T>>(d0 * 10 + d1));
+          writePtr += elementSize;
+          srcStart += 6;
+          continue;
+        }
+      } else if (((block >> 16) & 0xffff) == COMMA) {
+        const d0 = <u32>(block & 0xffff) - 48;
+        if (d0 <= 9) {
+          store<valueof<T>>(writePtr, <valueof<T>>d0);
+          writePtr += elementSize;
+          srcStart += 4;
+          continue;
+        }
+      }
+    }
+    const code = load<u16>(srcStart);
+    if (<u32>code - 48 <= 9 || (isSigned<valueof<T>>() && code == 45)) {
+      const lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const c = load<u16>(srcStart);
+        if (c == COMMA || c == BRACKET_RIGHT || isSpace(c)) {
+          let value: u64 = 0;
+          let p = lastIndex;
+          if (isSigned<valueof<T>>() && load<u16>(p) == 45) {
+            p += 2;
+            while (p < srcStart) {
+              value = value * 10 + (<u32>load<u16>(p) - 48);
+              p += 2;
+            }
+            store<valueof<T>>(writePtr, <valueof<T>>-(<i64>value));
+          } else {
+            while (p < srcStart) {
+              value = value * 10 + (<u32>load<u16>(p) - 48);
+              p += 2;
+            }
+            store<valueof<T>>(writePtr, <valueof<T>>value);
+          }
+          writePtr += elementSize;
+          break;
+        }
+        srcStart += 2;
+      }
+    }
+    srcStart += 2;
+  }
+
+  out.length = i32(<usize>(writePtr - dataStart) / elementSize);
+  return out;
+}
+
 
-@inline export function deserializeIntegerArrayInto<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline export function deserializeIntegerArrayInto<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   let index = 0;
 
   do {
@@ -439,7 +673,9 @@ export function deserializeIntegerArray_SWAR<T extends number[]>(srcStart: usize
 
     while (srcStart < srcEnd) {
       const slot = ensureArrayElementSlot<T>(out, index);
-      srcStart = isSigned<valueof<T>>() ? deserializeIntegerField<valueof<T>>(srcStart, srcEnd, slot) : deserializeUnsignedField<valueof<T>>(srcStart, srcEnd, slot);
+      srcStart = isSigned<valueof<T>>()
+        ? deserializeIntegerField<valueof<T>>(srcStart, srcEnd, slot)
+        : deserializeUnsignedField<valueof<T>>(srcStart, srcEnd, slot);
       if (!srcStart || srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
@@ -460,6 +696,14 @@ export function deserializeIntegerArray_SWAR<T extends number[]>(srcStart: usize
 }
 
 
-@inline export function deserializeIntegerArrayField<T extends number[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  return deserializeIntegerArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+@inline export function deserializeIntegerArrayField<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
+  return deserializeIntegerArrayInto<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
 }

package/assembly/deserialize/swar/array/map.ts

@@ -1,7 +1,11 @@
 import { ensureArrayField } from "./shared";
 
 
-@inline export function deserializeMapArrayField<T extends Map<any, any>[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+@inline export function deserializeMapArrayField<T extends Map<any, any>[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
   ensureArrayField<T>(fieldPtr);
   throw new Error("Failed to parse JSON!");
 }

package/assembly/deserialize/swar/array/object.ts

@@ -2,7 +2,11 @@ import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
 
-@inline export function deserializeObjectArrayInto<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline export function deserializeObjectArrayInto<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   let index = 0;
 
   do {
@@ -18,7 +22,9 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
       const slot = ensureArrayElementSlot<T>(out, index);
       let value = load<valueof<T>>(slot);
       if (changetype<usize>(value) == 0) {
-        value = changetype<valueof<T>>(__new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<valueof<T>>>()));
+        value = changetype<valueof<T>>(
+          __new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<valueof<T>>>()),
+        );
         // @ts-ignore: supplied by transform
         if (isDefined(changetype<nonnull<valueof<T>>>(value).__INITIALIZE)) {
           // @ts-ignore: supplied by transform
@@ -29,12 +35,18 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
       const valueStart = srcStart;
       // @ts-ignore: supplied by transform
-      if (isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)) {
+      if (
+        isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)
+      ) {
         // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<valueof<T>>(valueStart, srcEnd, value);
+        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<
+          valueof<T>
+        >(valueStart, srcEnd, value);
       } else {
         // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<valueof<T>>(valueStart, srcEnd, value);
+        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<
+          valueof<T>
+        >(valueStart, srcEnd, value);
       }
       if (!srcStart || srcStart >= srcEnd) break;
 
@@ -56,6 +68,14 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 }
 
 
-@inline export function deserializeObjectArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  return deserializeObjectArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+@inline export function deserializeObjectArrayField<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
+  return deserializeObjectArrayInto<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
 }

package/assembly/deserialize/swar/array/raw.ts

@@ -2,7 +2,11 @@ import { JSON } from "../../..";
 import { ensureArrayField } from "./shared";
 
 
-@inline export function deserializeRawArrayField(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+@inline export function deserializeRawArrayField(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
   ensureArrayField<JSON.Raw[]>(fieldPtr);
   throw new Error("Failed to parse JSON!");
 }