json-as 1.4.0 → 1.6.0

package/assembly/util/scanValueEndSwar.ts

@@ -4,6 +4,7 @@ import {
   BRACE_RIGHT,
   BRACKET_LEFT,
   BRACKET_RIGHT,
+  COLON,
   COMMA,
   QUOTE,
 } from "../custom/chars";
@@ -11,33 +12,45 @@ import { isSpace } from "./isSpace";
 
 // SWAR analogue of `scanValueEndSimd.ts`, processing four UTF-16 lanes per
 // 64-bit word for the SWAR build mode (no SIMD feature). Each mask is a fast
-// FILTER — a matched lane is re-checked with a real `load<u16>` before acting —
+// FILTER - a matched lane is re-checked with a real `load<u16>` before acting -
 // so the masks may over-match non-ASCII lanes whose low byte equals a target
 // (the verify rejects them). Lane byte offset within a hit word is
 // `ctz(mask) >> 3` (detection bit sits at lane*16 + 7).
 
-// @ts-expect-error: @inline is a valid decorator
-@inline const ONES: u64 = 0x0001_0001_0001_0001;
-// @ts-expect-error: @inline is a valid decorator
-@inline const HI: u64 = 0x0080_0080_0080_0080;
+const ONES: u64 = 0x0001_0001_0001_0001;
+const HI: u64 = 0x0080_0080_0080_0080;
 
 // 16-bit-lane "equals" partials (pre-`& HI`); OR several, then `& HI` once.
-// @ts-expect-error: @inline is a valid decorator
-@inline function eqPart(block: u64, splat: u64): u64 {
+function eqPart(block: u64, splat: u64): u64 {
   const t = block ^ splat;
   return (t - ONES) & ~t;
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline const S_QUOTE: u64 = 0x0022_0022_0022_0022;
-// @ts-expect-error: @inline is a valid decorator
-@inline const S_BACK_SLASH: u64 = 0x005c_005c_005c_005c;
+const S_QUOTE: u64 = 0x0022_0022_0022_0022;
+const S_BACK_SLASH: u64 = 0x005c_005c_005c_005c;
+const S_BRACKET_LEFT: u64 = 0x005b_005b_005b_005b;
+const S_BRACKET_RIGHT: u64 = 0x005d_005d_005d_005d;
+// Clears bit 5 (0x20) of each lane, folding `{`/`}` onto `[`/`]`.
+const FOLD: u64 = 0xffdf_ffdf_ffdf_ffdf;
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function quoteOrBackslashMask(block: u64): u64 {
+function quoteOrBackslashMask(block: u64): u64 {
   return (eqPart(block, S_QUOTE) | eqPart(block, S_BACK_SLASH)) & HI;
 }
 
+// Filter for lanes equal to `"`, `{`, `}`, `[`, or `]` - the only bytes that,
+// outside a string, change depth or open a string. As with the other SWAR
+// masks, a hit is a candidate to verify with a real load (it may over-match a
+// non-ASCII lane whose low byte collides).
+function structuralOrQuoteMask(block: u64): u64 {
+  const folded = block & FOLD;
+  return (
+    (eqPart(folded, S_BRACKET_LEFT) |
+      eqPart(folded, S_BRACKET_RIGHT) |
+      eqPart(block, S_QUOTE)) &
+    HI
+  );
+}
+
 function scanQuotedValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
   srcStart += 2;
   const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
@@ -63,21 +76,30 @@ function scanQuotedValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
     break;
   }
 
+  // Resolve escapes by consuming a backslash *and the char it escapes* together,
+  // so escape parity is tracked exactly. A look-back `prev != BACK_SLASH` test is
+  // wrong for an escaped backslash: in `"x\\"` the closing quote follows a `\`
+  // (the second of the pair) yet still closes the string.
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
-    if (code == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)
-      return srcStart + 2;
+    if (code == BACK_SLASH) {
+      srcStart += 4;
+      continue;
+    }
+    if (code == QUOTE) return srcStart + 2;
     srcStart += 2;
   }
   return 0;
 }
 
 function scanCompositeValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
-  // Scalar depth tracking (structural tokens are sparse; a bulk token-mask scan
-  // loses to a tight loop on token-dense objects) with SWAR quoted-skip for
-  // nested string values — where the long runs are.
+  // Process structural tokens scalar-side, but bulk-skip the bytes between them:
+  // nested string VALUES via the SWAR quoted scan, and runs of digits /
+  // punctuation / whitespace (numeric arrays) via a SWAR hunt for the next
+  // `"`/`{`/`}`/`[`/`]`.
   let depth: i32 = 1;
   let ptr = srcStart + 2;
