json-as 1.2.5 → 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,10 +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 { 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); // \
+@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
@@ -52,20 +57,54 @@ import { hex4_to_u16_swar } from "../../util/swar";
 // -------\n      14 -------*|     + 0
 // Formula: overflow = lane - 14
 
-
 /**
  * Deserializes strings back into into their original form using SIMD operations
  * @param src string to deserialize
  * @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);
@@ -96,7 +135,7 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
       if (code !== 0x75) {
         // Short escapes (\n \t \" \\)
         const escaped = load<u16>(DESERIALIZE_ESCAPE_TABLE + code);
-        mask &= mask - i32(escaped === 0x5C);
+        mask &= mask - i32(escaped === 0x5c);
         store<u16>(bs.offset, escaped);
         store<v128>(bs.offset, load<v128>(srcIdx, 4), 2);
 
@@ -135,7 +174,7 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
     srcStart += 2;
 
     // Early exit
-    if (block !== 0x5C) {
+    if (block !== 0x5c) {
       bs.offset += 2;
       continue;
     }
@@ -143,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,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,7 +1,7 @@
 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";
@@ -20,4 +20,4 @@ export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize)
     return value;
   }
   return unreachable();
-}
+}

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

@@ -1,6 +1,6 @@
 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[] {
@@ -30,21 +30,11 @@ export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: u
       }
     } 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")
@@ -70,8 +60,8 @@ export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: u
         if (code == BRACE_RIGHT) {
           if (--depth == 0) {
             // @ts-ignore: type
-            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart));
-            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart));
+            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
+            // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
             while (isSpace(load<u16>((srcStart += 2)))) {
               /* empty */
             }
@@ -86,11 +76,14 @@ export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: u
       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));
-            // console.log("Value (array): " + ptrToStr(lastIndex, srcStart));
+            out.push(JSON.__deserialize<JSON.Value>(lastIndex, srcStart + 2));
+            // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
             while (isSpace(load<u16>((srcStart += 2)))) {
               /* empty */
             }

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

@@ -1,4 +1,4 @@
-import { isSpace } from "../../../util";
+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";
@@ -11,22 +11,17 @@ export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize):
   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;
@@ -47,8 +42,8 @@ export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize):
       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));
@@ -66,8 +61,8 @@ export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize):
       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));
@@ -96,8 +91,6 @@ export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize):
         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));
     }

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

@@ -1,5 +1,6 @@
 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[]>()));
@@ -11,7 +12,7 @@ export function deserializeStringArray(srcStart: usize, srcEnd: usize, dst: usiz
       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.ts

@@ -10,6 +10,7 @@ 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 {