json-as 1.3.6 → 1.3.8

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

@@ -0,0 +1,68 @@
+import { isSpace } from "../../../util";
+import {
+  COMMA,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  FALSE_WORD_U64,
+  TRUE_WORD_U64,
+} from "../../../custom/chars";
+
+/**
+ * Strict boolean-array deserializer (`bool[]`, every JSON_MODE).
+ *
+ * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
+ * leading / trailing / doubled commas, and each element must be exactly the
+ * literal `true` or `false`. Throws on any deviation.
+ *
+ * The token check is SWAR-shaped: one `u64` load matches all four chars of
+ * `true`; `false` 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>()),
+  );
+  out.length = 0; // dst may arrive pre-sized; re-parse from empty via push
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Invalid JSON array: expected '['");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error("Invalid JSON array: expected ']'");
+  srcStart += 2; // past '['
+  srcEnd -= 2; // before ']'
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (srcStart >= srcEnd) return out;
+
+  while (true) {
+    if (srcStart + 8 <= srcEnd && load<u64>(srcStart) == TRUE_WORD_U64) {
+      out.push(true);
+      srcStart += 8;
+    } else if (
+      srcStart + 10 <= srcEnd &&
+      load<u64>(srcStart) == FALSE_WORD_U64 &&
+      load<u16>(srcStart, 8) == 101
+    ) {
+      out.push(false);
+      srcStart += 10;
+    } else {
+      throw new Error("Invalid JSON array: expected 'true' or 'false'");
+    }
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) != COMMA)
+      throw new Error("Invalid JSON array: expected ',' or ']'");
+    srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd)
+      throw new Error("Invalid JSON array: trailing comma");
+  }
+
+  return out;
+}

package/assembly/deserialize/{simple → naive}/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/naive/array/float.ts

@@ -0,0 +1,63 @@
+import { isSpace } from "../../../util";
+import { COMMA, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../..";
+
+/**
+ * Strict float-array deserializer (`f64[]` / `f32[]`).
+ *
+ * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
+ * leading / trailing / doubled commas, and no garbage between values. Each
+ * element token is validated by `deserializeFloat_NAIVE` (via `JSON.__deserialize`),
+ * so malformed numbers like `0e` / `-01` / `1.` are rejected here too. Throws on
+ * any deviation.
+ */
+export function deserializeFloatArray_NAIVE<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+  // `dst` may arrive pre-sized (e.g. the SWAR fast path presizes then falls
+  // back here); we re-parse from scratch via push, so start from empty.
+  out.length = 0;
+
+  // Trim surrounding whitespace and require the enclosing brackets.
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Invalid JSON array: expected '['");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error("Invalid JSON array: expected ']'");
+  srcStart += 2; // past '['
+  srcEnd -= 2; // before ']'
+
+  // skip whitespace; an empty body is a valid empty array
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (srcStart >= srcEnd) return out;
+
+  while (true) {
+    // value token: runs until whitespace or a comma
+    const tokenStart = srcStart;
+    while (srcStart < srcEnd) {
+      const c = load<u16>(srcStart);
+      if (c == COMMA || isSpace(c)) break;
+      srcStart += 2;
+    }
+    if (srcStart == tokenStart)
+      throw new Error("Invalid JSON array: missing value");
+    out.push(JSON.__deserialize<valueof<T>>(tokenStart, srcStart));
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break; // end of array body
+    if (load<u16>(srcStart) != COMMA)
+      throw new Error("Invalid JSON array: expected ',' or ']'");
+    srcStart += 2; // past ','
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd)
+      throw new Error("Invalid JSON array: trailing comma");
+  }
+
+  return out;
+}

package/assembly/deserialize/{simple → naive}/array/generic.ts

@@ -1,17 +1,24 @@
 import { JSON } from "../../..";
 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>()));
+import { scanValueEnd } from "../../../util/scanValueEnd";
+
+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/naive/array/integer.ts