+  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
   while (ptr < srcEnd) {
     const code = load<u16>(ptr);
     if (code == QUOTE) {
@@ -85,12 +107,36 @@ function scanCompositeValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
       if (!ptr) return 0;
       continue;
     }
-    if (code == BRACE_LEFT || code == BRACKET_LEFT) {
+    const folded = code & 0xffdf;
+    if (folded == BRACKET_LEFT) {
       depth++;
-    } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
+      ptr += 2;
+      continue;
+    }
+    if (folded == BRACKET_RIGHT) {
       if (--depth == 0) return ptr + 2;
+      ptr += 2;
+      continue;
     }
     ptr += 2;
+    // `,`/`:` sit one byte from the next token - stay scalar (string-dense
+    // objects); other fillers can run long, so SWAR-skip past them.
+    if (code == COMMA || code == COLON) continue;
+    while (ptr <= srcEnd8) {
+      const mask = structuralOrQuoteMask(load<u64>(ptr));
+      if (mask == 0) {
+        ptr += 8;
+        continue;
+      }
+      const idx = ptr + (usize(ctz(mask)) >> 3);
+      const c = load<u16>(idx);
+      const f = c & 0xffdf;
+      if (c == QUOTE || f == BRACKET_LEFT || f == BRACKET_RIGHT) {
+        ptr = idx; // real token - the outer loop processes it
+        break;
+      }
+      ptr = idx + 2; // spurious lane match - keep scanning
+    }
   }
   return 0;
 }
