json-as 1.3.6 → 1.3.8

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

@@ -1,7 +1,15 @@
+import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
 
-@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!");
+@inline export function deserializeMapArrayField<T extends Map<any, any>[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
+  return deserializeGenericArrayBody<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
 }

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

@@ -1,13 +1,24 @@
+import { JSON } from "../../..";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
-import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+import {
+  ensureArrayElementSlot,
+  ensureArrayField,
+  scanValueEnd,
+  skipWhitespace,
+} from "./shared";
 
 
-@inline export function deserializeObjectArrayInto<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline function deserializeObjectArrayBody<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   let index = 0;
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
+    srcStart = skipWhitespace(srcStart, srcEnd);
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -16,36 +27,29 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
     while (srcStart < srcEnd) {
       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>>>()));
-        // @ts-ignore: supplied by transform
-        if (isDefined(changetype<nonnull<valueof<T>>>(value).__INITIALIZE)) {
-          // @ts-ignore: supplied by transform
-          changetype<nonnull<valueof<T>>>(value).__INITIALIZE();
-        }
-        store<valueof<T>>(slot, value);
-      }
-
       const valueStart = srcStart;
-      // @ts-ignore: supplied by transform
-      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);
-      } else {
-        // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<valueof<T>>(valueStart, srcEnd, value);
-      }
-      if (!srcStart || srcStart >= srcEnd) break;
+      const valueEnd = scanValueEnd(valueStart, srcEnd);
+      if (!valueEnd) break;
+
+      const value = JSON.__deserialize<valueof<T>>(
+        valueStart,
+        valueEnd,
+        changetype<usize>(load<valueof<T>>(slot)),
+      );
+      store<valueof<T>>(slot, value);
+      srcStart = valueEnd;
 