@@ -0,0 +1,86 @@
+import { atoi, isSpace } from "../../../util";
+import { COMMA, BRACKET_LEFT, BRACKET_RIGHT } from "../../../custom/chars";
+
+// Strict RFC 8259 integer-token check over [start, end): optional minus (signed
+// types only), then a lone `0` or [1-9] digits — no leading zeros, fraction,
+// exponent, or trailing garbage. Throws otherwise.
+// @ts-ignore: inline
+@inline function validateJSONInteger(
+  start: usize,
+  end: usize,
+  signed: bool,
+): void {
+  let ptr = start;
+  if (ptr < end && load<u16>(ptr) == 45) {
+    if (!signed) throw new Error("Invalid JSON number: minus on unsigned");
+    ptr += 2;
+  }
+  if (ptr >= end) throw new Error("Invalid JSON number: expected digit");
+  const first = load<u16>(ptr);
+  if (first == 48) {
+    ptr += 2;
+    if (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9)
+      throw new Error("Invalid JSON number: leading zero");
+  } else if (<u32>(first - 48) <= 9) {
+    ptr += 2;
+    while (ptr < end && <u32>(load<u16>(ptr) - 48) <= 9) ptr += 2;
+  } else {
+    throw new Error("Invalid JSON number: expected digit");
+  }
+  if (ptr != end) throw new Error("Invalid JSON number: not an integer");
+}
+
+/**
+ * Strict integer-array deserializer (`i8[]`..`i64[]`, `u8[]`..`u64[]`).
+ *
+ * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
+ * leading / trailing / doubled commas, and each element must be a valid JSON
+ * integer (no leading zeros, fraction, or exponent). Throws on any deviation.
+ */
+export function deserializeIntegerArray_NAIVE<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+  out.length = 0; // dst may arrive pre-sized; re-parse from empty via push
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Invalid JSON array: expected '['");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error("Invalid JSON array: expected ']'");
+  srcStart += 2; // past '['
+  srcEnd -= 2; // before ']'
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (srcStart >= srcEnd) return out;
+
+  const signed = isSigned<valueof<T>>();
+  while (true) {
+    const tokenStart = srcStart;
+    while (srcStart < srcEnd) {
+      const c = load<u16>(srcStart);
+      if (c == COMMA || isSpace(c)) break;
+      srcStart += 2;
+    }
+    if (srcStart == tokenStart)
+      throw new Error("Invalid JSON array: missing value");
+    validateJSONInteger(tokenStart, srcStart, signed);
+    out.push(atoi<valueof<T>>(tokenStart, srcStart));
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) != COMMA)
+      throw new Error("Invalid JSON array: expected ',' or ']'");
+    srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd)
+      throw new Error("Invalid JSON array: trailing comma");
+  }
+
+  return out;
+}

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

@@ -0,0 +1,47 @@
+import {
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+} from "../../../custom/chars";
+import { JSON } from "../../..";
+import { isSpace } from "util/string";
+
+export function deserializeMapArray<T extends Map<any, any>[]>(
+  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;
+
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
+  if (srcStart - srcEnd == 0)
+    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 object at position " +
+        (srcEnd - srcStart).toString(),
+    );
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error(
+      "Expected ']' at end of object at position " +
+        (srcEnd - srcStart).toString(),
+    );
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == BRACE_LEFT && depth++ == 0) {
+      lastIndex = srcStart;
+    } else if (code == BRACE_RIGHT && --depth == 0) {
+      out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+    }
+    srcStart += 2;
+  }
+  return out;
+}

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

@@ -0,0 +1,47 @@
+import {
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+} from "../../../custom/chars";
+import { JSON } from "../../..";
+import { isSpace } from "util/string";
+
+export function deserializeObjectArray<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;
+
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
+  if (srcStart - srcEnd == 0)
+    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 object at position " +
+        (srcEnd - srcStart).toString(),
+    );
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error(
+      "Expected ']' at end of object at position " +
+        (srcEnd - srcStart).toString(),
+    );
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == BRACE_LEFT && depth++ == 0) {
+      lastIndex = srcStart;
+    } else if (code == BRACE_RIGHT && --depth == 0) {
+      out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+    }
+    srcStart += 2;
+  }
+  return out;
+}

package/assembly/deserialize/{simple → naive}/array/raw.ts