@@ -117,11 +163,7 @@ function scanScalarValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
  * objects/arrays use the SWAR token scans above; scalars use a short scalar
  * loop. Returns 0 on empty input or an unterminated string/composite.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function scanValueEnd_SWAR<T>(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+export function scanValueEnd_SWAR<T>(srcStart: usize, srcEnd: usize): usize {
   if (srcStart >= srcEnd) return 0;
   const first = load<u16>(srcStart);
 

package/assembly/util/scientific.ts

@@ -10,7 +10,7 @@
 // `scientific` directly skips both costs.
 //
 // scientific() is correctly rounded for all u64 mantissas and decimal
-// exponents that fit in IEEE-754 f64's range — including the [2^53, 2^64)
+// exponents that fit in IEEE-754 f64's range - including the [2^53, 2^64)
 // mantissa range that breaks Lemire's single-fmul fast path.
 
 const POWERS10: usize = memory.data<f64>([
@@ -25,13 +25,11 @@ const POWERS5: usize = memory.data<i32>([
   244140625, 1220703125,
 ]);
 
-// @ts-ignore: inline
-@inline function pow10(n: i32): f64 {
+function pow10(n: i32): f64 {
   return load<f64>(POWERS10 + ((<usize>n) << alignof<f64>()));
 }
 
-// @ts-ignore: inline
-@inline function pow5_32(n: i32): i32 {
+function pow5_32(n: i32): i32 {
   return load<i32>(POWERS5 + ((<usize>n) << alignof<i32>()));
 }
 
@@ -40,8 +38,7 @@ const POWERS5: usize = memory.data<i32>([
 // @ts-ignore: lazy decorator
 @lazy let __fixmulShift: u64 = 0;
 
-// @ts-ignore: inline
-@inline function fixmul(a: u64, b: u32): u64 {
+function fixmul(a: u64, b: u32): u64 {
   const low = (a & 0xffffffff) * b;
   const high = (a >> 32) * b + (low >> 32);
   const overflow = <u32>(high >> 32);
@@ -98,7 +95,7 @@ function scaleup(significand: u64, exp: i32): f64 {
 
 /**
  * Construct an f64 from a u64 mantissa and decimal exponent. Result is
- * correctly rounded — bit-identical to `f64.parse` for any input the SWAR
+ * correctly rounded - bit-identical to `f64.parse` for any input the SWAR
  * float deserializer can pre-parse into this form.
  *
  * Caller guarantees the digit run that produced `significand` was already

package/assembly/util/snp.ts

@@ -58,8 +58,7 @@ export function snp<T extends number>(srcStart: usize, srcEnd: usize): T {
   }
 }
 
-// @ts-ignore: Decorator valid here
-@inline function pow10<T extends number>(x: u16): T {
+function pow10<T extends number>(x: u16): T {
   if (sizeof<T>() == 8) {
     return <T>load<u64>(POW_TEN_TABLE_64 + x);
   } else {

package/assembly/util/swar-int.ts

@@ -26,8 +26,7 @@ const FINAL_4_MAGIC: u64 = 0x0000_0064_0000_0001;
  * @param block Four UTF-16 code units packed into a `u64`.
  * @returns The parsed 4-digit value, or `U32.MAX_VALUE` on invalid input.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function parse4Digits_Baseline(block: u64): u32 {
+export function parse4Digits_Baseline(block: u64): u32 {
   const digits = (block & LANE_LO_4) - ZERO_4;
   if (((digits | (digits + RANGE_ADD_4)) & RANGE_MASK_4) != 0) {
     return U32.MAX_VALUE;
@@ -58,8 +57,7 @@ const FINAL_4_MAGIC: u64 = 0x0000_0064_0000_0001;
  * @param block Four UTF-16 code units packed into a `u64`.
  * @returns The parsed 4-digit value, or `U32.MAX_VALUE` on invalid input.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function parse4Digits_PairMul(block: u64): u32 {
+export function parse4Digits_PairMul(block: u64): u32 {
   const digits = block - ZERO_4;
   if (((digits | (digits + RANGE_ADD_4)) & RANGE_MASK_4) != 0) {
     return U32.MAX_VALUE;
@@ -76,8 +74,7 @@ const FINAL_4_MAGIC: u64 = 0x0000_0064_0000_0001;
  * @param block Four UTF-16 code units packed into a `u64`.
  * @returns The parsed 4-digit value.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function parse4Digits_PairMul_Unsafe(block: u64): u32 {
+export function parse4Digits_PairMul_Unsafe(block: u64): u32 {
   const digits = block - ZERO_4;
   const pairs = (digits * 10 + (digits >> 16)) & U32_LO_PAIR;
   return <u32>((pairs * FINAL_4_MAGIC) >> 32);
@@ -123,8 +120,7 @@ export function parse8Digits_PairMul(lo: u64, hi: u64): u32 {
  * @param hi The second `u64`, four UTF-16 code units.
  * @returns The parsed 8-digit value.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function parse8Digits_PairMul_Unsafe(lo: u64, hi: u64): u32 {
+export function parse8Digits_PairMul_Unsafe(lo: u64, hi: u64): u32 {
   const loDigits = lo - ZERO_4;
   const hiDigits = hi - ZERO_4;
   const loPairs = (loDigits * 10 + (loDigits >> 16)) & U32_LO_PAIR;
@@ -149,8 +145,7 @@ export function parse8Digits_PairMul(lo: u64, hi: u64): u32 {
  * @param block Four UTF-16 code units packed into a `u64`.
  * @returns A mask with non-digit lanes flagged in their high bit, or 0.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function nonDigitMask4(block: u64): u64 {
+export function nonDigitMask4(block: u64): u64 {
   const digits = (block & LANE_LO_4) - ZERO_4;
   return (digits | (digits + RANGE_ADD_4)) & RANGE_MASK_4;
 }

package/assembly/util/swar.ts

@@ -18,8 +18,7 @@
  * @param block Packed UTF-16 ASCII hex digits.
  * @returns The decoded 16-bit value.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function hex4_to_u16_swar(block: u64): u16 {
+export function hex4_to_u16_swar(block: u64): u16 {
   // (c & 0xF) + 9 * (c >> 6)
   block = (block & 0x0f000f000f000f) + ((block >> 6) & 0x03000300030003) * 9;
 
@@ -51,8 +50,7 @@
  * @param code The 16-bit value to encode.
  * @returns Four packed UTF-16 ASCII hex digits.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function u16_to_hex4_swar(code: u16): u64 {
+export function u16_to_hex4_swar(code: u16): u64 {
   let block =
     (<u64>((code >> 12) & 0xf)) |
     ((<u64>((code >> 8) & 0xf)) << 16) |

package/assembly/util/validateJson.ts

@@ -0,0 +1,338 @@
+// Scalar RFC 8259 syntax validator used by strict builds. It keeps an explicit
+// container-state stack so hostile nesting is rejected without recursing
+// through the Wasm call stack. This is intentionally a cold correctness pass:
+// optimized backends retain their existing scanners, and the compile-time
+// JSON_STRICT guard removes this pass entirely from normal builds.
+
+const ARRAY_FIRST_OR_END: u8 = 0;
+const ARRAY_VALUE: u8 = 1;
+const ARRAY_COMMA_OR_END: u8 = 2;
+const OBJECT_FIRST_KEY_OR_END: u8 = 3;
+const OBJECT_KEY: u8 = 4;
+const OBJECT_COLON: u8 = 5;
+const OBJECT_VALUE: u8 = 6;
+const OBJECT_COMMA_OR_END: u8 = 7;
+// RFC 8259 permits implementations to set a maximum nesting depth. Keep the
+// limit below typical Wasm shadow-stack exhaustion while accepting practical
+// documents and reporting excessive nesting as a normal parse error.
+const MAX_JSON_DEPTH: i32 = 256;
+// Validation completes before target-specific parsing begins, so a single
+// fixed scratch stack is sufficient and avoids allocating a managed Array for
+// every strict parse. The public parser is already synchronous; a custom
+// deserializer can only start a nested parse after this pass has returned.
+// @ts-expect-error: decorator is valid for module-level scratch storage
+@lazy const JSON_STATE_STACK = new StaticArray<u8>(MAX_JSON_DEPTH);
+let jsonStateDepth: i32 = 0;
+
+// Four UTF-16 lanes per word. These masks only identify candidates; every hit
+// is re-read as u16 before it can affect validation, so lane-borrow false
+// positives are harmless while plain string runs advance eight bytes at once.
+const JSON_LANE_ONES: u64 = 0x0001_0001_0001_0001;
+const JSON_LANE_HI: u64 = 0x0080_0080_0080_0080;
+const JSON_QUOTE_SPLAT: u64 = 0x0022_0022_0022_0022;
+const JSON_SLASH_SPLAT: u64 = 0x005c_005c_005c_005c;
+const JSON_CONTROL_MASK: u64 = 0xffe0_ffe0_ffe0_ffe0;
+
+
+@inline
+function jsonEqualPart(block: u64, splat: u64): u64 {
+  const diff = block ^ splat;
+  return (diff - JSON_LANE_ONES) & ~diff;
+}
+
+
+@inline
+function jsonStringSpecialMask(block: u64): u64 {
+  return (
+    (jsonEqualPart(block, JSON_QUOTE_SPLAT) |
+      jsonEqualPart(block, JSON_SLASH_SPLAT) |
+      jsonEqualPart(block & JSON_CONTROL_MASK, 0)) &
+    JSON_LANE_HI
+  );
+}
+
+
+@inline
+function isJSONWhitespace(code: u16): bool {
+  return code == 0x20 || code == 0x09 || code == 0x0a || code == 0x0d;
+}
+
+
+@inline
+function isDigit(code: u16): bool {
+  return code >= 0x30 && code <= 0x39;
+}
+
+
+@inline
+function isHexDigit(code: u16): bool {
+  return (
+    isDigit(code) ||
+    (code >= 0x41 && code <= 0x46) ||
+    (code >= 0x61 && code <= 0x66)
+  );
+}
+
+function skipJSONWhitespace(ptr: usize, end: usize): usize {
+  while (ptr < end && isJSONWhitespace(load<u16>(ptr))) ptr += 2;
+  return ptr;
+}
+
+function scanJSONString(ptr: usize, end: usize): usize {
+  if (ptr >= end || load<u16>(ptr) != 0x22) return 0;
+  ptr += 2;
+  const end8 = end >= 8 ? end - 8 : 0;
+
+  while (ptr < end) {
+    while (ptr <= end8) {
+      const mask = jsonStringSpecialMask(load<u64>(ptr));
+      if (!mask) {
+        ptr += 8;
+        continue;
+      }
+
+      const candidate = ptr + (usize(ctz(mask)) >> 3);
+      const code = load<u16>(candidate);
+      if (code == 0x22) return candidate + 2;
+      if (code < 0x20) return 0;
+      if (code != 0x5c) {
+        // A non-ASCII lane may collide with the filter's low bits.
+        ptr = candidate + 2;
+        continue;
+      }
+      ptr = candidate;
+      break;
+    }
+
+    if (ptr >= end) return 0;
+    const code = load<u16>(ptr);
+    if (code == 0x22) return ptr + 2;
+    if (code < 0x20) return 0;
+
+    if (code == 0x5c) {
+      ptr += 2;
+      if (ptr >= end) return 0;
+      const escape = load<u16>(ptr);
+      if (escape == 0x75) {
+        if (ptr + 10 > end) return 0;
+        if (
+          !isHexDigit(load<u16>(ptr, 2)) ||
+          !isHexDigit(load<u16>(ptr, 4)) ||
+          !isHexDigit(load<u16>(ptr, 6)) ||
+          !isHexDigit(load<u16>(ptr, 8))
+        )
+          return 0;
+        ptr += 10;
+        continue;
+      }
+      if (
+        escape != 0x22 &&
+        escape != 0x5c &&
+        escape != 0x2f &&
+        escape != 0x62 &&
+        escape != 0x66 &&
+        escape != 0x6e &&
+        escape != 0x72 &&
+        escape != 0x74
+      )
+        return 0;
+    }
+
+    ptr += 2;
+  }
+
+  return 0;
+}
+
+function scanJSONNumber(ptr: usize, end: usize): usize {
+  if (ptr < end && load<u16>(ptr) == 0x2d) ptr += 2;
+  if (ptr >= end) return 0;
+
+  let code = load<u16>(ptr);
+  if (code == 0x30) {
+    ptr += 2;
+    if (ptr < end && isDigit(load<u16>(ptr))) return 0;
+  } else if (code >= 0x31 && code <= 0x39) {
+    do {
+      ptr += 2;
+    } while (ptr < end && isDigit(load<u16>(ptr)));
+  } else {
+    return 0;
+  }
+
+  if (ptr < end && load<u16>(ptr) == 0x2e) {
+    ptr += 2;
+    if (ptr >= end || !isDigit(load<u16>(ptr))) return 0;
+    do {
+      ptr += 2;
+    } while (ptr < end && isDigit(load<u16>(ptr)));
+  }
+
+  if (ptr < end) {
+    code = load<u16>(ptr);
+    if (code == 0x65 || code == 0x45) {
+      ptr += 2;
+      if (ptr < end) {
+        code = load<u16>(ptr);
+        if (code == 0x2b || code == 0x2d) ptr += 2;
+      }
+      if (ptr >= end || !isDigit(load<u16>(ptr))) return 0;
+      do {
+        ptr += 2;
+      } while (ptr < end && isDigit(load<u16>(ptr)));
+    }
+  }
+
+  return ptr;
+}
+
+function scanLiteral(
+  ptr: usize,
+  end: usize,
+  a: u16,
+  b: u16,
+  c: u16,
+  d: u16,
+  e: u16 = 0,
+): usize {
+  const byteLength: usize = e ? 10 : 8;
+  if (ptr + byteLength > end) return 0;
+  if (
+    load<u16>(ptr) != a ||
+    load<u16>(ptr, 2) != b ||
+    load<u16>(ptr, 4) != c ||
+    load<u16>(ptr, 6) != d ||
+    (e && load<u16>(ptr, 8) != e)
+  )
+    return 0;
+  return ptr + byteLength;
+}
+
+function scanJSONValue(ptr: usize, end: usize): usize {
+  if (ptr >= end) return 0;
+  const code = load<u16>(ptr);
+  if (code == 0x22) return scanJSONString(ptr, end);
+  if (code == 0x5b) {
+    if (jsonStateDepth >= MAX_JSON_DEPTH) return 0;
+    unchecked((JSON_STATE_STACK[jsonStateDepth++] = ARRAY_FIRST_OR_END));
+    return ptr + 2;
+  }
+  if (code == 0x7b) {
+    if (jsonStateDepth >= MAX_JSON_DEPTH) return 0;
+    unchecked((JSON_STATE_STACK[jsonStateDepth++] = OBJECT_FIRST_KEY_OR_END));
+    return ptr + 2;
+  }
+  if (code == 0x74) return scanLiteral(ptr, end, 0x74, 0x72, 0x75, 0x65); // true
+  if (code == 0x66) return scanLiteral(ptr, end, 0x66, 0x61, 0x6c, 0x73, 0x65); // false
+  if (code == 0x6e) return scanLiteral(ptr, end, 0x6e, 0x75, 0x6c, 0x6c); // null
+  return scanJSONNumber(ptr, end);
+}
+
+// JSONTestSuite's implementation-defined UTF-16-without-BOM fixtures arrive
+// in an AssemblyScript string as alternating byte-valued code units. Recover
+// the intended UTF-16 code units before validating or dispatching them.
+export function normalizeJSONEncoding(data: string): string {
+  const length = data.length;
+  if (length < 4) return data;
+
+  let byteIndex = -1;
+  if (data.charCodeAt(0) == 0) {
+    byteIndex = 0; // UTF-16BE bytes: NUL, code unit, NUL, code unit, ...
+  } else if (data.charCodeAt(1) == 0) {
+    byteIndex = 1; // UTF-16LE bytes: code unit, NUL, code unit, NUL, ...
+  } else {
+    return data;
+  }
+
+  for (let i = byteIndex; i < length; i += 2) {
+    if (data.charCodeAt(i) != 0) return data;
+  }
+
+  let out = "";
+  const codeIndex = byteIndex ^ 1;
+  for (let i = codeIndex; i < length; i += 2)
+    out += String.fromCharCode(data.charCodeAt(i));
+  return out;
+}
+
+export function validateJSON(data: string): bool {
+  let ptr = changetype<usize>(data);
+  const end = ptr + ((<usize>data.length) << 1);
+  ptr = skipJSONWhitespace(ptr, end);
+  if (ptr >= end) return false;
+
+  jsonStateDepth = 0;
+  ptr = scanJSONValue(ptr, end);
+  if (!ptr) return false;
+  let rootComplete = jsonStateDepth == 0;
+
+  while (true) {
+    ptr = skipJSONWhitespace(ptr, end);
+    if (jsonStateDepth == 0) return rootComplete && ptr == end;
+    if (ptr >= end) return false;
+
+    const top = jsonStateDepth - 1;
+    const state = unchecked(JSON_STATE_STACK[top]);
+    const code = load<u16>(ptr);
+
+    if (state == ARRAY_FIRST_OR_END) {
+      if (code == 0x5d) {
+        jsonStateDepth--;
+        ptr += 2;
+        if (jsonStateDepth == 0) rootComplete = true;
+      } else {
+        unchecked((JSON_STATE_STACK[top] = ARRAY_COMMA_OR_END));
+        ptr = scanJSONValue(ptr, end);
+        if (!ptr) return false;
+      }
+    } else if (state == ARRAY_VALUE) {
+      unchecked((JSON_STATE_STACK[top] = ARRAY_COMMA_OR_END));
+      ptr = scanJSONValue(ptr, end);
+      if (!ptr) return false;
+    } else if (state == ARRAY_COMMA_OR_END) {
+      if (code == 0x2c) {
+        unchecked((JSON_STATE_STACK[top] = ARRAY_VALUE));
+        ptr += 2;
+      } else if (code == 0x5d) {
+        jsonStateDepth--;
+        ptr += 2;
+        if (jsonStateDepth == 0) rootComplete = true;
+      } else {
+        return false;
+      }
+    } else if (state == OBJECT_FIRST_KEY_OR_END) {
+      if (code == 0x7d) {
+        jsonStateDepth--;
+        ptr += 2;
+        if (jsonStateDepth == 0) rootComplete = true;
+      } else {
+        ptr = scanJSONString(ptr, end);
+        if (!ptr) return false;
+        unchecked((JSON_STATE_STACK[top] = OBJECT_COLON));
+      }
+    } else if (state == OBJECT_KEY) {
+      ptr = scanJSONString(ptr, end);
+      if (!ptr) return false;
+      unchecked((JSON_STATE_STACK[top] = OBJECT_COLON));
+    } else if (state == OBJECT_COLON) {
+      if (code != 0x3a) return false;
+      unchecked((JSON_STATE_STACK[top] = OBJECT_VALUE));
+      ptr += 2;
+    } else if (state == OBJECT_VALUE) {
+      unchecked((JSON_STATE_STACK[top] = OBJECT_COMMA_OR_END));
+      ptr = scanJSONValue(ptr, end);
+      if (!ptr) return false;
+    } else {
+      if (code == 0x2c) {
+        unchecked((JSON_STATE_STACK[top] = OBJECT_KEY));
+        ptr += 2;
+      } else if (code == 0x7d) {
+        jsonStateDepth--;
+        ptr += 2;
+        if (jsonStateDepth == 0) rootComplete = true;
+      } else {
+        return false;
+      }
+    }
+  }
+}