json-as 1.2.6 → 1.3.1

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;
+  const outStart = bs.offset - bs.buffer;
   bs.ensureSize(u32(srcEnd - srcStart));
+  if (prefixLen != 0) {
+    memory.copy(bs.offset, 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 {
@@ -159,5 +195,88 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
     bs.offset += 2;
   }
 
-  return bs.out<string>();
+  return bs.sliceOut<string>(outStart);
+}
+
+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);

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

@@ -1,39 +1,19 @@
-import {
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-} from "../../../custom/chars";
+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>()),
-  );
+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 (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   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 (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(),
-    );
+  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);

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

@@ -1,39 +1,19 @@
-import {
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-} from "../../../custom/chars";
+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>()),
-  );
+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 (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   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 (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(),
-    );
+  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);

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

@@ -1,49 +1,27 @@
-import { isSpace } 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 { 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 { 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;
   while (srcStart < srcEnd) {
     let code = load<u16>(srcStart);
-    if (code == QUOTE) {
+    if (code == BRACKET_RIGHT) {
+      break;
+    } else if (code == COMMA || isSpace(code)) {
+      srcStart += 2;
+      continue;
+    } else if (code == QUOTE) {
       lastIndex = srcStart;
+      srcStart = scanStringEnd(srcStart, srcEnd);
+      if (srcStart >= srcEnd) throw new Error("Unterminated string in JSON array");
+      out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart + 2)));
       srcStart += 2;
-      while (srcStart < srcEnd) {
-        code = load<u16>(srcStart);
-        if (code == QUOTE || isSpace(code)) {
-          // console.log("Value (string): " + ptrToStr(lastIndex, srcStart));
-          out.push(JSON.Raw.from(ptrToStr(lastIndex, srcStart + 2)));
-          // while (isSpace(load<u16>((srcStart += 2)))) {
-          //   /* empty */
-          // }
-          srcStart += 4;
-          break;
-        }
-        srcStart += 2;
-      }
     } else if (code - 48 <= 9 || code == 45) {
       lastIndex = srcStart;
       srcStart += 2;
@@ -64,14 +42,8 @@ export function deserializeRawArray(
       while (srcStart < srcEnd) {
         const code = load<u16>(srcStart);
         if (code == QUOTE) {
-          srcStart += 2;
-          while (
-            !(
-              load<u16>(srcStart) == QUOTE &&
-              load<u16>(srcStart - 2) != BACK_SLASH
-            )
-          )
-            srcStart += 2;
+          srcStart = scanStringEnd(srcStart, srcEnd);
+          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));
@@ -89,14 +61,8 @@ export function deserializeRawArray(
       while (srcStart < srcEnd) {
         const code = load<u16>(srcStart);
         if (code == QUOTE) {
-          srcStart += 2;
-          while (
-            !(
-              load<u16>(srcStart) == QUOTE &&
-              load<u16>(srcStart - 2) != BACK_SLASH
-            )
-          )
-            srcStart += 2;
+          srcStart = scanStringEnd(srcStart, srcEnd);
+          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));
@@ -125,17 +91,8 @@ export function deserializeRawArray(
         out.push(JSON.Raw.from("null"));
         srcStart += 10;
       }
-    } else if (isSpace(code)) {
-      srcStart += 2;
     } 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/simple/array/string.ts

@@ -1,14 +1,9 @@
 import { JSON } from "../../..";
-import { BACK_SLASH, QUOTE } from "../../../custom/chars";
+import { QUOTE } from "../../../custom/chars";
+import { isUnescapedQuote } from "../../../util";
 
-export function deserializeStringArray(
-  srcStart: usize,
-  srcEnd: usize,
-  dst: usize,
-): string[] {
-  const out = changetype<string[]>(
-    dst || changetype<usize>(instantiate<string[]>()),
-  );
+export function deserializeStringArray(srcStart: usize, srcEnd: usize, dst: usize): string[] {
+  const out = changetype<string[]>(dst || changetype<usize>(instantiate<string[]>()));
   let lastPos: usize = 2;
   let inString = false;
   while (srcStart < srcEnd) {
@@ -17,7 +12,7 @@ export function deserializeStringArray(
       if (!inString) {
         inString = true;
         lastPos = srcStart;
-      } else if (load<u16>(srcStart - 2) != BACK_SLASH) {
+      } else if (isUnescapedQuote(srcStart)) {
         out.push(JSON.__deserialize<string>(lastPos, srcStart + 2));
         inString = false;
       }

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

@@ -1,39 +1,19 @@
-import {
-  BRACE_LEFT,
-  BRACE_RIGHT,
-  BRACKET_LEFT,
-  BRACKET_RIGHT,
-} from "../../../custom/chars";
+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>()),
-  );
+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 (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   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 (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(),
-    );
+  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);

package/assembly/deserialize/simple/array.ts

@@ -10,13 +10,10 @@ import { deserializeStringArray } 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);
   } else if (isBoolean<valueof<T>>()) {