json-as 1.3.5 → 1.3.7

package/assembly/deserialize/simd/integer.ts

@@ -0,0 +1,233 @@
+// SIMD integer deserializers (signed + unsigned) over UTF-16 sources.
+//
+// Consume-to-end paths use the full tiered hierarchy:
+//
+// - parse16_SIMD (32 bytes / 16 digits): best for long inputs
+// - parse8_SIMD  (16 bytes /  8 digits)
+// - parse4_SWAR  ( 8 bytes /  4 digits): SWAR is fine for short tails
+// - scalar       ( 2 bytes /  1 digit )
+//
+// Scan paths use the same asymmetric tuning as the SWAR version:
+//
+// - Unsigned scan: parse8_SIMD + scalar (no parse4).
+// - Signed scan: parse4_SWAR + scalar (no parse8). After the leading
+//   minus, the digit run lands in parse8's "terminator-in-load" boundary
+//   zone.
+//
+// Requires `--enable simd` at compile time. Dead-code-eliminated when
+// JSON_MODE != SIMD.
+
+import {
+  parse4Digits_PairMul,
+  parse4Digits_PairMul_Unsafe,
+} from "../../util/swar-int";
+import {
+  parse8Digits_SIMD,
+  parse8Digits_SIMD_Unsafe,
+  parse16Digits_SIMD,
+  parse16Digits_SIMD_Unsafe,
+} from "../../util/simd-int";
+
+const ASCII_MINUS: u16 = 45;
+const ASCII_ZERO: u16 = 48;
+
+/**
+ * Store a signed value into a typed integer field, truncating to `T`'s width.
+ *
+ * @param dstPtr Destination pointer (already includes any field offset).
+ * @param value  The `u64` accumulator, interpreted as a two's-complement
+ *               signed integer for narrower types.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline function storeSignedToField<T extends number>(
+  dstPtr: usize,
+  value: u64,
+): void {
+  if (sizeof<T>() == 1) {
+    store<i8>(dstPtr, <i8>value);
+  } else if (sizeof<T>() == 2) {
+    store<i16>(dstPtr, <i16>value);
+  } else if (sizeof<T>() == 4) {
+    store<i32>(dstPtr, <i32>value);
+  } else {
+    store<i64>(dstPtr, <i64>value);
+  }
+}
+
+/**
+ * Store an unsigned value into a typed integer field, truncating to `T`'s
+ * width.
+ *
+ * @param dstPtr Destination pointer (already includes any field offset).
+ * @param value  The `u64` accumulator.
+ */
+// @ts-expect-error: decorator valid here
+@inline function storeUnsignedToField<T extends number>(
+  dstPtr: usize,
+  value: u64,
+): void {
+  if (sizeof<T>() == 1) {
+    store<u8>(dstPtr, <u8>value);
+  } else if (sizeof<T>() == 2) {
+    store<u16>(dstPtr, <u16>value);
+  } else if (sizeof<T>() == 4) {
+    store<u32>(dstPtr, <u32>value);
+  } else {
+    store<u64>(dstPtr, value);
+  }
+}
+
+/**
+ * Parse a signed integer by consuming the entire `[srcStart, srcEnd)` range
+ * as a digit run, with an optional leading `-`.
+ *
+ * Caller guarantees the range is well-formed. Uses the unsafe SIMD kernels
+ * with no per-stride validation.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @param srcEnd   Pointer just past the last code unit.
+ * @returns The parsed value, two's-complement truncated to `T`.
+ */
+// @ts-expect-error: decorator valid here
+@inline export function deserializeInteger_SIMD<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  let negative = false;
+  if (srcStart < srcEnd && load<u16>(srcStart) == ASCII_MINUS) {
+    negative = true;
+    srcStart += 2;
+  }
+  let value: u64 = 0;
+  while (srcStart + 30 < srcEnd) {
+    value =
+      value * 10_000_000_000_000_000 + parse16Digits_SIMD_Unsafe(srcStart);
+    srcStart += 32;
+  }
+  while (srcStart + 14 < srcEnd) {
+    value = value * 100_000_000 + parse8Digits_SIMD_Unsafe(srcStart);
+    srcStart += 16;
+  }
+  while (srcStart + 6 < srcEnd) {
+    value = value * 10_000 + parse4Digits_PairMul_Unsafe(load<u64>(srcStart));
+    srcStart += 8;
+  }
+  while (srcStart < srcEnd) {
+    value = value * 10 + (<u32>load<u16>(srcStart) - ASCII_ZERO);
+    srcStart += 2;
+  }
+  return <T>(negative ? 0 - value : value);
+}
+
+/**
+ * Scan for a signed integer field, stopping at the first non-digit
+ * character. Writes the parsed value through `dstObj + dstOffset` 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 dstObj    Destination object pointer.
+ * @param dstOffset Byte offset of the field within `dstObj`.
+ * @returns The source position immediately after the last digit consumed.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeIntegerField_SIMD<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  let negative = false;
+  if (srcStart < srcEnd && load<u16>(srcStart) == ASCII_MINUS) {
+    negative = true;
+    srcStart += 2;
+  }
+  let value: u64 = 0;
+  // Signed scan uses parse4 + scalar only (see file header).
+  while (srcStart + 6 < srcEnd) {
+    const parsed = parse4Digits_PairMul(load<u64>(srcStart));
+    if (parsed == U32.MAX_VALUE) break;
+    value = value * 10_000 + parsed;
+    srcStart += 8;
+  }
+  while (srcStart < srcEnd) {
+    const digit = <u32>load<u16>(srcStart) - ASCII_ZERO;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+  storeSignedToField<T>(dstObj + dstOffset, negative ? 0 - value : value);
+  return srcStart;
+}
+
+/**
+ * Parse an unsigned integer by consuming the entire `[srcStart, srcEnd)`
+ * range as a digit run.
+ *
+ * Caller guarantees the range is digits only. Uses the unsafe SIMD kernels.
+ *
+ * @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 deserializeUnsigned_SIMD<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  let value: u64 = 0;
+  while (srcStart + 30 < srcEnd) {
+    value =
+      value * 10_000_000_000_000_000 + parse16Digits_SIMD_Unsafe(srcStart);
+    srcStart += 32;
+  }
+  while (srcStart + 14 < srcEnd) {
+    value = value * 100_000_000 + parse8Digits_SIMD_Unsafe(srcStart);
+    srcStart += 16;
+  }
+  while (srcStart + 6 < srcEnd) {
+    value = value * 10_000 + parse4Digits_PairMul_Unsafe(load<u64>(srcStart));
+    srcStart += 8;
+  }
+  while (srcStart < srcEnd) {
+    value = value * 10 + (<u32>load<u16>(srcStart) - ASCII_ZERO);
+    srcStart += 2;
+  }
+  return <T>value;
+}
+
+/**
+ * Scan for an unsigned integer field, stopping at the first non-digit
+ * character. Writes the parsed value through `dstObj + dstOffset` 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 dstObj    Destination object pointer.
+ * @param dstOffset Byte offset of the field within `dstObj`.
+ * @returns The source position immediately after the last digit consumed.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeUnsignedField_SIMD<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  let value: u64 = 0;
+  // Unsigned scan uses parse8 + scalar only (see file header).
+  while (srcStart + 14 < srcEnd) {
+    const parsed = parse8Digits_SIMD(srcStart);
+    if (parsed == U32.MAX_VALUE) break;
+    value = value * 100_000_000 + parsed;
+    srcStart += 16;
+  }
+  while (srcStart < srcEnd) {
+    const digit = <u32>load<u16>(srcStart) - ASCII_ZERO;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+  storeUnsignedToField<T>(dstObj + dstOffset, value);
+  return srcStart;
+}

package/assembly/deserialize/simd/string.ts

@@ -3,7 +3,10 @@ import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { __heap_base } from "memory";
 import { QUOTE } from "../../custom/chars";
 import { BACK_SLASH } from "../../custom/chars";
-import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
+import {
+  DESERIALIZE_ESCAPE_TABLE,
+  ESCAPE_HEX_TABLE,
+} from "../../globals/tables";
 import { hex4_to_u16_swar } from "../../util/swar";
 import { deserializeStringField_SWAR } from "../swar/string";
 
@@ -65,7 +68,10 @@ import { deserializeStringField_SWAR } from "../swar/string";
  * @returns number of bytes written
  */
 // @ts-expect-error: @inline is a valid decorator
