json-as 1.3.9 → 1.5.0

package/assembly/util/atoi-fast.ts

@@ -18,11 +18,7 @@ import {
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, truncated to `T`.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function atou<T extends number>(
-  srcStart: usize,
-  srcEnd: usize,
-): T {
+export function atou<T extends number>(srcStart: usize, srcEnd: usize): T {
   return deserializeUnsigned_SWAR<T>(srcStart, srcEnd);
 }
 
@@ -34,11 +30,7 @@ import {
  * @param srcEnd   Pointer just past the last code unit.
  * @returns The parsed value, truncated to `T`.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function atoi<T extends number>(
-  srcStart: usize,
-  srcEnd: usize,
-): T {
+export function atoi<T extends number>(srcStart: usize, srcEnd: usize): T {
   return deserializeInteger_SWAR<T>(srcStart, srcEnd);
 }
 
@@ -52,8 +44,7 @@ import {
  * @param dstPtr   Destination pointer for the parsed value.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function atouScan<T extends number>(
+export function atouScan<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstPtr: usize,
@@ -71,8 +62,7 @@ import {
  * @param dstPtr   Destination pointer for the parsed value.
  * @returns The source position immediately after the last digit consumed.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function atoiScan<T extends number>(
+export function atoiScan<T extends number>(
   srcStart: usize,
   srcEnd: usize,
   dstPtr: usize,

package/assembly/util/atoi.ts

@@ -3,8 +3,7 @@
  * @param str
  * @returns
  */
-// @ts-ignore: inline
-@inline export function atoi<T>(srcStart: usize, srcEnd: usize): T {
+export function atoi<T>(srcStart: usize, srcEnd: usize): T {
   // @ts-ignore: type
   let val: T = 0;
   if (isSigned<T>()) {

package/assembly/util/bytes.ts

@@ -1,7 +1,6 @@
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
-// @ts-ignore: Decorator valid here
-@inline export function bytes<T>(o: T): i32 {
+export function bytes<T>(o: T): i32 {
   if (isInteger<T>() || isFloat<T>()) {
     return sizeof<T>();
   } else if (isManaged<T>() || isReference<T>()) {

package/assembly/util/idofd.ts

@@ -1,6 +1,5 @@
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
-// @ts-ignore: decorator
-@inline export function idofD<T>(value: T): usize {
+export function idofD<T>(value: T): usize {
   return changetype<OBJECT>(changetype<usize>(value) - TOTAL_OVERHEAD).rtId;
 }

package/assembly/util/isSpace.ts

@@ -1,4 +1,3 @@
-// @ts-ignore
-@inline export function isSpace(code: u16): boolean {
+export function isSpace(code: u16): boolean {
   return code == 0x20 || code - 9 <= 4;
 }

package/assembly/util/itoa-fast.ts

@@ -6,8 +6,8 @@
 // below. Two reasons:
 //
 //   1. V8/wasm lowers `v / 100` (and other `/ <const>`s) to a single
-//      multiply-shift, so jeaiii's main selling point — avoiding division
-//      hardware — gives no win on this target. The op counts come out
+//      multiply-shift, so jeaiii's main selling point - avoiding division
+//      hardware - gives no win on this target. The op counts come out
 //      roughly equal.
 //
 //   2. The div-by-const variant computes each digit pair independently
@@ -24,7 +24,7 @@
 //   - A 100-entry digit-pair LUT keyed on `value % 100`. One `store<u32>`
 //     emits a UTF-16 pair.
 //
-//   - Forward write in one pass — no `decimalCount32` precomputation, no
+//   - Forward write in one pass - no `decimalCount32` precomputation, no
 //     backward write.
 //
 // Reference H2H bench: `__benches__/custom/itoa-h2h.bench.ts`.
@@ -43,13 +43,11 @@ function initPairs(): void {
   _pairsInited = true;
 }
 
-
-@inline export function ensureItoaPairs(): void {
+export function ensureItoaPairs(): void {
   if (!_pairsInited) initPairs();
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function pair(i: u32): u32 {
+function pair(i: u32): u32 {
   return load<u32>(DIGIT_PAIRS_UTF16 + ((<usize>i) << 2));
 }
 
@@ -59,8 +57,7 @@ function initPairs(): void {
  * a byte offset). Caller must ensure the buffer has at least 20 bytes
  * available (max 10 chars).
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function itoaU32(buf: usize, v: u32): u32 {
+export function itoaU32(buf: usize, v: u32): u32 {
   if (v < 10) {
     store<u16>(buf, <u16>(v + 0x30));
     return 1;
@@ -165,8 +162,7 @@ function initPairs(): void {
  * Writes a u32 in the range 0..99_999_999 as exactly 8 UTF-16 chars with
  * leading zeros. Used by the u64 path to emit trailing groups of 8 digits.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function writeU32Padded8(buf: usize, v: u32): void {
+function writeU32Padded8(buf: usize, v: u32): void {
   const a = v / 1_000_000;
   let rest = v - a * 1_000_000;
   const b = rest / 10_000;
@@ -187,8 +183,7 @@ function initPairs(): void {
  * For 17+ digit values (which still fit in u64 < 1.8e19), repeat.
  * Caller must ensure the buffer has at least 40 bytes available.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function itoaU64(buf: usize, v: u64): u32 {
+export function itoaU64(buf: usize, v: u64): u32 {
   if (v <= <u64>u32.MAX_VALUE) {
     return itoaU32(buf, <u32>v);
   }
@@ -216,8 +211,7 @@ function initPairs(): void {
  *
  * Returns the number of UTF-16 chars written.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function itoaFast<T extends number>(buf: usize, value: T): u32 {
+export function itoaFast<T extends number>(buf: usize, value: T): u32 {
   if (sizeof<T>() <= 4) {
     if (isSigned<T>()) {
       let v = <i32>value;

package/assembly/util/nextPowerOf2.ts

@@ -1,4 +1,3 @@
-// @ts-ignore: Decorator valid here
-@inline export function nextPowerOf2(n: u32): u32 {
+export function nextPowerOf2(n: u32): u32 {
   return 1 << (32 - clz(n - 1));
 }

package/assembly/util/parsefloat-fast.ts

@@ -3,7 +3,7 @@ import { ptrToStr } from "./ptrToStr";
 // Lemire-style fast float parser.
 //
 // Reference: Daniel Lemire, "Number parsing at a gigabyte per second"
-// (2021). https://arxiv.org/abs/2101.11408 — implemented in
+// (2021). https://arxiv.org/abs/2101.11408 - implemented in
 // https://github.com/fastfloat/fast_float.
 //
 // The "fast path" applies when:
@@ -35,13 +35,11 @@ const MAX_EXACT_POW10: i32 = 22;
 // 2^53 = 9_007_199_254_740_992. Any u64 <= this is exact in f64.
 const MAX_EXACT_MANTISSA: u64 = 1 << 53;
 
-
-@inline function loadPow10(exp: u32): f64 {
+function loadPow10(exp: u32): f64 {
   return load<f64>(POW10_F64_POS + ((<usize>exp) << 3));
 }
 
-
-@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+function fallback<T>(srcStart: usize, srcEnd: usize): T {
   const s = ptrToStr(srcStart, srcEnd);
   // @ts-ignore: type
   const type: T = 0;
@@ -64,8 +62,7 @@ const MAX_EXACT_MANTISSA: u64 = 1 << 53;
  * exact through accumulation and only loses precision at the final
  * `<f64>` cast.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function parseFloatFast<T>(srcStart: usize, srcEnd: usize): T {
+export function parseFloatFast<T>(srcStart: usize, srcEnd: usize): T {
   const origStart = srcStart;
   let p = srcStart;
   let negative = false;

package/assembly/util/ptrToStr.ts

@@ -1,5 +1,4 @@
-// @ts-ignore: decorator
-@inline export function ptrToStr(start: usize, end: usize): string {
+export function ptrToStr(start: usize, end: usize): string {
   const size = end - start;
   const out = __new(size, idof<string>());
   memory.copy(out, start, size);

package/assembly/util/scanValueEnd.ts

@@ -27,8 +27,7 @@ import { scanStringEnd } from "./stringScan";
  * but stays scalar so `naive/` callers don't pull SWAR into the correctness
  * baseline.
  */
-// @ts-ignore: inline
-@inline export function scanValueEnd(srcStart: usize, srcEnd: usize): usize {
+export function scanValueEnd<T = usize>(srcStart: usize, srcEnd: usize): usize {
   if (srcStart >= srcEnd) return 0;
   const first = load<u16>(srcStart);
 

package/assembly/util/scanValueEndSimd.ts

@@ -0,0 +1,198 @@
+import {
+  BACK_SLASH,
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COLON,
+  COMMA,
+  QUOTE,
+} from "../custom/chars";
+import { isSpace } from "./isSpace";
+
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_QUOTE = i16x8.splat(<i16>QUOTE);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BACK_SLASH = i16x8.splat(<i16>BACK_SLASH);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BRACE_RIGHT = i16x8.splat(<i16>BRACE_RIGHT);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BRACKET_RIGHT = i16x8.splat(<i16>BRACKET_RIGHT);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_COMMA = i16x8.splat(<i16>COMMA);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_SPACE = i16x8.splat(0x20);
+// JSON whitespace besides space is the contiguous range 0x09..0x0d
+// (tab/LF/VT/FF/CR), matched as `(c - 9) u<= 4` - one sub + one unsigned
+// compare instead of five equality tests. Exact: matches `isSpace` with no
+// false positives.
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_WS_LO = i16x8.splat(0x09);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_WS_SPAN = i16x8.splat(0x04);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BRACKET_LEFT = i16x8.splat(<i16>BRACKET_LEFT);
+// Clears bit 5 (0x20), folding `{`/`}` onto `[`/`]` so one pair of compares
+// matches either bracket flavor. No ASCII char besides `[{`/`]}` folds onto
+// `[`/`]`, so the structural mask stays exact.
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_BRACKET_FOLD = i16x8.splat(<i16>0xffdf);
+
+function quoteOrBackslashMask(block: v128): i32 {
+  return i16x8.bitmask(
+    v128.or(i16x8.eq(block, SPLAT_QUOTE), i16x8.eq(block, SPLAT_BACK_SLASH)),
+  );
+}
+
+// Lanes equal to `"`, `{`, `}`, `[`, or `]` - the only bytes that, outside a
+// string, change depth or open a string. Everything else (digits, `:`, `,`,
+// whitespace, true/false/null) can be bulk-skipped between them.
+function structuralOrQuoteMask(block: v128): i32 {
+  const folded = v128.and(block, SPLAT_BRACKET_FOLD);
+  const brackets = v128.or(
+    i16x8.eq(folded, SPLAT_BRACKET_LEFT),
+    i16x8.eq(folded, SPLAT_BRACKET_RIGHT),
+  );
+  return i16x8.bitmask(v128.or(brackets, i16x8.eq(block, SPLAT_QUOTE)));
+}
+
+function scalarTerminatorMask(block: v128): i32 {
+  const structural = v128.or(
+    v128.or(i16x8.eq(block, SPLAT_COMMA), i16x8.eq(block, SPLAT_BRACE_RIGHT)),
+    i16x8.eq(block, SPLAT_BRACKET_RIGHT),
+  );
+  // (c - 9) u<= 4  covers tab/LF/VT/FF/CR; space handled separately.
+  const whitespace = v128.or(
+    i16x8.le_u(i16x8.sub(block, SPLAT_WS_LO), SPLAT_WS_SPAN),
+    i16x8.eq(block, SPLAT_SPACE),
+  );
+  return i16x8.bitmask(v128.or(structural, whitespace));
+}
+
+function scanQuotedValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
+  srcStart += 2;
+  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+
+  while (srcStart <= srcEnd16) {
+    const block = load<v128>(srcStart);
+    const mask = quoteOrBackslashMask(block);
+    if (mask == 0) {
+      srcStart += 16;
+      continue;
+    }
+
+    const laneIdx = usize(ctz(mask) << 1);
+    const srcIdx = srcStart + laneIdx;
+    const code = load<u16>(srcIdx);
+    if (code == QUOTE) return srcIdx + 2;
+    if (srcIdx + 2 >= srcEnd) return 0;
+    srcStart = srcIdx + 4;
+  }
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == QUOTE) return srcStart + 2;
+    if (code == BACK_SLASH) {
+      if (srcStart + 2 >= srcEnd) return 0;
+      srcStart += 4;
+      continue;
+    }
+    srcStart += 2;
+  }
+
+  return 0;
+}
+
+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 `"`/`{`/`}`/`[`/`]`.
+  let depth: i32 = 1;
+  let ptr = srcStart + 2;
+  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+  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;
+      }
+      ptr += usize(ctz(mask) << 1);
+      break;
+    }
+  }
+  return 0;
+}
+
+function scanScalarValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
+  const srcEnd16 = srcEnd >= 16 ? srcEnd - 16 : 0;
+  while (srcStart <= srcEnd16) {
+    const mask = scalarTerminatorMask(load<v128>(srcStart));
+    if (mask == 0) {
+      srcStart += 16;
+      continue;
+    }
+    return srcStart + usize(ctz(mask) << 1);
+  }
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (
+      code == COMMA ||
+      code == BRACKET_RIGHT ||
+      code == BRACE_RIGHT ||
+      isSpace(code)
+    )
+      return srcStart;
+    srcStart += 2;
+  }
+
+  return srcStart;
+}
+
+export function scanValueEnd_SIMD<T>(srcStart: usize, srcEnd: usize): usize {
+  if (srcStart >= srcEnd) return 0;
+  const first = load<u16>(srcStart);
+
+  if (isString<nonnull<T>>() && first == QUOTE)
+    return scanQuotedValueEnd_SIMD(srcStart, srcEnd);
+  if (isArray<nonnull<T>>() && first == BRACKET_LEFT)
+    return scanCompositeValueEnd_SIMD(srcStart, srcEnd);
+  if (
+    (isManaged<nonnull<T>>() || isReference<nonnull<T>>()) &&
+    first == BRACE_LEFT
+  )
+    return scanCompositeValueEnd_SIMD(srcStart, srcEnd);
+
+  if (first == QUOTE) return scanQuotedValueEnd_SIMD(srcStart, srcEnd);
+  if (first == BRACE_LEFT || first == BRACKET_LEFT)
+    return scanCompositeValueEnd_SIMD(srcStart, srcEnd);
+  return scanScalarValueEnd_SIMD(srcStart, srcEnd);
+}

package/assembly/util/scanValueEndSwar.ts

@@ -0,0 +1,184 @@
+import {
+  BACK_SLASH,
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COLON,
+  COMMA,
+  QUOTE,
+} from "../custom/chars";
+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 -
+// 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).
+
+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.
+function eqPart(block: u64, splat: u64): u64 {
+  const t = block ^ splat;
+  return (t - ONES) & ~t;
+}
+
+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;
+
+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;
+
+  // Fast-skip 8-byte windows until a real quote (return) or a backslash, then
+  // hand off to the precise scalar tail (which resolves escape runs). The mask
+  // is a filter, so each candidate lane is verified with a real `load<u16>`;
+  // non-ASCII lanes that spuriously match are skipped (neither quote nor
+  // backslash), and `srcStart` is left at the window start for the tail.
+  while (srcStart <= srcEnd8) {
+    let mask = quoteOrBackslashMask(load<u64>(srcStart));
+    if (mask == 0) {
+      srcStart += 8;
+      continue;
+    }
+    do {
+      const srcIdx = srcStart + (usize(ctz(mask)) >> 3);
+      mask &= mask - 1;
+      const code = load<u16>(srcIdx);
+      if (code == QUOTE) return srcIdx + 2;
+      if (code == BACK_SLASH) break;
+    } while (mask != 0);
+    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 == BACK_SLASH) {
+      srcStart += 4;
+      continue;
+    }
+    if (code == QUOTE) return srcStart + 2;
+    srcStart += 2;
+  }
+  return 0;
+}
+
+function scanCompositeValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
+  // 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) {
+      ptr = scanQuotedValueEnd_SWAR(ptr, srcEnd);
+      if (!ptr) return 0;
+      continue;
+    }
+    const folded = code & 0xffdf;
+    if (folded == BRACKET_LEFT) {
+      depth++;
+      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;
+}
+
+function scanScalarValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
+  // Scalars (number/true/false/null) are short, so a plain scalar terminator
+  // scan beats setting up SWAR masks per word.
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (
+      code == COMMA ||
+      code == BRACKET_RIGHT ||
+      code == BRACE_RIGHT ||
+      isSpace(code)
+    )
+      return srcStart;
+    srcStart += 2;
+  }
+  return srcStart;
+}
+
+/**
+ * SWAR `scanValueEnd`: position just past the value at `srcStart`. Strings and
+ * objects/arrays use the SWAR token scans above; scalars use a short scalar
+ * loop. Returns 0 on empty input or an unterminated string/composite.
+ */
+export function scanValueEnd_SWAR<T>(srcStart: usize, srcEnd: usize): usize {
+  if (srcStart >= srcEnd) return 0;
+  const first = load<u16>(srcStart);
+
+  if (isString<nonnull<T>>() && first == QUOTE)
+    return scanQuotedValueEnd_SWAR(srcStart, srcEnd);
+  if (isArray<nonnull<T>>() && first == BRACKET_LEFT)
+    return scanCompositeValueEnd_SWAR(srcStart, srcEnd);
+  if (
+    (isManaged<nonnull<T>>() || isReference<nonnull<T>>()) &&
+    first == BRACE_LEFT
+  )
+    return scanCompositeValueEnd_SWAR(srcStart, srcEnd);
+
+  if (first == QUOTE) return scanQuotedValueEnd_SWAR(srcStart, srcEnd);
+  if (first == BRACE_LEFT || first == BRACKET_LEFT)
+    return scanCompositeValueEnd_SWAR(srcStart, srcEnd);
+  return scanScalarValueEnd_SWAR(srcStart, srcEnd);
+}

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);
@@ -54,8 +51,7 @@ const POWERS5: usize = memory.data<i32>([
   );
 }
 
-// @ts-ignore: inline
-@inline function scaledown(significand: u64, exp: i32): f64 {
+function scaledown(significand: u64, exp: i32): f64 {
   const denom: u64 = 6103515625; // 1e14 * 0x1p-14
   const scale = reinterpret<f64>(0x3f06849b86a12b9b); // 1e-14 * 0x1p32
 
@@ -82,8 +78,7 @@ const POWERS5: usize = memory.data<i32>([
   return NativeMath.scalbn(<f64>significand, <i32>shift);
 }
 
-// @ts-ignore: inline
-@inline function scaleup(significand: u64, exp: i32): f64 {
+function scaleup(significand: u64, exp: i32): f64 {
   const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;
   let shift = ctz(significand);
   significand >>= shift;
@@ -100,7 +95,7 @@ const POWERS5: usize = memory.data<i32>([
 
 /**
  * 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
@@ -111,8 +106,7 @@ const POWERS5: usize = memory.data<i32>([
  * @param exp Decimal exponent (e.g. for "12.34" pass 1234 and -2)
  * @returns The correctly rounded f64, or 0 / Infinity at the extremes.
  */
-// @ts-ignore: inline
-@inline export function scientific(significand: u64, exp: i32): f64 {
+export function scientific(significand: u64, exp: i32): f64 {
   if (!significand || exp < -342) return 0;
   if (exp > 308) return Infinity;
   let significandf = <f64>significand;