json-as 1.4.0 → 1.5.0

package/assembly/deserialize/simd/float.ts

@@ -3,7 +3,7 @@
 // `parse8Digits_SIMD` (16 bytes / 8 digits) before falling through to
 // `parse4Digits_PairMul` (8 bytes / 4 digits) and finally the scalar tail.
 //
-// Output is bit-identical to `f64.parse` / `f32.parse` for every input — the
+// Output is bit-identical to `f64.parse` / `f32.parse` for every input - the
 // SIMD strides only change how the u64 mantissa is accumulated, not what it
 // becomes.
 //
@@ -23,8 +23,7 @@ const ASCII_ZERO: u16 = 48;
 const ASCII_E_UP: u16 = 69;
 const ASCII_E_LO: u16 = 101;
 
-// @ts-ignore: inline
-@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+function fallback<T>(srcStart: usize, srcEnd: usize): T {
   const s = ptrToStr(srcStart, srcEnd);
   // @ts-ignore
   const type: T = 0;
@@ -34,8 +33,7 @@ const ASCII_E_LO: u16 = 101;
   return <T>(<f32>f32.parse(s));
 }
 
-// @ts-ignore: inline
-@inline function fallbackField<T extends number>(
+function fallbackField<T extends number>(
   origStart: usize,
   end: usize,
   fieldPtr: usize,

package/assembly/deserialize/simd/integer.ts

@@ -38,11 +38,7 @@ const ASCII_ZERO: u16 = 48;
  * @param value  The `u64` accumulator, interpreted as a two's-complement
  *               signed integer for narrower types.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function storeSignedToField<T extends number>(
-  dstPtr: usize,
-  value: u64,
-): void {
+function storeSignedToField<T extends number>(dstPtr: usize, value: u64): void {
   if (sizeof<T>() == 1) {
     store<i8>(dstPtr, <i8>value);
   } else if (sizeof<T>() == 2) {
@@ -61,8 +57,7 @@ const ASCII_ZERO: u16 = 48;
  * @param dstPtr Destination pointer (already includes any field offset).
  * @param value  The `u64` accumulator.
  */
-// @ts-expect-error: decorator valid here
-@inline function storeUnsignedToField<T extends number>(
+function storeUnsignedToField<T extends number>(
   dstPtr: usize,
   value: u64,
 ): void {

package/assembly/deserialize/simd/string.ts

@@ -63,13 +63,8 @@ import { hex4_to_u16_swar } from "../../util/swar";
  * @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 {
+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);
@@ -106,11 +101,7 @@ function writeStringToField_SIMD(
 // handling (no closing-quote search). Same HYBRID strategy as the field path
 // (see deserializeEscapedStringField_SIMD): escape blocks use a free
 // whole-block v128 store for the plain prefix; clean runs stream the first
-// block then bulk-memcpy the remainder. Output is sliced out of `bs` scratch.
-//
-// Deliberately NOT @inline: cold escape path. Inlining the nested-loop v128
-// body at every call site explodes `--converge` compile time on large schemas
-// for no runtime gain (one call per escaped string).
+
 function deserializeEscapedString_SIMD(
   payloadStart: usize,
   escapeStart: usize,
@@ -254,18 +245,14 @@ export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): string {
 // reused `bs` scratch buffer, then written once via writeStringToField_SIMD.
 //
 // Strategy (validated against run-copy and pure-stream variants across escape
-// densities — see __benches__/custom/simd-string-deser-variants-h2h):
+// densities - see __benches__/custom/simd-string-deser-variants-h2h):
 //   * Escape-bearing block: a single whole-block v128 store copies the plain
 //     prefix for free; then the escape is decoded scalar.
 //   * Clean block: stream the first one cheaply, but if the clean run keeps
-//     going, switch to one bulk memory.copy for the remainder — bandwidth-
+//     going, switch to one bulk memory.copy for the remainder - bandwidth-
 //     optimal on long sparse runs, avoiding a per-block-store cliff on large
 //     inputs. This dominates both alternatives: stream-cheap on dense escapes,
-//     memcpy-fast on long runs.
-//
-// Deliberately NOT @inline: cold escape path. As an @inline it was inlined into
-// deserializeStringField_SIMD at every struct string-field site, exploding
-// `--converge` compile time ~24x on large schemas (4s → 99s) for no runtime
+
 // gain. The hot no-escape scan + writeStringToField stay inline in the caller.
 function deserializeEscapedStringField_SIMD(
   payloadStart: usize,
@@ -386,10 +373,6 @@ function deserializeEscapedStringField_SIMD(
   return srcStart;
 }
 
-// NOT @inline: as an @inline entry, binaryen inlined the (loop-bearing) escaped
-// scanner into every per-field copy, exploding `large` SIMD compile ~24x
-// (4s→99s, 221KB→555KB wasm). Kept as a single shared function — matches
-// deserializeStringField_SWAR (also non-inline) and costs only one call/field.
 export function deserializeStringField_SIMD<T extends string | null>(
   srcStart: usize,
   srcEnd: usize,

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

@@ -2,8 +2,7 @@ import { JSON } from "../../..";
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeArbitraryArrayField(
+export function deserializeArbitraryArrayField(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/array.ts

@@ -90,8 +90,7 @@ export function deserializeArrayArrayBody<T extends unknown[][]>(
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeArrayArrayField<T extends unknown[][]>(
+export function deserializeArrayArrayField<T extends unknown[][]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/bool.ts

@@ -59,8 +59,7 @@ function deserializeBooleanArrayBody<T extends boolean[]>(
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeBooleanArrayField<T extends boolean[]>(
+export function deserializeBooleanArrayField<T extends boolean[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/box.ts

@@ -2,8 +2,7 @@ import { JSON } from "../../..";
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeBoxArrayField<T extends JSON.Box<any>[]>(
+export function deserializeBoxArrayField<T extends JSON.Box<any>[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/float.ts

@@ -8,21 +8,11 @@ import { parse4Digits_PairMul } from "../../../util/swar-int";
 import { loadPow10, MAX_EXACT_MANTISSA, MAX_EXACT_POW10 } from "../float";
 import { isSpace } from "../../../util";
 
-
-@inline function skipFloatArrayWhitespace(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+function skipFloatArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   return srcStart;
 }
-
-// @ts-ignore: inline
-@inline function fallbackStore<E>(
-  origStart: usize,
-  end: usize,
-  slot: usize,
-): void {
+function fallbackStore<E>(origStart: usize, end: usize, slot: usize): void {
   const s = ptrToStr(origStart, end);
   if (sizeof<E>() == sizeof<f32>()) {
     store<f32>(slot, f32.parse(s));
@@ -77,7 +67,7 @@ export function parseFloatElementSWAR<E>(
   }
 
   // Fractional mantissa: parse4 SWAR stride + scalar tail. Same u64
-  // accumulator as the integer part — exponent compensates for fracDigits.
+  // accumulator as the integer part - exponent compensates for fracDigits.
   let fracDigits: i32 = 0;
   if (p < srcEnd && load<u16>(p) == 46) {
     p += 2;
@@ -164,7 +154,7 @@ export function parseFloatElementSWAR<E>(
     // the `ptrToStr` allocation + strtod re-parse.
     result = scientific(mantissa, exponent);
   } else {
-    // >19 mantissa digits — beyond u64 capacity, may need strtod's sticky-bit
+    // >19 mantissa digits - beyond u64 capacity, may need strtod's sticky-bit
     // pattern. Hand off to f*.parse on the float's substring.
     fallbackStore<E>(origStart, p, slot);
     return p;
@@ -255,7 +245,7 @@ export function deserializeFloatArray_SWAR<T extends number[]>(
 }
 
 /**
- * Field/into variant — parses `[..]` into the existing `out` array and
+ * Field/into variant - parses `[..]` into the existing `out` array and
  * returns the cursor past the closing `]`.
  *
  * Worst-case pre-sizing (`(srcEnd - srcStart) >> 2`) used by the top-level
@@ -315,9 +305,7 @@ export function deserializeFloatArrayBody<T extends number[]>(
 
   throw new Error("Failed to parse JSON!");
 }
-
-
-@inline export function deserializeFloatArrayField<T extends number[]>(
+export function deserializeFloatArrayField<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/generic.ts

@@ -47,8 +47,7 @@ export function deserializeGenericArrayBody<T extends unknown[]>(
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeGenericArrayField<T extends unknown[]>(
+export function deserializeGenericArrayField<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/integer.ts

@@ -7,12 +7,9 @@ import { parse4Digits_PairMul } from "../../../util/swar-int";
 // Store helpers parameterised on the element type `E` directly, so they
 // serve both `Array<E>` and `TypedArray<E>` callers. The integer-array
 // callers below all pass `valueof<T>` and AS folds the resulting tower of
-// `sizeof<E>` comparisons at compile time — same codegen as the prior
+// `sizeof<E>` comparisons at compile time - same codegen as the prior
 // `T extends number[]` version, but reusable from `swar/typedarray.ts`.
-@inline function storeSignedIntegerE<E extends number>(
-  slot: usize,
-  value: i64,
-): void {
+function storeSignedIntegerE<E extends number>(slot: usize, value: i64): void {
   if (sizeof<E>() == sizeof<i8>()) {
     store<i8>(slot, <i8>value);
   } else if (sizeof<E>() == sizeof<i16>()) {
@@ -26,8 +23,7 @@ import { parse4Digits_PairMul } from "../../../util/swar-int";
   }
 }
 
-
-@inline function storeUnsignedIntegerE<E extends number>(
+function storeUnsignedIntegerE<E extends number>(
   slot: usize,
   value: u64,
 ): void {
@@ -211,11 +207,7 @@ export function parseUnsignedIntegerSWAR<E extends number>(
   return srcStart;
 }
 
-
-@inline function skipIntegerArrayWhitespace(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+function skipIntegerArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) {
     srcStart += 2;
   }
@@ -661,7 +653,7 @@ function deserializeIntegerArrayBody<T extends number[]>(
       const slot = ensureArrayElementSlot<T>(out, index);
       // Inline the array-optimized SWAR parser directly. The top-level
       // (`deserializeIntegerArrayImpl`) and the typed-array path
-      // (`swar/typedarray.ts`) already call these — having the field path
+      // (`swar/typedarray.ts`) already call these - having the field path
       // call them too means the per-element parser is identical across all
       // three call sites (parse4 + scalar fold for both signed and
       // unsigned, narrow-lane special case for i8/u8/i16/u16).
@@ -669,7 +661,7 @@ function deserializeIntegerArrayBody<T extends number[]>(
       // Why not `deserializeUnsignedField_SWAR` (which uses parse8 + scalar)?
       // That tuning targets the struct-single-field path where the digit
       // run is one aligned token. In an array, mixed element widths cause
-      // parse8 to fail-and-retry at element boundaries — see u32-64mib's
+      // parse8 to fail-and-retry at element boundaries - see u32-64mib's
       // 23% regression when parse8 was tried in the array path.
       srcStart = isSigned<valueof<T>>()
         ? parseSignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, slot)
@@ -697,8 +689,7 @@ function deserializeIntegerArrayBody<T extends number[]>(
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeIntegerArrayField<T extends number[]>(
+export function deserializeIntegerArrayField<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/map.ts

@@ -1,8 +1,7 @@
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeMapArrayField<T extends Map<any, any>[]>(
+export function deserializeMapArrayField<T extends Map<any, any>[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/object.ts

@@ -58,8 +58,7 @@ function deserializeObjectArrayBody<T extends unknown[]>(
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeObjectArrayField<T extends unknown[]>(
+export function deserializeObjectArrayField<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

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

@@ -2,8 +2,7 @@ import { JSON } from "../../..";
 import { deserializeGenericArrayBody } from "./generic";
 import { ensureArrayField } from "./shared";
 
-
-@inline export function deserializeRawArrayField(
+export function deserializeRawArrayField(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/shared.ts

@@ -10,16 +10,12 @@ import {
 import { isSpace } from "../../../util";
 
 /** Advance past JSON whitespace (space, tab, LF, CR). */
-// @ts-expect-error: @inline is a valid decorator
-@inline export function skipWhitespace(srcStart: usize, srcEnd: usize): usize {
+export function skipWhitespace(srcStart: usize, srcEnd: usize): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   return srcStart;
 }
 
-
-@inline export function ensureArrayField<T extends Array<any>>(
-  fieldPtr: usize,
-): T {
+export function ensureArrayField<T extends Array<any>>(fieldPtr: usize): T {
   let out = load<T>(fieldPtr);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
@@ -28,8 +24,7 @@ import { isSpace } from "../../../util";
   return out;
 }
 
-
-@inline export function ensureArrayFieldAt<T extends Array<any>>(
+export function ensureArrayFieldAt<T extends Array<any>>(
   dstObj: usize,
   dstOffset: usize,
 ): T {
@@ -41,8 +36,7 @@ import { isSpace } from "../../../util";
   return out;
 }
 
-
-@inline function backslashOrQuoteMask(block: u64): u64 {
+function backslashOrQuoteMask(block: u64): u64 {
   const b = block ^ 0x005c_005c_005c_005c;
   const q = block ^ 0x0022_0022_0022_0022;
   return (
@@ -51,8 +45,7 @@ import { isSpace } from "../../../util";
   );
 }
 
-
-@inline export function ensureArrayElementSlot<T extends Array<any>>(
+export function ensureArrayElementSlot<T extends Array<any>>(
   out: T,
   index: i32,
 ): usize {
@@ -60,7 +53,7 @@ import { isSpace } from "../../../util";
   if (out.length < nextLength) {
     // Grow via `push`, not `out.length = nextLength`. AS's `length=`
     // setter calls `ensureCapacity(canGrow=false)` which reallocates to
-    // *exactly* the requested size — fine for a one-shot resize, but
+    // *exactly* the requested size - fine for a one-shot resize, but
     // catastrophic in the per-element loop (every push triggers a full
     // copy of the array, giving O(N²) growth cost). `push` goes through
     // `canGrow=true`, doubling capacity geometrically as needed.

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

@@ -8,11 +8,7 @@ import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 import { deserializeStringField_SWAR } from "../string";
 
-
-@inline function skipStringArrayWhitespace(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+function skipStringArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   return srcStart;
 }
@@ -41,7 +37,7 @@ function deserializeStringArrayBody<T extends string[]>(
       // and skip 8 bytes.
       //
       // We accept null tokens unconditionally rather than gating on
-      // `isNullable<valueof<T>>()` — AS's `valueof` of a nullable-array
+      // `isNullable<valueof<T>>()` - AS's `valueof` of a nullable-array
       // element type doesn't always preserve the nullable marker through
       // the dispatcher's `<T>` cast, so the gate would mis-fire for the
       // very case it's meant to handle. The runtime cost on plain
@@ -80,8 +76,7 @@ function deserializeStringArrayBody<T extends string[]>(
   throw new Error("Failed to parse JSON!");
 }
 
-
-@inline export function deserializeStringArrayField<T extends string[]>(
+export function deserializeStringArrayField<T extends string[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array/struct.ts

@@ -2,11 +2,7 @@ import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
-
-@inline function skipStructArrayWhitespace(
-  srcStart: usize,
-  srcEnd: usize,
-): usize {
+function skipStructArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   return srcStart;
 }
@@ -100,9 +96,7 @@ function deserializeStructArrayBody<T extends unknown[]>(
 
   throw new Error("Failed to parse JSON!");
 }
-
-
-@inline export function deserializeStructArrayField<T extends unknown[]>(
+export function deserializeStructArrayField<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/array.ts

@@ -13,9 +13,7 @@ import { deserializeStringArrayField } from "./array/string";
 import { deserializeStructArrayField } from "./array/struct";
 
 export { deserializeArrayField as deserializeArrayField_SWAR };
-
-
-@inline export function deserializeArrayField<T extends unknown[]>(
+export function deserializeArrayField<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   dstObj: usize,

package/assembly/deserialize/swar/float.ts

@@ -12,7 +12,7 @@
 //
 // Inspired by Daniel Lemire, "Number parsing at a gigabyte per second" (2021)
 // and the simdjson `fast_float` implementation. The integer-part loop stays
-// scalar — most JSON float payloads have 1-3 digit integer parts, so a parse4
+// scalar - most JSON float payloads have 1-3 digit integer parts, so a parse4
 // stride there pays the wasted-validate cost on every call without saving
 // enough scalar iterations.
 
@@ -34,14 +34,11 @@ const ASCII_DOT: u16 = 46;
 const ASCII_ZERO: u16 = 48;
 const ASCII_E_UP: u16 = 69;
 const ASCII_E_LO: u16 = 101;
-
-// @ts-ignore: inline
-@inline export function loadPow10(exp: u32): f64 {
+export function loadPow10(exp: u32): f64 {
   return load<f64>(POW10_F64_POS + ((<usize>exp) << 3));
 }
 
-// @ts-ignore: inline
-@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+function fallback<T>(srcStart: usize, srcEnd: usize): T {
   const s = ptrToStr(srcStart, srcEnd);
   // @ts-ignore
   const type: T = 0;
@@ -50,9 +47,7 @@ const ASCII_E_LO: u16 = 101;
   // @ts-ignore
   return <T>(<f32>f32.parse(s));
 }
-
-// @ts-ignore: inline
-@inline function fallbackField<T extends number>(
+function fallbackField<T extends number>(
   origStart: usize,
   end: usize,
   fieldPtr: usize,

package/assembly/deserialize/swar/integer.ts

@@ -40,11 +40,7 @@ const ASCII_ZERO: u16 = 48;
  * @param value  The `u64` accumulator, interpreted as a two's-complement
  *               signed integer for narrower types.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function storeSignedToField<T extends number>(
-  dstPtr: usize,
-  value: u64,
-): void {
+function storeSignedToField<T extends number>(dstPtr: usize, value: u64): void {
   if (sizeof<T>() == 1) {
     store<i8>(dstPtr, <i8>value);
   } else if (sizeof<T>() == 2) {
@@ -63,8 +59,7 @@ const ASCII_ZERO: u16 = 48;
  * @param dstPtr Destination pointer (already includes any field offset).
  * @param value  The `u64` accumulator.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function storeUnsignedToField<T extends number>(
+function storeUnsignedToField<T extends number>(
   dstPtr: usize,
   value: u64,
 ): void {

package/assembly/deserialize/swar/string.ts

@@ -41,11 +41,7 @@ import { hex4_to_u16_swar } from "../../util/swar";
  * @param dst buffer to write to
  * @returns number of bytes written
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function copyStringFromSource(
-  srcStart: usize,
-  byteLength: usize,
-): string {
+function copyStringFromSource(srcStart: usize, byteLength: usize): string {
   if (byteLength == 0) return changetype<string>("");
   const out = __new(byteLength, idof<string>());
   memory.copy(out, srcStart, byteLength);
@@ -245,7 +241,7 @@ function writeStringToField(
 // the next unread src pointer.
 //
 // HYBRID strategy (validated against the prior run-copy scanner across escape
-// densities — see __benches__/custom/swar-string-deser-hybrid-h2h: +17–70%):
+// densities - see __benches__/custom/swar-string-deser-hybrid-h2h: +17–70%):
 //   * Escape-bearing block: one optimistic whole-block u64 store copies the
 //     plain prefix for free, then the (scalar-confirmed) escape is decoded.
 //   * Clean block: stream the first one, then if the clean run continues switch
@@ -483,9 +479,14 @@ export function deserializeStringField_SWAR<T extends string | null>(
   if (srcEnd >= 16) {
     const srcEnd16 = srcEnd - 16;
     while (srcStart <= srcEnd16) {
-      const m0 = backslash_or_quote_mask(load<u64>(srcStart));
-      const m1 = backslash_or_quote_mask(load<u64>(srcStart, 8));
-      if ((m0 | m1) != 0) break;
+      // Test the first word before loading the second: short values and keys
+      // close (or escape) within the first 8 bytes, so this skips the second
+      // load on the common case while still skipping 16 bytes when both clean.
+      if (backslash_or_quote_mask(load<u64>(srcStart)) != 0) break;
+      if (backslash_or_quote_mask(load<u64>(srcStart, 8)) != 0) {
+        srcStart += 8;
+        break;
+      }
       srcStart += 16;
     }
   }
@@ -555,8 +556,7 @@ export function deserializeStringField_SWAR<T extends string | null>(
  * so callers must confirm the hit scalarly.
  * Each matching lane sets itself to 0x80.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function backslash_or_quote_mask(block: u64): u64 {
+function backslash_or_quote_mask(block: u64): u64 {
   const b = block ^ 0x005c_005c_005c_005c;
   const q = block ^ 0x0022_0022_0022_0022;
   return (
@@ -575,8 +575,7 @@ export function deserializeStringField_SWAR<T extends string | null>(
  *
  * Each matching lane sets itself to 0x80.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function backslash_mask(block: u64): u64 {
+function backslash_mask(block: u64): u64 {
   const b = block ^ 0x005c_005c_005c_005c;
   const backslash_mask =
     (b - 0x0001_0001_0001_0001) & ~b & 0x0080_0080_0080_0080;
@@ -597,8 +596,7 @@ export function deserializeStringField_SWAR<T extends string | null>(
  * WARNING: The low byte of a code unit *may* be a backslash, thus triggering false positives!
  * This is useful for a hot path where it is possible to detect the false positive scalarly.
  */
-// @ts-expect-error: @inline is a valid decorator
-@inline function backslash_mask_unsafe(block: u64): u64 {
+function backslash_mask_unsafe(block: u64): u64 {
   const b = block ^ 0x005c_005c_005c_005c;
   const backslash_mask =
     (b - 0x0001_0001_0001_0001) & ~b & 0x0080_0080_0080_0080;

package/assembly/deserialize/swar/typedarray.ts

@@ -6,10 +6,10 @@
 //
 //   - **No count pass.** TypedArrays have a fixed length at construction,
 //     so the natural approach is to count first then allocate. We tried
-//     that with a SWAR comma counter — it cut the per-element cost but
+//     that with a SWAR comma counter - it cut the per-element cost but
 //     kept us ~30% below the top-level `f64[]` path because the count
 //     scan still touched the whole input twice. Instead we allocate
-//     worst-case (`(srcEnd - srcStart) >> 2 + 1` elements — each
+//     worst-case (`(srcEnd - srcStart) >> 2 + 1` elements - each
 //     element needs >= "D," = 2 UTF-16 chars = 4 bytes) and `__renew`
 //     the underlying buffer down to the exact byte count after parsing.
 //     The over-allocation peaks at ~2-3× the final size for typical
@@ -46,7 +46,7 @@ import {
  * Worst-case element count: each element occupies >= 1 digit + 1
  * delimiter = 2 UTF-16 chars = 4 bytes. So `(srcEnd - srcStart) >> 2`
  * upper-bounds the count. Allocating to worst-case lets us skip a
- * full count pass over the input — at the cost of an over-allocated
+ * full count pass over the input - at the cost of an over-allocated
  * underlying buffer that we trim via `__renew` once we know the
  * actual element count.
  *
@@ -125,7 +125,7 @@ export function deserializeTypedArray_SWAR<T extends ArrayLike<number>>(
   // directly: `__renew` the buffer to the actual byte length and
   // update the view's `byteLength` and `dataStart`. AS's TypedArray
   // structure has `buffer`, `dataStart` (= buffer), `byteLength`
-  // (capacity in bytes) in that order — same layout as ArrayBufferView.
+  // (capacity in bytes) in that order - same layout as ArrayBufferView.
   const actualCount = i32(<usize>(writePtr - dataStart) / elementSize);
   if (actualCount != maxElements) {
     const actualBytes = <usize>actualCount * elementSize;