-@inline function copyStringFromSource_SIMD(srcStart: usize, byteLength: usize): string {
+@inline function copyStringFromSource_SIMD(
+  srcStart: usize,
+  byteLength: usize,
+): string {
   if (byteLength == 0) return changetype<string>("");
   // @ts-expect-error: __new is a runtime builtin
   const out = __new(byteLength, idof<string>());
@@ -74,7 +80,11 @@ import { deserializeStringField_SWAR } from "../swar/string";
 }
 
 // @ts-expect-error: @inline is a valid decorator
-@inline function writeStringToField_SIMD(dstFieldPtr: usize, srcStart: usize, byteLength: u32): void {
+@inline function writeStringToField_SIMD(
+  dstFieldPtr: usize,
+  srcStart: usize,
+  byteLength: u32,
+): void {
   if (byteLength == 0) {
     store<usize>(dstFieldPtr, changetype<usize>(""));
     return;
@@ -100,7 +110,11 @@ import { deserializeStringField_SWAR } from "../swar/string";
 
 // todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
 // @ts-expect-error: @inline is a valid decorator
-@inline function deserializeEscapedString_SIMD(payloadStart: usize, escapeStart: usize, srcEnd: usize): string {
+@inline function deserializeEscapedString_SIMD(
+  payloadStart: usize,
+  escapeStart: usize,
+  srcEnd: usize,
+): string {
   const prefixLen = <u32>(escapeStart - payloadStart);
   let srcStart = escapeStart;
   const srcEnd16 = srcEnd - 16;
@@ -238,12 +252,16 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
     }
 
     const laneIdx = usize(ctz(mask) << 1);
-    return inline.always(deserializeEscapedString_SIMD(payloadStart, srcStart + laneIdx, srcEnd));
+    return inline.always(
+      deserializeEscapedString_SIMD(payloadStart, srcStart + laneIdx, srcEnd),
+    );
   }
 
   while (srcStart < srcEnd) {
     if (load<u16>(srcStart) == BACK_SLASH) {
-      return inline.always(deserializeEscapedString_SIMD(payloadStart, srcStart, srcEnd));
+      return inline.always(
+        deserializeEscapedString_SIMD(payloadStart, srcStart, srcEnd),
+      );
     }
     srcStart += 2;
   }
@@ -252,9 +270,15 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 }
 
 // @ts-expect-error: @inline is a valid decorator
-@inline export function deserializeStringField_SIMD<T extends string | null>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+@inline export function deserializeStringField_SIMD<T extends string | null>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
   const dstFieldPtr = dstObj + dstOffset;
-  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) abort("Expected leading quote");
+  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE)
+    abort("Expected leading quote");
 
   const quotedStart = srcStart;
   const payloadStart = srcStart + 2;
@@ -263,7 +287,9 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 
   while (srcStart <= srcEnd16) {
     const block = load<v128>(srcStart);
-    let mask = i16x8.bitmask(v128.or(i16x8.eq(block, SPLAT_5C), i16x8.eq(block, SPLAT_22)));
+    let mask = i16x8.bitmask(
+      v128.or(i16x8.eq(block, SPLAT_5C), i16x8.eq(block, SPLAT_22)),
+    );
 
     if (mask == 0) {
       srcStart += 16;
@@ -277,7 +303,11 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
       const char = load<u16>(srcIdx);
 
       if (char == QUOTE) {
-        writeStringToField_SIMD(dstFieldPtr, payloadStart, <u32>(srcIdx - payloadStart));
+        writeStringToField_SIMD(
+          dstFieldPtr,
+          payloadStart,
+          <u32>(srcIdx - payloadStart),
+        );
         return srcIdx + 2;
       }
 
@@ -292,7 +322,11 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
   while (srcStart < srcEnd) {
     const char = load<u16>(srcStart);
     if (char == QUOTE) {
-      writeStringToField_SIMD(dstFieldPtr, payloadStart, <u32>(srcStart - payloadStart));
+      writeStringToField_SIMD(
+        dstFieldPtr,
+        payloadStart,
+        <u32>(srcStart - payloadStart),
+      );
       return srcStart + 2;
     }
     if (char == BACK_SLASH) {

package/assembly/deserialize/simple/arbitrary.ts

@@ -6,15 +6,22 @@ import { deserializeString } from "./string";
 import { deserializeObject } from "./object";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";
 
-export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value {
+export function deserializeArbitrary(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): JSON.Value {
   const firstChar = load<u16>(srcStart);
   if (firstChar == QUOTE) {
     return JSON.Value.from(deserializeString(srcStart, srcEnd));
-  } else if (firstChar == BRACE_LEFT) return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
-  else if (firstChar - 48 <= 9 || firstChar == 45) return JSON.Value.from(deserializeFloat<f64>(srcStart, srcEnd));
+  } else if (firstChar == BRACE_LEFT)
+    return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
+  else if (firstChar - 48 <= 9 || firstChar == 45)
+    return JSON.Value.from(deserializeFloat<f64>(srcStart, srcEnd));
   else if (firstChar == BRACKET_LEFT) {
     return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, 0));
-  } else if (firstChar == 116 || firstChar == 102) return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
+  } else if (firstChar == 116 || firstChar == 102)
+    return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
   else if (firstChar == CHAR_N) {
     const value = JSON.Value.from<usize>(0);
     return value;

package/assembly/deserialize/simple/array/arbitrary.ts

@@ -1,10 +1,27 @@
-import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, CHAR_F, CHAR_N, CHAR_T, COMMA, QUOTE } from "../../../custom/chars";
+import {
+  BACK_SLASH,
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  CHAR_F,
+  CHAR_N,
+  CHAR_T,
+  COMMA,
+  QUOTE,
+} from "../../../custom/chars";
 import { JSON } from "../../../";
 import { isSpace, scanStringEnd } from "../../../util";
 import { ptrToStr } from "../../../util/ptrToStr";
 
-export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value[] {
-  const out = changetype<JSON.Value[]>(dst || changetype<usize>(instantiate<JSON.Value[]>()));
+export function deserializeArbitraryArray(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): JSON.Value[] {
+  const out = changetype<JSON.Value[]>(
+    dst || changetype<usize>(instantiate<JSON.Value[]>()),
+  );
   let lastIndex: usize = 0;
   let depth: u32 = 0;
   // if (load<u16>(srcStart) != BRACKET_LEFT)
@@ -31,7 +48,8 @@ export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: u
     } else if (code == QUOTE) {
       lastIndex = srcStart;
       srcStart = scanStringEnd(srcStart, srcEnd);
-      if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON array");
+      if (srcStart >= srcEnd)
+        throw new Error("Unterminated string in JSON array");
       // @ts-ignore: exists
       out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
       srcStart += 2;
@@ -78,7 +96,8 @@ export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: u
         const code = load<u16>(srcStart);
         if (code == QUOTE) {
           srcStart = scanStringEnd(srcStart, srcEnd);
-          if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON array");
+          if (srcStart >= srcEnd)
+            throw new Error("Unterminated string in JSON array");
         } else if (code == BRACKET_RIGHT) {
           if (--depth == 0) {
             // @ts-ignore: type

package/assembly/deserialize/simple/array/array.ts

@@ -1,8 +1,14 @@
 import { BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../../";
 
-export function deserializeArrayArray<T extends unknown[][]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+export function deserializeArrayArray<T extends unknown[][]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   let lastIndex: usize = 0;
   let depth: u32 = 0;
   srcStart += 2;

package/assembly/deserialize/simple/array/bool.ts

@@ -1,17 +1,48 @@
-export function deserializeBooleanArray<T extends boolean[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
-  srcStart += 2; // skip [
+import { FALSE_WORD_U64, TRUE_WORD_U64 } from "../../../custom/chars";
+
+/**
+ * Boolean-array deserializer (used by every JSON_MODE for top-level
+ * `JSON.parse<bool[]>`). Worst-case sizing is one element per `"true,"` =
+ * 10 UTF-16 bytes, so pre-allocating `(srcEnd - srcStart) / 10` slots
+ * upper-bounds the element count exactly once and lets the loop write
+ * through a direct pointer instead of `Array.push`.
+ *
+ * The token check itself is already SWAR-shaped: a single `u64` load
+ * matches all four chars of `true`, and the `false` case adds one `u16`
+ * load to confirm the trailing `e`.
+ */
+export function deserializeBooleanArray<T extends boolean[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+
+  // Worst case: every element is `true,` = 5 UTF-16 chars = 10 bytes.
+  // `bool` is unmanaged so AS skips zero-fill on `length=`, making the
+  // over-allocation essentially free.
+  const maxElements = i32(<usize>(srcEnd - srcStart) / 10);
+  if (maxElements > 0) out.length = maxElements;
+  const dataStart = out.dataStart;
+  let writePtr = dataStart;
+
+  srcStart += 2; // skip `[`
   while (srcStart < srcEnd) {
     const block = load<u64>(srcStart);
-    if (block == 28429475166421108) {
-      out.push(true);
+    if (block == TRUE_WORD_U64) {
+      store<bool>(writePtr, true);
+      writePtr += 1;
       srcStart += 10;
-    } else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101) {
-      out.push(false);
+    } else if (block == FALSE_WORD_U64 && load<u16>(srcStart, 8) == 101) {
+      store<bool>(writePtr, false);
+      writePtr += 1;
       srcStart += 12;
     } else {
       srcStart += 2;
     }
   }
+  out.length = i32(writePtr - dataStart);
   return out;
 }

package/assembly/deserialize/simple/array/box.ts

@@ -2,8 +2,14 @@ import { isSpace } from "../../../util";
 import { COMMA, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 
-export function deserializeBoxArray<T extends JSON.Box<any>[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+export function deserializeBoxArray<T extends JSON.Box<any>[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   if (isBoolean<valueof<T>>()) {
     srcStart += 2; // skip [
     while (srcStart < srcEnd) {

package/assembly/deserialize/simple/array/float.ts

@@ -2,21 +2,46 @@ import { isSpace } from "../../../util";
 import { COMMA, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 
-export function deserializeFloatArray<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+/**
+ * Float-array deserializer (`f64[]` / `f32[]`).
+ *
+ * Worst-case sizing: every element is at least `D,` = 2 UTF-16 chars = 4
+ * bytes (a single-digit value followed by `,` or `]`). The `srcLen >> 2`
+ * upper bound holds even for valid JSON containing negative or fractional
+ * widths, because each element advance still consumes >= 4 bytes.
+ *
+ * f64/f32 are unmanaged so AS skips zero-fill on `length=`. The parse loop
+ * writes through a direct `writePtr` pointer, eliminating `Array.push`'s
+ * per-element capacity check + length write. Final `out.length` is trimmed
+ * to the actual element count.
+ */
+export function deserializeFloatArray<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+
+  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;
+
   let lastIndex: usize = 0;
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
-    if (code - 48 <= 9 || code == 45) {
+    if (<u32>code - 48 <= 9 || code == 45) {
       lastIndex = srcStart;
       srcStart += 2;
       while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
-          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
+        const c = load<u16>(srcStart);
+        if (c == COMMA || c == BRACKET_RIGHT || isSpace(c)) {
+          const value = JSON.__deserialize<valueof<T>>(lastIndex, srcStart);
+          store<valueof<T>>(writePtr, value);
+          writePtr += elementSize;
           break;
         }
         srcStart += 2;
@@ -24,5 +49,7 @@ export function deserializeFloatArray<T extends number[]>(srcStart: usize, srcEn
     }
     srcStart += 2;
   }
+
+  out.length = i32(<usize>(writePtr - dataStart) / elementSize);
   return out;
 }

package/assembly/deserialize/simple/array/generic.ts

@@ -3,15 +3,23 @@ import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { isSpace } from "../../../util";
 import { scanValueEnd } from "../../swar/array/shared";
 
-export function deserializeGenericArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+export function deserializeGenericArray<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   out.length = 0;
 
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
 
-  if (srcStart >= srcEnd) throw new Error("Input string had zero length or was all whitespace");
-  if (load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Expected '[' at start of array");
+  if (srcStart >= srcEnd)
+    throw new Error("Input string had zero length or was all whitespace");
+  if (load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Expected '[' at start of array");
   srcStart += 2;
 
   while (srcStart < srcEnd) {

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

@@ -1,8 +1,14 @@
 import { atoi, isSpace } from "../../../util";
 import { COMMA, BRACKET_RIGHT } from "../../../custom/chars";
 
-export function deserializeIntegerArray<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+export function deserializeIntegerArray<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
   let lastIndex: usize = 0;
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);