@@ -1,11 +1,28 @@
 import { isSpace, isUnescapedQuote, scanStringEnd } from "../../../util";
-import { COMMA, BRACKET_RIGHT, QUOTE, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BACK_SLASH, CHAR_T, CHAR_F, CHAR_N } from "../../../custom/chars";
+import {
+  COMMA,
+  BRACKET_RIGHT,
+  QUOTE,
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BACK_SLASH,
+  CHAR_T,
+  CHAR_F,
+  CHAR_N,
+} from "../../../custom/chars";
 import { JSON } from "../../..";
 import { ptrToStr } from "../../../util/ptrToStr";
 
-export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize): JSON.Raw[] {
+export function deserializeRawArray(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): JSON.Raw[] {
   // console.log("data: " + ptrToStr(srcStart, srcEnd));
-  const out = changetype<JSON.Raw[]>(dst || changetype<usize>(instantiate<JSON.Raw[]>()));
+  const out = changetype<JSON.Raw[]>(
+    dst || changetype<usize>(instantiate<JSON.Raw[]>()),
+  );
   let lastIndex: usize = 0;
   let depth = 0;
   srcStart += 2;
@@ -19,7 +36,8 @@ export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize):
     } 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");
       out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart + 2)));
       srcStart += 2;
     } else if (code - 48 <= 9 || code == 45) {
@@ -43,7 +61,8 @@ export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize):
         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 == BRACE_RIGHT) {
           if (--depth == 0) {
             // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
@@ -62,7 +81,8 @@ export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize):
         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) {
             // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
@@ -92,7 +112,14 @@ export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize):
         srcStart += 10;
       }
     } else {
-      throw new Error("Unexpected character in JSON object '" + String.fromCharCode(code) + "' at position " + (srcEnd - srcStart).toString() + " " + ptrToStr(lastIndex, srcStart + 10));
+      throw new Error(
+        "Unexpected character in JSON object '" +
+          String.fromCharCode(code) +
+          "' at position " +
+          (srcEnd - srcStart).toString() +
+          " " +
+          ptrToStr(lastIndex, srcStart + 10),
+      );
     }
   }
   return out;

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

@@ -0,0 +1,69 @@
+import { JSON } from "../../..";
+import {
+  COMMA,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  NULL_WORD_U64,
+  QUOTE,
+} from "../../../custom/chars";
+import { isSpace, scanStringEnd } from "../../../util";
+
+/**
+ * Strict string-array deserializer (`string[]` / `(string | null)[]`).
+ *
+ * Enforces RFC 8259 array structure: `[`-framed, single-comma separated, no
+ * leading / trailing / doubled commas, and each element must be a quoted string
+ * (or the literal `null` for a nullable element type). Element contents are
+ * validated by `deserializeString_NAIVE` (via `JSON.__deserialize`). Throws on
+ * any deviation.
+ */
+export function deserializeStringArray_NAIVE(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): string[] {
+  const out = changetype<string[]>(
+    dst || changetype<usize>(instantiate<string[]>()),
+  );
+  out.length = 0; // dst may arrive pre-sized; re-parse from empty via push
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
+    throw new Error("Invalid JSON array: expected '['");
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error("Invalid JSON array: expected ']'");
+  srcStart += 2; // past '['
+  srcEnd -= 2; // before ']'
+
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  if (srcStart >= srcEnd) return out;
+
+  while (true) {
+    const code = load<u16>(srcStart);
+    if (code == QUOTE) {
+      const closing = scanStringEnd(srcStart, srcEnd);
+      if (closing >= srcEnd)
+        throw new Error("Invalid JSON array: unterminated string");
+      out.push(JSON.__deserialize<string>(srcStart, closing + 2));
+      srcStart = closing + 2;
+    } else if (srcStart + 8 <= srcEnd && load<u64>(srcStart) == NULL_WORD_U64) {
+      // `(string | null)[]` element
+      out.push(changetype<string>(0));
+      srcStart += 8;
+    } else {
+      throw new Error("Invalid JSON array: expected string");
+    }
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) != COMMA)
+      throw new Error("Invalid JSON array: expected ',' or ']'");
+    srcStart += 2;
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd)
+      throw new Error("Invalid JSON array: trailing comma");
+  }
+
+  return out;
+}

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

