json-as 1.5.0 → 1.6.0

package/assembly/serialize/index/bool.ts

@@ -1 +1 @@
-export { serializeBool } from "../naive/bool";
+export { serializeBool, serializeBoolUnsafe } from "../naive/bool";

package/assembly/serialize/index/float.ts

@@ -1,5 +1 @@
-export {
-  serializeFloat,
-  serializeFloat32,
-  serializeFloat64,
-} from "../naive/float";
+export { serializeFloat32, serializeFloat64 } from "../naive/float";

package/assembly/serialize/index/integer.ts

@@ -1 +1 @@
-export { serializeInteger } from "../naive/integer";
+export { serializeInteger, serializeIntegerUnsafe } from "../naive/integer";

package/assembly/serialize/index/object.ts

@@ -5,6 +5,23 @@ import { serializeArbitrary } from "./arbitrary";
 import { serializeStringRange } from "../naive/string";
 
 export function serializeObject(src: JSON.Obj): void {
+  const rawStart = src._rawStart;
+  if (rawStart != 0) {
+    const rawSize = src._rawEnd - rawStart;
+    // At top level, `bs.out` can copy the anchored source slice straight into
+    // the returned string. Nested objects already have parent bytes in the
+    // staging buffer and therefore keep the regular append path below.
+    if (bs.offset == bs.buffer && bs.cacheOutput == 0) {
+      bs.cacheOutput = rawStart;
+      bs.cacheOutputLen = rawSize;
+      return;
+    }
+    bs.proposeSize(rawSize);
+    memory.copy(bs.offset, rawStart, rawSize);
+    bs.offset += rawSize;
+    return;
+  }
+
   const srcSize = src.size;
 
   if (srcSize == 0) {

package/assembly/serialize/naive/array.ts

@@ -5,6 +5,7 @@ import { serializeBoolUnsafe } from "./bool";
 import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 import { serializeString } from "../index/string";
+import { ensureItoaPairs, itoaFast } from "../../util/itoa-fast";
 import { dtoa_buffered, ftoa_buffered } from "xjb-as";
 
 function maxIntegerBytes<T extends number>(): u32 {
@@ -265,6 +266,59 @@ function serializeI8ArrayFast(src: i8[]): void {
   store<u16>(bs.offset - 2, BRACKET_RIGHT);
 }
 
+// Integer arrays wider than one byte use the same uniform trailing-comma
+// layout as the specialized float paths. Keeping the output cursor local
+// avoids two global `bs.offset` accesses per value, while reading dataStart
+// directly removes the Array.__uget call left in the generic array loop.
+function serializeIntegerArrayFast<T extends number[]>(src: T): void {
+  const len = src.length;
+  bs.proposeSize(4 + <u32>len * (maxIntegerBytes<valueof<T>>() + 2));
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+  if (len == 0) {
+    store<u16>(bs.offset, BRACKET_RIGHT);
+    bs.offset += 2;
+    return;
+  }
+
+  ensureItoaPairs();
+  const dataStart = src.dataStart;
+  const stride = sizeof<valueof<T>>();
+  let offset = bs.offset;
+  for (let i: i32 = 0; i < len; i++) {
+    const value = load<valueof<T>>(dataStart + <usize>i * stride);
+    offset += (<usize>itoaFast<valueof<T>>(offset, value)) << 1;
+    store<u16>(offset, COMMA);
+    offset += 2;
+  }
+  store<u16>(offset - 2, BRACKET_RIGHT);
+  bs.offset = offset;
+}
+
+function serializeStringArrayFast(src: string[]): void {
+  const len = src.length;
+  // String serialization reserves its own payload; reserve delimiters here.
+  bs.proposeSize(4 + (len > 0 ? <u32>(len - 1) * 2 : 0));
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+  if (len == 0) {
+    store<u16>(bs.offset, BRACKET_RIGHT);
+    bs.offset += 2;
+    return;
+  }
+
+  const dataStart = src.dataStart;
+  for (let i: i32 = 0; i < len; i++) {
+    const value = changetype<string>(
+      load<usize>(dataStart + ((<usize>i) << 2)),
+    );
+    serializeString(value);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+  store<u16>(bs.offset - 2, BRACKET_RIGHT);
+}
+
 export function serializeArray<T extends any[]>(src: T): void {
   // Specialized fast paths fold the per-element comma into the element write,
   // saving one `store<u16>` + advance per iteration. AS folds the type checks
@@ -292,6 +346,16 @@ export function serializeArray<T extends any[]>(src: T): void {
     serializeI8ArrayFast(changetype<i8[]>(src));
     return;
   }
+  if (isInteger<valueof<T>>()) {
+    // u8[] and i8[] returned through their lookup-table paths above.
+    serializeIntegerArrayFast<T>(src);
+    return;
+  }
+  if (isString<valueof<T>>()) {
+    // @ts-expect-error: T is string[]
+    serializeStringArrayFast(changetype<string[]>(src));
+    return;
+  }
   if (isFloat<valueof<T>>() && sizeof<valueof<T>>() == 8) {
     // @ts-expect-error: T is f64[]
     serializeF64ArrayFast(changetype<f64[]>(src));

package/assembly/serialize/naive/float.ts

@@ -27,8 +27,3 @@ export function serializeFloat64(data: f64): void {
   bs.stackSize += bytes;
   bs.offset += bytes;
 }
-
-export function serializeFloat<T extends number>(data: T): void {
-  if (sizeof<T>() == 4) serializeFloat32(<f32>data);
-  else serializeFloat64(<f64>data);
-}

package/assembly/serialize/naive/map.ts

@@ -1,6 +1,34 @@
 import { bs } from "../../../lib/as-bs";
 import { JSON } from "../..";
 import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
+import { serializeString } from "../index/string";
+import { serializeRaw } from "./raw";
+
+function serializeRawMapFast<T extends Map<any, any>>(
+  keys: Array<indexof<T>>,
+  values: Array<valueof<T>>,
+): void {
+  const len = keys.length;
+  bs.proposeSize(4 + <u32>len * 4);
+  store<u16>(bs.offset, BRACE_LEFT);
+  bs.offset += 2;
+
+  const keyData = keys.dataStart;
+  const valueData = values.dataStart;
+  for (let i = 0; i < len; i++) {
+    const key = changetype<string>(load<usize>(keyData + ((<usize>i) << 2)));
+    const value = changetype<JSON.Raw>(
+      load<usize>(valueData + ((<usize>i) << 2)),
+    );
+    serializeString(key);
+    store<u16>(bs.offset, COLON);
+    bs.offset += 2;
+    serializeRaw(value);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+  store<u16>(bs.offset - 2, BRACE_RIGHT);
+}
 
 export function serializeMap<T extends Map<any, any>>(src: T): void {
   const srcSize = src.size;
@@ -17,6 +45,15 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
   let values = src.values();
   const keyIsString = isString<indexof<T>>();
 
+  if (keyIsString && isReference<valueof<T>>()) {
+    const valueType = changetype<nonnull<valueof<T>>>(0);
+    // @ts-ignore: instanceof on the reference value type
+    if (valueType instanceof JSON.Raw) {
+      serializeRawMapFast<T>(keys, values);
+      return;
+    }
+  }
+
   bs.proposeSize(4 + <u32>(srcSize - 1) * 2 + <u32>srcSize * 2);
 
   store<u16>(bs.offset, BRACE_LEFT);

package/assembly/serialize/naive/set.ts

@@ -14,7 +14,6 @@ function maxIntegerBytes<T extends number>(): u32 {
 }
 
 function reservePrimitiveSet<T>(len: i32): void {
-  if (len <= 0) return;
   if (isBoolean<T>()) {
     bs.proposeSize(4 + <u32>len * 12);
   } else if (isInteger<T>()) {

package/assembly/serialize/naive/staticarray.ts

@@ -13,7 +13,6 @@ function maxIntegerBytes<T extends number>(): u32 {
   return isSigned<T>() ? 42 : 40;
 }
 function reservePrimitiveStaticArray<T>(len: i32): void {
-  if (len <= 0) return;
   if (isBoolean<T>()) {
     bs.proposeSize(4 + <u32>len * 12);
   } else if (isInteger<T>()) {

package/assembly/serialize/naive/string.ts

@@ -85,9 +85,3 @@ export function serializeStringRange(srcPtr: usize, srcSize: usize): void {
   store<u16>(bs.offset, QUOTE);
   bs.offset += 2;
 }
-function write_u_escape(code: u16): void {
-  bs.growSize(10);
-  store<u32>(bs.offset, U_MARKER); // "\u"
-  store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
-  bs.offset += 12;
-}

package/assembly/serialize/naive/typedarray.ts

@@ -11,7 +11,6 @@ function maxIntegerBytes<T extends number>(): u32 {
 }
 
 function reserveTypedArray<T extends ArrayLike<number>>(len: i32): void {
-  if (len <= 0) return;
   if (isFloat<valueof<T>>()) {
     bs.proposeSize(4 + <u32>len * (sizeof<valueof<T>>() == 4 ? 34 : 66));
   } else {

package/assembly/util/eisel-lemire.ts

@@ -0,0 +1,179 @@
+// Fast, correctly-rounded conversion of `mantissa * 10^power` for the common
+// decimal-exponent range [-22, 22]. This is the Eisel-Lemire conversion used by
+// simdjson's number parser, specialized to the range where json-as previously
+// fell into `scientific()` after the exact-Clinger path rejected mantissas above
+// 2^53. Keeping only 45 cached powers costs 720 bytes instead of simdjson's
+// general 10 KiB table; callers retain `scientific()` as the wide-range fallback.
+
+// Consecutive {primary, secondary} truncated 128-bit powers of five for decimal
+// exponents -22 through 22. Sourced from simdjson's power_of_five_128 table.
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const POWERS_OF_FIVE_128: usize = memory.data<u64>([
+  0xf1c90080baf72cb1, 0x5324c68b12dd6800, 0x971da05074da7bee,
+  0xd3f6fc16ebca8000, 0xbce5086492111aea, 0x88f4bb1ca6bd0000,
+  0xec1e4a7db69561a5, 0x2b31e9e3d0700000, 0x9392ee8e921d5d07,
+  0x3aff322e62600000, 0xb877aa3236a4b449, 0x09befeb9fad487c3,
+  0xe69594bec44de15b, 0x4c2ebe687989a9b4, 0x901d7cf73ab0acd9,
+  0x0f9d37014bf60a11, 0xb424dc35095cd80f, 0x538484c19ef38c95,
+  0xe12e13424bb40e13, 0x2865a5f206b06fba, 0x8cbccc096f5088cb,
+  0xf93f87b7442e45d4, 0xafebff0bcb24aafe, 0xf78f69a51539d749,
+  0xdbe6fecebdedd5be, 0xb573440e5a884d1c, 0x89705f4136b4a597,
+  0x31680a88f8953031, 0xabcc77118461cefc, 0xfdc20d2b36ba7c3e,
+  0xd6bf94d5e57a42bc, 0x3d32907604691b4d, 0x8637bd05af6c69b5,
+  0xa63f9a49c2c1b110, 0xa7c5ac471b478423, 0x0fcf80dc33721d54,
+  0xd1b71758e219652b, 0xd3c36113404ea4a9, 0x83126e978d4fdf3b,
+  0x645a1cac083126ea, 0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4,
+  0xcccccccccccccccc, 0xcccccccccccccccd, 0x8000000000000000,
+  0x0000000000000000, 0xa000000000000000, 0x0000000000000000,
+  0xc800000000000000, 0x0000000000000000, 0xfa00000000000000,
+  0x0000000000000000, 0x9c40000000000000, 0x0000000000000000,
+  0xc350000000000000, 0x0000000000000000, 0xf424000000000000,
+  0x0000000000000000, 0x9896800000000000, 0x0000000000000000,
+  0xbebc200000000000, 0x0000000000000000, 0xee6b280000000000,
+  0x0000000000000000, 0x9502f90000000000, 0x0000000000000000,
+  0xba43b74000000000, 0x0000000000000000, 0xe8d4a51000000000,
+  0x0000000000000000, 0x9184e72a00000000, 0x0000000000000000,
+  0xb5e620f480000000, 0x0000000000000000, 0xe35fa931a0000000,
+  0x0000000000000000, 0x8e1bc9bf04000000, 0x0000000000000000,
+  0xb1a2bc2ec5000000, 0x0000000000000000, 0xde0b6b3a76400000,
+  0x0000000000000000, 0x8ac7230489e80000, 0x0000000000000000,
+  0xad78ebc5ac620000, 0x0000000000000000, 0xd8d726b7177a8000,
+  0x0000000000000000, 0x878678326eac9000, 0x0000000000000000,
+]);
+
+// High half of a full 64x64 -> 128 multiplication, using four 32-bit partial
+// products. WebAssembly MVP has no i128 or mul-high instruction.
+function mul64High(a: u64, b: u64): u64 {
+  const aLo = <u64>(<u32>a);
+  const aHi = a >> 32;
+  const bLo = <u64>(<u32>b);
+  const bHi = b >> 32;
+  const lowLow = aLo * bLo;
+  const highLow = aHi * bLo;
+  const middle = highLow + aLo * bHi;
+  const middleCarry = <u64>(middle < highLow);
+  const low = lowLow + (middle << 32);
+  return aHi * bHi + (middle >> 32) + (middleCarry << 32) + <u64>(low < lowLow);
+}
+
+/**
+ * Fixed-power Eisel-Lemire conversion for GeoJSON-style coordinates with 14
+ * fractional digits. This is the `power == -14` specialization of
+ * {@link eiselLemire22}: the cached-power address and binary-exponent base are
+ * constants, and the exact-halfway correction is unreachable for this power.
+ */
+export function eiselLemireMinus14(significand: u64): f64 {
+  let i = significand;
+  let leading = <i32>clz(i);
+  i <<= leading;
+
+  let lower = i * 0xb424dc35095cd80f;
+  let upper = mul64High(i, 0xb424dc35095cd80f);
+
+  if ((upper & 0x1ff) == 0x1ff) {
+    const secondUpper = mul64High(i, 0x538484c19ef38c95);
+    const oldLower = lower;
+    lower += secondUpper;
+    if (lower < oldLower) upper++;
+  }
+
+  const upperBit = upper >> 63;
+  let mantissa = upper >> (<i32>(upperBit + 9));
+  leading += <i32>(1 ^ upperBit);
+  let realExponent = 1040 - leading;
+
+  mantissa += mantissa & 1;
+  mantissa >>= 1;
+
+  if (mantissa >= (<u64>1) << 53) {
+    mantissa = (<u64>1) << 52;
+    realExponent++;
+  }
+
+  const bits = (mantissa & ~((<u64>1) << 52)) | ((<u64>realExponent) << 52);
+  return reinterpret<f64>(bits);
+}
+
+/** Fixed -14 conversion for significands in [2^53, 2^54). */
+export function eiselLemireMinus14_54Bit(significand: u64): f64 {
+  const i = significand << 10;
+
+  let lower = i * 0xb424dc35095cd80f;
+  let upper = mul64High(i, 0xb424dc35095cd80f);
+
+  if ((upper & 0x1ff) == 0x1ff) {
+    const secondUpper = mul64High(i, 0x538484c19ef38c95);
+    const oldLower = lower;
+    lower += secondUpper;
+    if (lower < oldLower) upper++;
+  }
+
+  const upperBit = upper >> 63;
+  let mantissa = upper >> (<i32>(upperBit + 9));
+  let realExponent = 1030 - <i32>(1 ^ upperBit);
+
+  mantissa += mantissa & 1;
+  mantissa >>= 1;
+
+  if (mantissa >= (<u64>1) << 53) {
+    mantissa = (<u64>1) << 52;
+    realExponent++;
+  }
+
+  const bits = (mantissa & ~((<u64>1) << 52)) | ((<u64>realExponent) << 52);
+  return reinterpret<f64>(bits);
+}
+
+/**
+ * Convert a non-zero u64 significand at a decimal exponent in [-22, 22].
+ * The result is correctly rounded to IEEE-754 binary64.
+ */
+export function eiselLemire22(significand: u64, power: i32): f64 {
+  let i = significand;
+  let leading = <i32>clz(i);
+  i <<= leading;
+
+  const tableIndex = (<usize>(power + 22)) << 4;
+  const factor = load<u64>(POWERS_OF_FIVE_128 + tableIndex);
+  let lower = i * factor;
+  let upper = mul64High(i, factor);
+
+  // A primary product ending in nine uncertain bits needs the second table
+  // limb. This is rare, but removes Eisel-Lemire's historical fallback.
+  if ((upper & 0x1ff) == 0x1ff) {
+    const secondUpper = mul64High(
+      i,
+      load<u64>(POWERS_OF_FIVE_128 + tableIndex, 8),
+    );
+    const oldLower = lower;
+    lower += secondUpper;
+    if (lower < oldLower) upper++;
+  }
+
+  const upperBit = upper >> 63;
+  let mantissa = upper >> (<i32>(upperBit + 9));
+  leading += <i32>(1 ^ upperBit);
+  let realExponent = <i32>(((<i64>217706 * power) >> 16) + 1087) - leading;
+  const halfwayShift = <i32>(upperBit + 9);
+
+  // Round exact halfway cases to even.
+  if (
+    lower <= 1 &&
+    power >= -4 &&
+    power <= 22 &&
+    (mantissa & 3) == 1 &&
+    mantissa << halfwayShift == upper
+  ) {
+    mantissa &= ~(<u64>1);
+  }
+  mantissa += mantissa & 1;
+  mantissa >>= 1;
+
+  if (mantissa >= (<u64>1) << 53) {
+    mantissa = (<u64>1) << 52;
+    realExponent++;
+  }
+
+  const bits = (mantissa & ~((<u64>1) << 52)) | ((<u64>realExponent) << 52);
+  return reinterpret<f64>(bits);
+}

package/assembly/util/prettyWhitespaceSimd.ts

@@ -0,0 +1,69 @@
+// Whitespace-run scanner selected once for large pretty JSON documents.
+
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_SPACE = i16x8.splat(0x20);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_WS_LO = i16x8.splat(9);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_WS_SPAN = i16x8.splat(4);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_LF = i16x8.splat(10);
+
+
+@inline
+function whitespaceMask(block: v128): i32 {
+  return i16x8.bitmask(
+    v128.or(
+      i16x8.eq(block, SPLAT_SPACE),
+      i16x8.le_u(i16x8.sub(block, SPLAT_WS_LO), SPLAT_WS_SPAN),
+    ),
+  );
+}
+
+/** Detect an eight-space indentation run near the document head. */
+export function hasLongPrettyIndent_SIMD(srcStart: usize, srcEnd: usize): bool {
+  const sampleEnd = min(srcEnd, srcStart + 4096);
+  const vectorEnd = sampleEnd >= 16 ? sampleEnd - 16 : 0;
+  while (srcStart <= vectorEnd) {
+    let mask = i16x8.bitmask(i16x8.eq(load<v128>(srcStart), SPLAT_LF));
+    while (mask != 0) {
+      const newline = srcStart + ((<usize>ctz(mask)) << 1);
+      if (
+        newline + 18 <= srcEnd &&
+        !v128.any_true(v128.xor(load<v128>(newline, 2), i16x8.splat(0x20)))
+      )
+        return true;
+      mask &= mask - 1;
+    }
+    srcStart += 16;
+  }
+  return false;
+}
+
+/** `srcStart` is known to point at JSON whitespace. */
+export function skipPrettyWhitespace_SIMD(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  srcStart += 2;
+  if (srcStart >= srcEnd) return srcStart;
+  let code = load<u16>(srcStart);
+  if (code != 0x20 && code - 9 > 4) return srcStart;
+
+  const vectorEnd = srcEnd >= 16 ? srcEnd - 16 : 0;
+  while (srcStart <= vectorEnd) {
+    const mask = whitespaceMask(load<v128>(srcStart));
+    if (mask == 0xff) {
+      srcStart += 16;
+      continue;
+    }
+    srcStart += (<usize>ctz(~mask & 0xff)) << 1;
+    return srcStart;
+  }
+  do {
+    srcStart += 2;
+    if (srcStart >= srcEnd) return srcStart;
+    code = load<u16>(srcStart);
+  } while (code == 0x20 || code - 9 <= 4);
+  return srcStart;
+}

package/assembly/util/scanValueEndSimd.ts

@@ -4,7 +4,6 @@ import {
   BRACE_RIGHT,
   BRACKET_LEFT,
   BRACKET_RIGHT,
-  COLON,
   COMMA,
   QUOTE,
 } from "../custom/chars";
@@ -104,49 +103,73 @@ function scanQuotedValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
 }
 
 function scanCompositeValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
-  // Process structural tokens scalar-side (cheap, and token-dense regions stay
-  // in a tight loop), but bulk-skip the bytes between them: nested string VALUES
-  // via the vectorized quoted scan (URLs, base64, prose), and runs of digits /
-  // punctuation / whitespace (numeric arrays like coordinate lists) via a
-  // vectorized hunt for the next `"`/`{`/`}`/`[`/`]`.
+  // Walk every structural event in a loaded block before advancing. This is
+  // substantially cheaper for object-heavy values than restarting a SIMD hunt
+  // after every short key: one v128 load now covers all quotes and brackets in
+  // its eight UTF-16 lanes. Brackets inside strings are ignored, and a closing
+  // quote is active only when preceded by an even-length backslash run.
   let depth: i32 = 1;
   let ptr = srcStart + 2;
   const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+  let inString = false;
+
+  while (ptr <= srcEnd16) {
+    let mask = structuralOrQuoteMask(load<v128>(ptr));
+    while (mask != 0) {
+      const lane = usize(ctz(mask) << 1);
+      mask &= mask - 1;
+      const eventPtr = ptr + lane;
+      const code = load<u16>(eventPtr);
+
+      if (code == QUOTE) {
+        if (!inString) {
+          inString = true;
+        } else {
+          let slash = eventPtr - 2;
+          let escaped = false;
+          while (slash > srcStart && load<u16>(slash) == BACK_SLASH) {
+            escaped = !escaped;
+            slash -= 2;
+          }
+          if (!escaped) inString = false;
+        }
+        continue;
+      }
+      if (inString) continue;
+
+      const folded = code & 0xffdf;
+      if (folded == BRACKET_LEFT) {
+        depth++;
+      } else if (folded == BRACKET_RIGHT && --depth == 0) {
+        return eventPtr + 2;
+      }
+    }
+    ptr += 16;
+  }
+
   while (ptr < srcEnd) {
     const code = load<u16>(ptr);
     if (code == QUOTE) {
-      ptr = scanQuotedValueEnd_SIMD(ptr, srcEnd);
-      if (!ptr) return 0;
-      continue;
-    }
-    const folded = code & 0xffdf;
-    if (folded == BRACKET_LEFT) {
-      // `[` or `{`
-      depth++;
-      ptr += 2;
-      continue;
-    }
-    if (folded == BRACKET_RIGHT) {
-      // `]` or `}`
-      if (--depth == 0) return ptr + 2;
-      ptr += 2;
-      continue;
-    }
-    ptr += 2;
-    // `,` and `:` sit one byte from the next token, so vectorizing them only
-    // adds SIMD setup on string-dense objects - stay scalar. Other fillers
-    // (number digits, whitespace, true/false/null) can run long; vectorize past
-    // them to the next `"`/`{`/`}`/`[`/`]`.
-    if (code == COMMA || code == COLON) continue;
-    while (ptr <= srcEnd16) {
-      const mask = structuralOrQuoteMask(load<v128>(ptr));
-      if (mask == 0) {
-        ptr += 16;
-        continue;
+      if (!inString) {
+        inString = true;
+      } else {
+        let slash = ptr - 2;
+        let escaped = false;
+        while (slash > srcStart && load<u16>(slash) == BACK_SLASH) {
+          escaped = !escaped;
+          slash -= 2;
+        }
+        if (!escaped) inString = false;
+      }
+    } else if (!inString) {
+      const folded = code & 0xffdf;
+      if (folded == BRACKET_LEFT) {
+        depth++;
+      } else if (folded == BRACKET_RIGHT && --depth == 0) {
+        return ptr + 2;
       }
-      ptr += usize(ctz(mask) << 1);
-      break;
     }
+    ptr += 2;
   }
   return 0;
 }