json-as 1.2.6 → 1.3.0

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

@@ -0,0 +1,307 @@
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { deserializeIntegerArray_SLOW } from "../../swar/array/integer";
+
+const ASCII_LANE_MASK_4: u64 = 0x00ff00ff00ff00ff;
+const ASCII_ZERO_4: u64 = 0x0030003000300030;
+
+
+@lazy const SPLAT_30 = i16x8.splat(0x30);
+
+
+@lazy const SPLAT_09 = i16x8.splat(9);
+
+
+@lazy const ZERO_I16X8 = i16x8.splat(0);
+
+
+@lazy const ZERO_I32X4 = i32x4.splat(0);
+
+
+@lazy const PACK_WEIGHTS_10_1 = i8x16(10, 1, 10, 1, 10, 1, 10, 1, 0, 0, 0, 0, 0, 0, 0, 0);
+
+
+@lazy const PAIR_WEIGHTS_100_1 = i16x8(100, 1, 100, 1, 0, 0, 0, 0);
+
+
+@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 tryParseEightDigitsSIMD(srcStart: usize, value: u64): u64 {
+  const block = load<v128>(srcStart);
+  const digits = i16x8.sub(block, SPLAT_30);
+  if (v128.any_true(i16x8.gt_u(digits, SPLAT_09))) return 0;
+
+  const packed = i8x16.narrow_i16x8_u(digits, ZERO_I16X8);
+  const products = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1);
+  const pairs = i32x4.extadd_pairwise_i16x8_u(products);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs, ZERO_I32X4);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1);
+
+  const lo = i32x4.extract_lane(groups, 0);
+  const hi = i32x4.extract_lane(groups, 1);
+  return value * 100000000 + (<u64>lo * 10000 + <u64>hi);
+}
+
+
+@inline function parseSignedIntegerSIMD<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 + 14 < srcEnd) {
+    const next = tryParseEightDigitsSIMD(srcStart, value);
+    if (!next) break;
+    value = next;
+    srcStart += 16;
+  }
+
+  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 parseUnsignedIntegerSIMD<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 + 14 < srcEnd) {
+    const next = tryParseEightDigitsSIMD(srcStart, value);
+    if (!next) break;
+    value = next;
+    srcStart += 16;
+  }
+
+  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;
+}
+
+// @ts-ignore: Decorator valid here
+export function deserializeIntegerArray_SIMD<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+  const originalSrcStart = srcStart;
+  const reusableLength = out.length;
+
+  if (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 + 14 < srcEnd) {
+            const next = tryParseEightDigitsSIMD(srcStart, value);
+            if (!next) break;
+            value = next;
+            srcStart += 16;
+          }
+          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 + 14 < srcEnd) {
+            const next = tryParseEightDigitsSIMD(srcStart, value);
+            if (!next) break;
+            value = next;
+            srcStart += 16;
+          }
+          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 = parseSignedIntegerSIMD<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 = parseUnsignedIntegerSIMD<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));
+}

package/assembly/deserialize/simd/string.ts

@@ -1,13 +1,15 @@
 import { bs } from "../../../lib/as-bs";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+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";
 
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const SPLAT_5C = i16x8.splat(0x5c); // \
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_22 = i16x8.splat(0x22); // "
 
 // Overflow Pattern for Unicode Escapes (READ)
 // \u0001        0  \u0001__|      + 0
@@ -61,13 +63,48 @@ import { hex4_to_u16_swar } from "../../util/swar";
  * @param dst buffer to write to
  * @returns number of bytes written
  */
+// @ts-expect-error: @inline is a valid decorator
+@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>());
+  memory.copy(out, srcStart, byteLength);
+  return changetype<string>(out);
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline function writeStringToField_SIMD(dstFieldPtr: usize, srcStart: usize, byteLength: u32): void {
+  if (byteLength == 0) {
+    store<usize>(dstFieldPtr, changetype<usize>(""));
+    return;
+  }
+
+  const current = load<usize>(dstFieldPtr);
+  let stringPtr: usize;
+  if (current != 0 && changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
+    stringPtr = current;
+  } else if (current != 0 && current != changetype<usize>("")) {
+    stringPtr = __renew(current, byteLength);
+    store<usize>(dstFieldPtr, stringPtr);
+  } else {
+    stringPtr = __new(byteLength, idof<string>());
+    store<usize>(dstFieldPtr, stringPtr);
+  }
+  memory.copy(stringPtr, srcStart, byteLength);
+}
+
 // todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
