json-as 1.2.6 → 1.3.1

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

@@ -0,0 +1,461 @@
+import { deserializeIntegerField } from "../../integer";
+import { deserializeUnsignedField } from "../../unsigned";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { isSpace } from "../../../util";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+
+const ASCII_LANE_MASK_4: u64 = 0x00ff00ff00ff00ff;
+const ASCII_ZERO_4: u64 = 0x0030003000300030;
+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 {
+  if (sizeof<valueof<T>>() == sizeof<i8>()) {
+    store<i8>(slot, <i8>value);
+  } else if (sizeof<valueof<T>>() == sizeof<i16>()) {
+    store<i16>(slot, <i16>value);
+  } else if (sizeof<valueof<T>>() == sizeof<i32>()) {
+    store<i32>(slot, <i32>value);
+  } else if (sizeof<valueof<T>>() == sizeof<isize>()) {
+    store<isize>(slot, <isize>value);
+  } else {
+    store<i64>(slot, value);
+  }
+}
+
+
+@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>()) {
+    store<u16>(slot, <u16>value);
+  } else if (sizeof<valueof<T>>() == sizeof<u32>()) {
+    store<u32>(slot, <u32>value);
+  } else if (sizeof<valueof<T>>() == sizeof<usize>()) {
+    store<usize>(slot, <usize>value);
+  } else {
+    store<u64>(slot, value);
+  }
+}
+
+
+@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));
+}
+
+
+@inline function parseSignedIntegerScalar<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+  let negative = false;
+  let code = load<u16>(srcStart);
+  if (code == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) return 0;
+    code = load<u16>(srcStart);
+  }
+
+  let digit = <u32>code - 48;
+  if (digit > 9) return 0;
+
+  let value: u64 = digit;
+  srcStart += 2;
+  while (srcStart < srcEnd) {
+    digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+
+  pushSignedInteger<T>(out, negative ? -(<i64>value) : <i64>value);
+  return srcStart;
+}
+
+
+@inline function parseUnsignedIntegerScalar<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+  let digit = <u32>load<u16>(srcStart) - 48;
+  if (digit > 9) return 0;
+
+  let value: u64 = digit;
+  srcStart += 2;
+  while (srcStart < srcEnd) {
+    digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+
+  pushUnsignedInteger<T>(out, value);
+  return srcStart;
+}
+
+
+@inline function parseSignedIntegerSWAR<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+  let negative = false;
+  let code = load<u16>(srcStart);
+  if (code == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) return 0;
+    code = load<u16>(srcStart);
+  }
+
+  let digit = <u32>code - 48;
+  if (digit > 9) return 0;
+
+  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;
+  }
+
+  while (srcStart < srcEnd) {
+    digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+
+  pushSignedInteger<T>(out, negative ? -(<i64>value) : <i64>value);
+  return srcStart;
+}
+
+
+@inline function parseUnsignedIntegerSWAR<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+  let digit = <u32>load<u16>(srcStart) - 48;
+  if (digit > 9) return 0;
+
+  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;
+  }
+
+  while (srcStart < srcEnd) {
+    digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+
+  pushUnsignedInteger<T>(out, value);
+  return srcStart;
+}
+
+
+@inline function skipIntegerArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) {
+    srcStart += 2;
+  }
+  return srcStart;
+}
+
+// @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>()));
+  let index = 0;
+
+  out.length = 0;
+  srcStart = skipIntegerArrayWhitespace(srcStart, srcEnd);
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) {
+    throw new Error("Failed to parse JSON!");
+  }
+
+  srcStart += 2;
+  while (srcStart < srcEnd) {
+    srcStart = skipIntegerArrayWhitespace(srcStart, srcEnd);
+    if (srcStart >= srcEnd) break;
+
+    let code = load<u16>(srcStart);
+    if (code == BRACKET_RIGHT) return out;
+
+    if (isSigned<valueof<T>>()) {
+      let negative = false;
+      if (code == 45) {
+        negative = true;
+        srcStart += 2;
+        if (srcStart >= srcEnd) break;
+        code = load<u16>(srcStart);
+      }
+
+      let digit = <u32>code - 48;
+      if (digit > 9) break;
+
+      let value: u64 = digit;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        digit = <u32>load<u16>(srcStart) - 48;
+        if (digit > 9) break;
+        value = value * 10 + digit;
+        srcStart += 2;
+      }
+
+      storeSignedInteger<T>(ensureArrayElementSlot<T>(out, index), negative ? -(<i64>value) : <i64>value);
+    } else {
+      let digit = <u32>code - 48;
+      if (digit > 9) break;
+
+      let value: u64 = digit;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        digit = <u32>load<u16>(srcStart) - 48;
+        if (digit > 9) break;
+        value = value * 10 + digit;
+        srcStart += 2;
+      }
+
+      storeUnsignedInteger<T>(ensureArrayElementSlot<T>(out, index), value);
+    }
+
+    index++;
+    srcStart = skipIntegerArrayWhitespace(srcStart, srcEnd);
+    if (srcStart >= srcEnd) break;
+
+    code = load<u16>(srcStart);
+    if (code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACKET_RIGHT) return out;
+    break;
+  }
+
+  throw new Error("Failed to parse JSON!");
+}
+
+
+@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;
+
+  if (useSWAR && reusableLength != 0) {
+    const dataStart = out.dataStart;
+    let index = 0;
+
+    do {
+      if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+      srcStart += 2;
+      if (srcStart >= srcEnd) break;
+      if (load<u16>(srcStart) == BRACKET_RIGHT) {
+        out.length = 0;
+        return out;
+      }
+
+      if (isSigned<valueof<T>>()) {
+        while (srcStart < srcEnd) {
+          let negative = false;
+          let code = load<u16>(srcStart);
+          if (code == 45) {
+            negative = true;
+            srcStart += 2;
+            if (srcStart >= srcEnd) break;
+            code = load<u16>(srcStart);
+          }
+
+          let digit = <u32>code - 48;
+          if (digit > 9) break;
+
+          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;
+          }
+
+          while (srcStart < srcEnd) {
+            digit = <u32>load<u16>(srcStart) - 48;
+            if (digit > 9) break;
+            value = value * 10 + digit;
+            srcStart += 2;
+          }
+
+          if (index >= reusableLength) break;
+          storeSignedInteger<T>(dataStart + <usize>index * sizeof<valueof<T>>(), negative ? -(<i64>value) : <i64>value);
+          index++;
+          if (srcStart >= srcEnd) break;
+
+          code = load<u16>(srcStart);
+          if (code == COMMA) {
+            srcStart += 2;
+            continue;
+          }
+          if (code == BRACKET_RIGHT) {
+            out.length = index;
+            return out;
+          }
+          break;
+        }
+      } else {
+        while (srcStart < srcEnd) {
+          let digit = <u32>load<u16>(srcStart) - 48;
+          if (digit > 9) break;
+
+          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;
+          }
+
+          while (srcStart < srcEnd) {
+            digit = <u32>load<u16>(srcStart) - 48;
+            if (digit > 9) break;
+            value = value * 10 + digit;
+            srcStart += 2;
+          }
+
+          if (index >= reusableLength) break;
+          storeUnsignedInteger<T>(dataStart + <usize>index * sizeof<valueof<T>>(), value);
+          index++;
+          if (srcStart >= srcEnd) break;
+
+          const code = load<u16>(srcStart);
+          if (code == COMMA) {
+            srcStart += 2;
+            continue;
+          }
+          if (code == BRACKET_RIGHT) {
+            out.length = index;
+            return out;
+          }
+          break;
+        }
+      }
+    } while (false);
+
+    srcStart = originalSrcStart;
+  }
+
+  out.length = 0;
+
+  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 (isSigned<valueof<T>>()) {
+      while (srcStart < srcEnd) {
+        srcStart = useSWAR ? parseSignedIntegerSWAR<T>(srcStart, srcEnd, out) : parseSignedIntegerScalar<T>(srcStart, srcEnd, out);
+        if (!srcStart || srcStart >= srcEnd) break;
+
+        const code = load<u16>(srcStart);
+        if (code == COMMA) {
+          srcStart += 2;
+          continue;
+        }
+        if (code == BRACKET_RIGHT) 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 code = load<u16>(srcStart);
+        if (code == COMMA) {
+          srcStart += 2;
+          continue;
+        }
+        if (code == BRACKET_RIGHT) return out;
+        break;
+      }
+    }
+  } while (false);
+
+  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 {
+  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 {
+  return deserializeIntegerArrayImpl<T>(srcStart, srcEnd, dst, true);
+}
+
+
+@inline export function deserializeIntegerArrayField<T extends number[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    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);
+      if (!srcStart || srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}

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

@@ -0,0 +1,7 @@
+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!");
+}

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