@@ -0,0 +1,47 @@
+import {
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+} from "../../../custom/chars";
+import { JSON } from "../../..";
+import { isSpace } from "util/string";
+
+export function deserializeStructArray<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;
+
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
+  if (srcStart - srcEnd == 0)
+    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 object at position " +
+        (srcEnd - srcStart).toString(),
+    );
+  if (load<u16>(srcEnd - 2) != BRACKET_RIGHT)
+    throw new Error(
+      "Expected ']' at end of object at position " +
+        (srcEnd - srcStart).toString(),
+    );
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == BRACE_LEFT && depth++ == 0) {
+      lastIndex = srcStart;
+    } else if (code == BRACE_RIGHT && --depth == 0) {
+      out.push(JSON.__deserialize<valueof<T>>(lastIndex, (srcStart += 2)));
+    }
+    srcStart += 2;
+  }
+  return out;
+}

package/assembly/deserialize/{simple → naive}/array.ts

@@ -2,30 +2,32 @@ import { JSON } from "../..";
 import { deserializeArbitraryArray } from "./array/arbitrary";
 import { deserializeArrayArray } from "./array/array";
 import { deserializeBooleanArray } from "./array/bool";
-import { deserializeFloatArray } from "./array/float";
+import { deserializeFloatArray_NAIVE } from "./array/float";
 import { deserializeGenericArray } from "./array/generic";
-import { deserializeIntegerArray } from "./array/integer";
+import { deserializeIntegerArray_NAIVE } from "./array/integer";
 import { deserializeMapArray } from "./array/map";
 import { deserializeStructArray } from "./array/struct";
-import { deserializeStringArray } from "./array/string";
+import { deserializeStringArray_NAIVE } from "./array/string";
 import { deserializeObjectArray } from "./array/object";
 import { deserializeBoxArray } from "./array/box";
 import { deserializeRawArray } from "./array/raw";
-export { deserializeArrayField, deserializeArrayField as deserializeArrayField_SWAR } from "../swar/array";
-
 // @ts-ignore: Decorator valid here
-export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+export function deserializeArray<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
   if (isString<valueof<T>>()) {
-    return <T>deserializeStringArray(srcStart, srcEnd, dst);
+    return <T>deserializeStringArray_NAIVE(srcStart, srcEnd, dst);
   } else if (isBoolean<valueof<T>>()) {
     // @ts-ignore
     return deserializeBooleanArray<T>(srcStart, srcEnd, dst);
   } else if (isInteger<valueof<T>>()) {
     // @ts-ignore
-    return deserializeIntegerArray<T>(srcStart, srcEnd, dst);
+    return deserializeIntegerArray_NAIVE<T>(srcStart, srcEnd, dst);
   } else if (isFloat<valueof<T>>()) {
     // @ts-ignore
-    return deserializeFloatArray<T>(srcStart, srcEnd, dst);
+    return deserializeFloatArray_NAIVE<T>(srcStart, srcEnd, dst);
   } else if (isArray<valueof<T>>()) {
     // @ts-ignore: type
     return deserializeArrayArray<T>(srcStart, srcEnd, dst);
@@ -56,7 +58,10 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
       return deserializeStructArray<T>(srcStart, srcEnd, dst);
       // @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 deserializeStructArray<T>(srcStart, srcEnd, dst);
     }
     throw new Error("Could not parse array of type " + nameof<T>() + "!");

package/assembly/deserialize/{simple → naive}/bool.ts

@@ -1,7 +1,11 @@
 // @ts-ignore: inline
-@inline export function deserializeBoolean(srcStart: usize, srcEnd: usize): boolean {
+@inline export function deserializeBoolean(
+  srcStart: usize,
+  srcEnd: usize,
+): boolean {
   const block = load<u64>(srcStart);
   if (block == 28429475166421108) return true;
-  else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101) return false;
+  else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101)
+    return false;
   return false; //throw new Error(`Expected to find boolean, but found "${data.slice(0, 100)}" instead!`);
 }