-export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
-  // Strip quotes
-  srcStart += 2;
-  srcEnd -= 2;
+// @ts-expect-error: @inline is a valid decorator
+@inline function deserializeEscapedString_SIMD(payloadStart: usize, escapeStart: usize, srcEnd: usize): string {
+  const prefixLen = <u32>(escapeStart - payloadStart);
+  let srcStart = escapeStart;
   const srcEnd16 = srcEnd - 16;
   bs.ensureSize(u32(srcEnd - srcStart));
+  bs.offset = bs.buffer;
+  if (prefixLen != 0) {
+    memory.copy(bs.buffer, payloadStart, prefixLen);
+    bs.offset += prefixLen;
+  }
 
   while (srcStart < srcEnd16) {
     const block = load<v128>(srcStart);
@@ -145,8 +182,7 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
     const code = load<u16>(srcStart);
     if (code !== 0x75) {
       // Short escapes (\n \t \" \\)
-      const block = load<u16>(srcStart);
-      const escape = load<u16>(DESERIALIZE_ESCAPE_TABLE + block);
+      const escape = load<u16>(DESERIALIZE_ESCAPE_TABLE + code);
       store<u16>(bs.offset, escape);
       srcStart += 2;
     } else {
@@ -161,3 +197,86 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 
   return bs.out<string>();
 }
+
+export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
+  // Strip quotes
+  srcStart += 2;
+  srcEnd -= 2;
+  const payloadStart = srcStart;
+  const srcEnd16 = srcEnd - 16;
+
+  while (srcStart < srcEnd16) {
+    const block = load<v128>(srcStart);
+    const eq5C = i16x8.eq(block, SPLAT_5C);
+
+    if (!v128.any_true(eq5C)) {
+      srcStart += 16;
+      continue;
+    }
+
+    const laneIdx = usize(ctz(i16x8.bitmask(eq5C)) << 1);
+    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));
+    }
+    srcStart += 2;
+  }
+
+  return copyStringFromSource_SIMD(payloadStart, srcEnd - payloadStart);
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeStringField_SIMD<T extends string | null>(srcStart: usize, srcEnd: usize, dstFieldPtr: usize): usize {
+  if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE) abort("Expected leading quote");
+
+  const quotedStart = srcStart;
+  const payloadStart = srcStart + 2;
+  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+  srcStart = payloadStart;
+
+  while (srcStart <= srcEnd16) {
+    const block = load<v128>(srcStart);
+    let mask = i16x8.bitmask(v128.or(i16x8.eq(block, SPLAT_5C), i16x8.eq(block, SPLAT_22)));
+
+    if (mask == 0) {
+      srcStart += 16;
+      continue;
+    }
+
+    do {
+      const laneIdx = usize(ctz(mask) << 1);
+      mask &= mask - 1;
+      const srcIdx = srcStart + laneIdx;
+      const char = load<u16>(srcIdx);
+
+      if (char == QUOTE) {
+        writeStringToField_SIMD(dstFieldPtr, payloadStart, <u32>(srcIdx - payloadStart));
+        return srcIdx + 2;
+      }
+
+      if (char == BACK_SLASH) {
+        return deserializeStringField_SWAR<T>(quotedStart, srcEnd, dstFieldPtr);
+      }
+    } while (mask != 0);
+
+    srcStart += 16;
+  }
+
+  while (srcStart < srcEnd) {
+    const char = load<u16>(srcStart);
+    if (char == QUOTE) {
+      writeStringToField_SIMD(dstFieldPtr, payloadStart, <u32>(srcStart - payloadStart));
+      return srcStart + 2;
+    }
+    if (char == BACK_SLASH) {
+      return deserializeStringField_SWAR<T>(quotedStart, srcEnd, dstFieldPtr);
+    }
+    srcStart += 2;
+  }
+
+  abort("Unterminated string literal");
+  return srcStart;
+}

package/assembly/deserialize/simple/arbitrary.ts

@@ -1,27 +1,20 @@
 import { JSON } from "../..";
 import { deserializeArray } from "./array";
 import { deserializeBoolean } from "./bool";
-import { deserializeFloat } from "./float";
+import { deserializeFloat } from "../float";
 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,27 +1,10 @@
-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 } from "util/string";
+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)
@@ -47,21 +30,11 @@ export function deserializeArbitraryArray(
       }
     } else if (code == QUOTE) {
       lastIndex = srcStart;
+      srcStart = scanStringEnd(srcStart, srcEnd);
+      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;
-      while (srcStart < srcEnd) {
-        const code = load<u16>(srcStart);
-        if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
-          // console.log("Value (string): " + ptrToStr(lastIndex, srcStart + 2));
-          // @ts-ignore: exists
-          out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
-          srcStart += 2;
-          break;
-        }
-        srcStart += 2;
-      }
       // console.log("next: " + String.fromCharCode(load<u16>(srcStart)));
     } else if (code - 48 <= 9 || code == 45) {
       // console.log("trigger int")
@@ -103,7 +76,10 @@ export function deserializeArbitraryArray(
       srcStart += 2;
       while (srcStart < srcEnd) {
         const code = load<u16>(srcStart);
-        if (code == BRACKET_RIGHT) {
+        if (code == QUOTE) {
+          srcStart = scanStringEnd(srcStart, srcEnd);
+          if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON array");
+        } else if (code == BRACKET_RIGHT) {
           if (--depth == 0) {
             // @ts-ignore: type
             out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));

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

@@ -1,14 +1,8 @@
 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,11 +1,5 @@
-export function deserializeBooleanArray<T extends boolean[]>(
-  srcStart: usize,
-  srcEnd: usize,
-  dst: usize,
-): T {
-  const out = changetype<nonnull<T>>(
-    dst || changetype<usize>(instantiate<T>()),
-  );
+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 [
   while (srcStart < srcEnd) {
     const block = load<u64>(srcStart);

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

@@ -2,14 +2,8 @@ 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,14 +2,8 @@ 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>()),
-  );
+export function deserializeFloatArray<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);

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

@@ -1,14 +1,8 @@
 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);