@@ -0,0 +1,44 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+
+
+@inline export function deserializeObjectArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    while (srcStart < srcEnd) {
+      const slot = ensureArrayElementSlot<T>(out, index);
+      let value = load<valueof<T>>(slot);
+      if (changetype<usize>(value) == 0) {
+        value = changetype<valueof<T>>(instantiate<nonnull<valueof<T>>>());
+        store<valueof<T>>(slot, value);
+      }
+
+      srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE<valueof<T>>(srcStart, srcEnd, value);
+      if (!srcStart || srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}

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

@@ -0,0 +1,8 @@
+import { JSON } from "../../..";
+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!");
+}

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

@@ -0,0 +1,96 @@
+import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA, QUOTE } from "../../../custom/chars";
+
+
+@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>());
+    store<T>(fieldPtr, out);
+  } else {
+    out.length = 0;
+  }
+  return out;
+}
+
+
+@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;
+}
+
+
+@inline export function ensureArrayElementSlot<T extends Array<any>>(out: T, index: i32): usize {
+  const nextLength = index + 1;
+  if (out.length < nextLength) out.length = nextLength;
+  return out.dataStart + <usize>index * sizeof<valueof<T>>();
+}
+
+
+@inline export function scanQuotedValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
+  srcStart += 2;
+  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
+
+  while (srcStart <= srcEnd8) {
+    let mask = inline.always(backslashOrQuoteMask(load<u64>(srcStart)));
+    if (mask === 0) {
+      srcStart += 8;
+      continue;
+    }
+
+    do {
+      const laneIdx = usize(ctz(mask) >> 3);
+      mask &= mask - 1;
+      const srcIdx = srcStart + laneIdx;
+      const char = load<u16>(srcIdx);
+      if (char == QUOTE) return srcIdx + 2;
+      if (char == BACK_SLASH) break;
+    } while (mask !== 0);
+
+    break;
+  }
+
+  while (srcStart < srcEnd) {
+    const char = load<u16>(srcStart);
+    if (char == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH) return srcStart + 2;
+    srcStart += 2;
+  }
+
+  return 0;
+}
+
+
+@inline export function scanValueEnd(srcStart: usize, srcEnd: usize): usize {
+  if (srcStart >= srcEnd) return 0;
+  const first = load<u16>(srcStart);
+
+  if (first == QUOTE) return scanQuotedValueEnd_SWAR(srcStart, srcEnd);
+
+  if (first == BRACE_LEFT || first == BRACKET_LEFT) {
+    let depth: i32 = 1;
+    let ptr = srcStart + 2;
+    while (ptr < srcEnd) {
+      const code = load<u16>(ptr);
+      if (code == QUOTE) {
+        ptr = scanQuotedValueEnd_SWAR(ptr, srcEnd);
+        if (!ptr) return 0;
+        continue;
+      }
+      if (code == BRACE_LEFT || code == BRACKET_LEFT) {
+        depth++;
+      } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
+        if (--depth == 0) return ptr + 2;
+      }
+      ptr += 2;
+    }
+    return 0;
+  }
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == COMMA || code == BRACKET_RIGHT) return srcStart;
+    srcStart += 2;
+  }
+
+  return 0;
+}

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

@@ -0,0 +1,39 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+import { deserializeStringField_SWAR } from "../string";
+
+
+@inline export function deserializeStringArrayField<T extends string[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    while (srcStart < srcEnd) {
+      const slot = ensureArrayElementSlot<T>(out, index);
+      srcStart = deserializeStringField_SWAR<valueof<T>>(srcStart, srcEnd, slot);
+      if (!srcStart || srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}

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

@@ -0,0 +1,44 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+
+
+@inline export function deserializeStructArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  const out = ensureArrayField<T>(fieldPtr);
+  let index = 0;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return srcStart + 2;
+    }
+
+    while (srcStart < srcEnd) {
+      const slot = ensureArrayElementSlot<T>(out, index);
+      let value = load<valueof<T>>(slot);
+      if (changetype<usize>(value) == 0) {
+        value = changetype<valueof<T>>(instantiate<nonnull<valueof<T>>>());
+        store<valueof<T>>(slot, value);
+      }
+
+      srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE<valueof<T>>(srcStart, srcEnd, value);
+      if (!srcStart || srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        index++;
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = index + 1;
+        return srcStart + 2;
+      }
+      break;
+    }
+  } while (false);
+
+  throw new Error("Failed to parse JSON!");
+}