+      srcStart = skipWhitespace(srcStart, srcEnd);
       const code = load<u16>(srcStart);
       if (code == COMMA) {
         srcStart += 2;
+        srcStart = skipWhitespace(srcStart, srcEnd);
         index++;
         continue;
       }
       if (code == BRACKET_RIGHT) {
-        out.length = index + 1;
+        const nextLen = index + 1;
+        if (out.length != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -56,6 +60,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 deserializeObjectArrayBody<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
 }

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

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

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

@@ -1,7 +1,25 @@
-import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA, QUOTE } from "../../../custom/chars";
+import {
+  BACK_SLASH,
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+  QUOTE,
+} from "../../../custom/chars";
+import { isSpace } from "../../../util";
+
+/** Advance past JSON whitespace (space, tab, LF, CR). */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function skipWhitespace(srcStart: usize, srcEnd: usize): usize {
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  return srcStart;
+}
 
 
-@inline export function ensureArrayField<T extends Array<any>>(fieldPtr: usize): T {
+@inline export function ensureArrayField<T extends Array<any>>(
+  fieldPtr: usize,
+): T {
   let out = load<T>(fieldPtr);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
@@ -11,7 +29,10 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 }
 
 
-@inline export function ensureArrayFieldAt<T extends Array<any>>(dstObj: usize, dstOffset: usize): T {
+@inline export function ensureArrayFieldAt<T extends Array<any>>(
+  dstObj: usize,
+  dstOffset: usize,
+): T {
   let out = load<T>(dstObj, dstOffset);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
@@ -24,25 +45,43 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 @inline function backslashOrQuoteMask(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;
+  return (
+    (((q - 0x0001_0001_0001_0001) & ~q) | ((b - 0x0001_0001_0001_0001) & ~b)) &
+    0x0080_0080_0080_0080
+  );
 }
 
 
-@inline export function ensureArrayElementSlot<T extends Array<any>>(out: T, index: i32): usize {
+@inline export function ensureArrayElementSlot<T extends Array<any>>(
+  out: T,
+  index: i32,
+): usize {
   const nextLength = index + 1;
   if (out.length < nextLength) {
-    out.length = nextLength;
-    const slot = out.dataStart + <usize>index * sizeof<valueof<T>>();
-    // Reference arrays can allocate recursively before the caller stores the new element.
-    // Zero the newly exposed slot immediately so incremental GC never observes a garbage pointer.
-    if (isManaged<valueof<T>>() || isReference<valueof<T>>()) store<usize>(slot, 0);
-    return slot;
+    // Grow via `push`, not `out.length = nextLength`. AS's `length=`
+    // setter calls `ensureCapacity(canGrow=false)` which reallocates to
+    // *exactly* the requested size — fine for a one-shot resize, but
+    // catastrophic in the per-element loop (every push triggers a full
+    // copy of the array, giving O(N²) growth cost). `push` goes through
+    // `canGrow=true`, doubling capacity geometrically as needed.
+    //
+    // We push a zero-bit default: `0` for primitives, the null reference
+    // for managed/reference element types. The caller overwrites this
+    // slot immediately, so the placeholder is never observed.
+    if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+      out.push(changetype<valueof<T>>(0));
+    } else {
+      out.push(<valueof<T>>0);
+    }
   }
   return out.dataStart + <usize>index * sizeof<valueof<T>>();
 }
 
 
-@inline export function scanQuotedValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
+@inline export function scanQuotedValueEnd_SWAR(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
   srcStart += 2;
   const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
 
@@ -67,7 +106,8 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 
   while (srcStart < srcEnd) {
     const char = load<u16>(srcStart);
-    if (char == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH) return srcStart + 2;
+    if (char == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)
+      return srcStart + 2;
     srcStart += 2;
   }
 
@@ -103,7 +143,16 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
-    if (code == COMMA || code == BRACKET_RIGHT || code == BRACE_RIGHT) return srcStart;
+    // Stop at the structural terminator OR trailing whitespace, so the returned
+    // range is the exact value (scalar parsers assume no trailing whitespace).
+    // Callers skip whitespace to reach the following `,`/`]`/`}`.
+    if (
+      code == COMMA ||
+      code == BRACKET_RIGHT ||
+      code == BRACE_RIGHT ||
+      isSpace(code)
+    )
+      return srcStart;
     srcStart += 2;
   }
 

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

@@ -1,14 +1,34 @@
-import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import {
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+  NULL_WORD_U64,
+} from "../../../custom/chars";
+import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 import { deserializeStringField_SWAR } from "../string";
 
 
-@inline export function deserializeStringArrayInto<T extends string[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline function skipStringArrayWhitespace(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  return srcStart;
+}
+
+
+@inline function deserializeStringArrayBody<T extends string[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   let index = 0;
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
+    srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -17,17 +37,41 @@ import { deserializeStringField_SWAR } from "../string";
 
     while (srcStart < srcEnd) {
       const slot = ensureArrayElementSlot<T>(out, index);
-      srcStart = deserializeStringField_SWAR<valueof<T>>(srcStart, srcEnd, slot);
-      if (!srcStart || srcStart >= srcEnd) break;
+      // Null fast path for `(string | null)[]`. "null" is 4 UTF-16 chars
+      // = 8 bytes, exactly one u64 compare. Store 0 (the AS null reference)
+      // and skip 8 bytes.
+      //
+      // We accept null tokens unconditionally rather than gating on
+      // `isNullable<valueof<T>>()` — AS's `valueof` of a nullable-array
+      // element type doesn't always preserve the nullable marker through
+      // the dispatcher's `<T>` cast, so the gate would mis-fire for the
+      // very case it's meant to handle. The runtime cost on plain
+      // `string[]` arrays is one extra u64 compare per element; a
+      // well-formed `string[]` input never matches it.
+      if (srcStart + 8 <= srcEnd && load<u64>(srcStart) == NULL_WORD_U64) {
+        store<usize>(slot, 0);
+        srcStart += 8;
+      } else {
+        srcStart = deserializeStringField_SWAR<valueof<T>>(
+          srcStart,
+          srcEnd,
+          slot,
+        );
+      }
+      if (!srcStart) break;
+      srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
+      if (srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
       if (code == COMMA) {
         srcStart += 2;
+        srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
         index++;
         continue;
       }
       if (code == BRACKET_RIGHT) {
-        out.length = index + 1;
+        const nextLen = index + 1;
+        if (out.length != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -38,6 +82,95 @@ import { deserializeStringField_SWAR } from "../string";
 }
 
 
-@inline export function deserializeStringArrayField<T extends string[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  return deserializeStringArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+@inline export function deserializeStringArrayField<T extends string[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
+  return deserializeStringArrayBody<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
+}
+
+// Top-level entry for `JSON.parse<string[]>` / `JSON.parse<(string | null)[]>`.
+//
+// Pre-grows the destination array to a worst-case bound in one allocation,
+// then writes elements via `writePtr` direct stores. This sidesteps the
+// per-element growth cost of `deserializeStringArrayBody`'s
+// `ensureArrayElementSlot` path. The incremental runtime zero-initializes
+// new allocations, so `null` slots need no per-element store on cold
+// arrays (we still write 0 to handle reused arrays whose old refs would
+// otherwise leak through).
+export function deserializeStringArray_SWAR<T extends string[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+
+  // Worst-case sizing: shortest possible element is `""` followed by `,` =
+  // 6 UTF-16 bytes, so `(srcLen + 5) / 6` upper-bounds the count. Clamp to
+  // AS's BLOCK_MAXSIZE / sizeof<string ref> = (1<<28) - 4 elements; payloads
+  // that exceed this would fail the `out.length =` setter anyway. For a
+  // 1 GiB UTF-16 source that maxes at ~256M slot allocation = ~1 GiB.
+  const elementSize: usize = sizeof<usize>();
+  const maxBlockElements: i32 = i32((<usize>0x40000000 - 16) / elementSize);
+  let maxElements: i32 = i32((<usize>(srcEnd - srcStart) + 5) / 6);
+  if (maxElements < 0 || maxElements > maxBlockElements) {
+    maxElements = maxBlockElements;
+  }
+  if (out.length < maxElements) out.length = maxElements;
+
+  const dataStart: usize = out.dataStart;
+  let writePtr: usize = dataStart;
+  const writePtrLimit: usize = dataStart + <usize>maxElements * elementSize;
+
+  // Caller guarantees srcStart is at the opening `[`.
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) {
+    out.length = 0;
+    return out;
+  }
+  srcStart += 2;
+  srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
+  if (srcStart < srcEnd && load<u16>(srcStart) == BRACKET_RIGHT) {
+    out.length = 0;
+    return out;
+  }
+
+  while (srcStart < srcEnd && writePtr < writePtrLimit) {
+    // Null fast path: one u64 compare.
+    if (srcStart + 8 <= srcEnd && load<u64>(srcStart) == NULL_WORD_U64) {
+      store<usize>(writePtr, 0);
+      srcStart += 8;
+    } else {
+      srcStart = deserializeStringField_SWAR<valueof<T>>(
+        srcStart,
+        srcEnd,
+        writePtr,
+      );
+      if (!srcStart) break;
+    }
+    writePtr += elementSize;
+    srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
+    if (srcStart >= srcEnd) break;
+
+    const code = load<u16>(srcStart);
+    if (code == COMMA) {
+      srcStart += 2;
+      srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
+      continue;
+    }
+    if (code == BRACKET_RIGHT) {
+      const finalLen = i32(<usize>(writePtr - dataStart) / elementSize);
+      if (out.length != finalLen) out.length = finalLen;
+      return out;
+    }
+    break;
+  }
+
+  throw new Error("Failed to parse JSON!");
 }

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

@@ -1,13 +1,42 @@
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
 
-@inline export function deserializeStructArrayInto<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline function skipStructArrayWhitespace(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  return srcStart;
+}
+
+// Per-element worker for `@json class Foo[]` fields. Each element is a
+// managed reference whose value is produced by the transform-generated
+// `__DESERIALIZE_FAST` / `__DESERIALIZE_SLOW` methods, so the loop pattern
+// is structurally different from primitive-array bodies:
+//
+//   - The slot stores a *reference*; reused arrays may already hold an
+//     allocated instance whose fields we just overwrite. Only allocate +
+//     `__INITIALIZE` when the slot is null.
+//   - `__DESERIALIZE_FAST` returns the cursor past the closing `}` on
+//     success, or `0` to signal "bail to slow path". We mirror the
+//     dispatcher in `JSON.__deserialize` here: try FAST first, fall back
+//     to SLOW on `0`.
+//   - Whitespace is skipped at each separator boundary so struct-array
+//     fields tolerate the same `[ {...} , {...} ]` shape that top-level
+//     `JSON.parse` does.
+@inline function deserializeStructArrayBody<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   let index = 0;
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
+    srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -18,7 +47,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
@@ -27,25 +58,40 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
         store<valueof<T>>(slot, value);
       }
 
-      const valueStart = srcStart;
-      // @ts-ignore: supplied by transform
-      if (isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)) {
+      let next: usize = 0;
+      if (
         // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<valueof<T>>(valueStart, srcEnd, value);
-      } else {
+        isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)
+      ) {
+        // @ts-ignore: supplied by transform
+        next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<
+          valueof<T>
+        >(srcStart, srcEnd, value);
+      }
+      if (!next) {
         // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<valueof<T>>(valueStart, srcEnd, value);
+        next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<
+          valueof<T>
+        >(srcStart, srcEnd, value);
       }
-      if (!srcStart || srcStart >= srcEnd) break;
+      if (!next) break;
+      srcStart = next;
+      srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+      if (srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
       if (code == COMMA) {
         srcStart += 2;
+        srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
         index++;
         continue;
       }
       if (code == BRACKET_RIGHT) {
-        out.length = index + 1;
+        // Skip `ensureCapacity` when the reused array already has the
+        // right length (e.g. canada-style geometry rings whose count
+        // matches a previous parse).
+        const nextLen = index + 1;
+        if (out.length != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -56,6 +102,14 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 }
 
 
-@inline export function deserializeStructArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  return deserializeStructArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+@inline export function deserializeStructArrayField<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
+  return deserializeStructArrayBody<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
 }

package/assembly/deserialize/swar/array.ts

@@ -11,17 +11,16 @@ import { deserializeObjectArrayField } from "./array/object";
 import { deserializeRawArrayField } from "./array/raw";
 import { deserializeStringArrayField } from "./array/string";
 import { deserializeStructArrayField } from "./array/struct";
-import { deserializeArrayArrayInto } from "./array/array";
-import { deserializeBooleanArrayInto } from "./array/bool";
-import { deserializeFloatArrayInto } from "./array/float";
-import { deserializeGenericArrayInto } from "./array/generic";
-import { deserializeIntegerArrayInto } from "./array/integer";
-import { deserializeObjectArrayInto } from "./array/object";
-import { deserializeStringArrayInto } from "./array/string";
-import { deserializeStructArrayInto } from "./array/struct";
 
+export { deserializeArrayField as deserializeArrayField_SWAR };
 
-@inline export function deserializeArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+
+@inline export function deserializeArrayField<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
   const fieldPtr = dstObj + dstOffset;
   if (isString<valueof<T>>()) {
     return deserializeStringArrayField<T>(srcStart, srcEnd, fieldPtr);
@@ -53,7 +52,10 @@ import { deserializeStructArrayInto } from "./array/struct";
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
       return deserializeStructArrayField<T>(srcStart, srcEnd, fieldPtr);
       // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
+    } else if (
+      isDefined(type.__DESERIALIZE_SLOW) ||
+      isDefined(type.__DESERIALIZE_FAST)
+    ) {
       return deserializeStructArrayField<T>(srcStart, srcEnd, fieldPtr);
     }
     throw new Error("Could not parse array field of type " + nameof<T>() + "!");
@@ -61,44 +63,3 @@ import { deserializeStructArrayInto } from "./array/struct";
     throw new Error("Could not parse array field of type " + nameof<T>() + "!");
   }
 }
-
-
-@inline export function deserializeArrayInto_SWAR<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
-  if (isString<valueof<T>>()) {
-    return deserializeStringArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isBoolean<valueof<T>>()) {
-    return deserializeBooleanArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isInteger<valueof<T>>()) {
-    return deserializeIntegerArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isFloat<valueof<T>>()) {
-    return deserializeFloatArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isArray<valueof<T>>()) {
-    return deserializeArrayArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
-    const type = changetype<nonnull<valueof<T>>>(0);
-    if (type instanceof JSON.Value) {
-      return deserializeGenericArrayInto<T>(srcStart, srcEnd, out);
-    } else if (type instanceof JSON.Box) {
-      throw new Error("Failed to parse JSON!");
-    } else if (type instanceof JSON.Obj) {
-      return deserializeObjectArrayInto<T>(srcStart, srcEnd, out);
-    } else if (type instanceof JSON.Raw) {
-      throw new Error("Failed to parse JSON!");
-    } else if (type instanceof Date) {
-      return deserializeGenericArrayInto<T>(srcStart, srcEnd, out);
-    } else if (type instanceof Set) {
-      return deserializeGenericArrayInto<T>(srcStart, srcEnd, out);
-    } else if (type instanceof Map) {
-      throw new Error("Failed to parse JSON!");
-      // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
-      return deserializeStructArrayInto<T>(srcStart, srcEnd, out);
-      // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
-      return deserializeStructArrayInto<T>(srcStart, srcEnd, out);
-    }
-    throw new Error("Could not parse array field of type " + nameof<T>() + "!");
-  } else {
-    throw new Error("Could not parse array field of type " + nameof<T>() + "!");
-  }
-}