json-as 1.4.0 → 1.5.0

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));
 }
 
@@ -213,8 +211,7 @@ export function itoaU64(buf: usize, v: u64): u32 {
  *
  * 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;

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/scanValueEndSimd.ts

@@ -4,6 +4,7 @@ import {
   BRACE_RIGHT,
   BRACKET_LEFT,
   BRACKET_RIGHT,
+  COLON,
   COMMA,
   QUOTE,
 } from "../custom/chars";
@@ -22,23 +23,40 @@ import { isSpace } from "./isSpace";
 // @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
+// (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);
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function quoteOrBackslashMask(block: v128): i32 {
+function quoteOrBackslashMask(block: v128): i32 {
   return i16x8.bitmask(
     v128.or(i16x8.eq(block, SPLAT_QUOTE), i16x8.eq(block, SPLAT_BACK_SLASH)),
   );
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function scalarTerminatorMask(block: v128): i32 {
+// 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),
@@ -86,12 +104,14 @@ function scanQuotedValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
 }
 
 function scanCompositeValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
-  // Track object/array depth scalar-side (structural tokens are sparse and a
-  // bulk token-mask scan loses to a tight loop on token-dense objects), but
-  // skip nested string VALUES with the vectorized quoted scan — that's where
-  // the long runs (URLs, base64, prose) actually are.
+  // 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) {
@@ -99,12 +119,34 @@ function scanCompositeValueEnd_SIMD(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) {
+      // `[` or `{`
       depth++;
-    } else if (code == BRACE_RIGHT || code == BRACKET_RIGHT) {
+      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;
 }
@@ -135,11 +177,7 @@ function scanScalarValueEnd_SIMD(srcStart: usize, srcEnd: usize): usize {
   return srcStart;
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline export function scanValueEnd_SIMD<T>(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+export function scanValueEnd_SIMD<T>(srcStart: usize, srcEnd: usize): usize {
   if (srcStart >= srcEnd) return 0;
   const first = load<u16>(srcStart);
 

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) |