json-as 1.3.6 → 1.3.7

package/assembly/util/itoa-fast.ts

@@ -0,0 +1,230 @@
+// Fast integer -> UTF-16 stringification (jeaiii-style).
+//
+// Background: AS std's `itoa_buffered` runs `decimalCount32` (a width
+// classifier) then `utoa32_dec_lut` (a backward-writing div-by-10000
+// loop). On wasm/V8 the function-call overhead between those steps shows
+// up clearly for short widths (2-4 digits) where the per-element work is
+// otherwise tiny.
+//
+// This module ports the jeaiii (James Edward Anhalt III) algorithm:
+//   - One `@inline` function per signed/unsigned u32/u64.
+//   - Width-ladder of `if (v < 10^k)` checks emits digits forward in a
+//     single pass; the same comparisons that would have driven a separate
+//     `decimalCount` are reused as the dispatch.
+//   - Each digit-pair is written as a single `store<u32>` from a 400-byte
+//     LUT (`DIGIT_PAIRS_UTF16`) keyed on `value % 100`.
+//   - All `/` and `%` are by compile-time constants (10 / 100 / 10000 /
+//     10^8) so the wasm tier lowers them to multiply-shift.
+//
+// Reference H2H bench: `__benches__/custom/itoa-h2h.bench.ts`.
+
+// 100-entry pair LUT: index `i` -> u32 holding UTF-16 chars for the
+// zero-padded two-digit string "DD". One `store<u32>` writes the pair.
+const DIGIT_PAIRS_UTF16: usize = memory.data(100 * 4);
+let _pairsInited: bool = false;
+
+function initPairs(): void {
+  for (let i: i32 = 0; i < 100; i++) {
+    const tens = u32(0x30 + i / 10);
+    const units = u32(0x30 + (i % 10));
+    store<u32>(DIGIT_PAIRS_UTF16 + ((<usize>i) << 2), tens | (units << 16));
+  }
+  _pairsInited = true;
+}
+
+
+@inline export function ensureItoaPairs(): void {
+  if (!_pairsInited) initPairs();
+}
+
+// @ts-expect-error: @inline is a valid decorator
+@inline function pair(i: u32): u32 {
+  return load<u32>(DIGIT_PAIRS_UTF16 + ((<usize>i) << 2));
+}
+
+/**
+ * jeaiii-style u32 -> UTF-16 stringification, forward write.
+ * Returns the number of UTF-16 chars written (caller multiplies by 2 for
+ * 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 {
+  if (v < 10) {
+    store<u16>(buf, <u16>(v + 0x30));
+    return 1;
+  }
+  if (v < 100) {
+    store<u32>(buf, pair(v));
+    return 2;
+  }
+  if (v < 1_000_000) {
+    if (v < 10_000) {
+      if (v < 1_000) {
+        const h = v / 100;
+        const l = v - h * 100;
+        store<u16>(buf, <u16>(h + 0x30));
+        store<u32>(buf, pair(l), 2);
+        return 3;
+      }
+      const h = v / 100;
+      const l = v - h * 100;
+      store<u32>(buf, pair(h));
+      store<u32>(buf, pair(l), 4);
+      return 4;
+    }
+    if (v < 100_000) {
+      const hi = v / 10_000;
+      const rest = v - hi * 10_000;
+      const m = rest / 100;
+      const l = rest - m * 100;
+      store<u16>(buf, <u16>(hi + 0x30));
+      store<u32>(buf, pair(m), 2);
+      store<u32>(buf, pair(l), 6);
+      return 5;
+    }
+    const hi = v / 10_000;
+    const rest = v - hi * 10_000;
+    const m = rest / 100;
+    const l = rest - m * 100;
+    store<u32>(buf, pair(hi));
+    store<u32>(buf, pair(m), 4);
+    store<u32>(buf, pair(l), 8);
+    return 6;
+  }
+  if (v < 100_000_000) {
+    if (v < 10_000_000) {
+      const top = v / 1_000_000;
+      let rest = v - top * 1_000_000;
+      const m = rest / 10_000;
+      rest = rest - m * 10_000;
+      const n = rest / 100;
+      const l = rest - n * 100;
+      store<u16>(buf, <u16>(top + 0x30));
+      store<u32>(buf, pair(m), 2);
+      store<u32>(buf, pair(n), 6);
+      store<u32>(buf, pair(l), 10);
+      return 7;
+    }
+    const top = v / 1_000_000;
+    let rest = v - top * 1_000_000;
+    const m = rest / 10_000;
+    rest = rest - m * 10_000;
+    const n = rest / 100;
+    const l = rest - n * 100;
+    store<u32>(buf, pair(top));
+    store<u32>(buf, pair(m), 4);
+    store<u32>(buf, pair(n), 8);
+    store<u32>(buf, pair(l), 12);
+    return 8;
+  }
+  if (v < 1_000_000_000) {
+    const top = v / 100_000_000;
+    let rest = v - top * 100_000_000;
+    const a = rest / 1_000_000;
+    rest = rest - a * 1_000_000;
+    const b = rest / 10_000;
+    rest = rest - b * 10_000;
+    const c = rest / 100;
+    const d = rest - c * 100;
+    store<u16>(buf, <u16>(top + 0x30));
+    store<u32>(buf, pair(a), 2);
+    store<u32>(buf, pair(b), 6);
+    store<u32>(buf, pair(c), 10);
+    store<u32>(buf, pair(d), 14);
+    return 9;
+  }
+  const top = v / 100_000_000;
+  let rest = v - top * 100_000_000;
+  const a = rest / 1_000_000;
+  rest = rest - a * 1_000_000;
+  const b = rest / 10_000;
+  rest = rest - b * 10_000;
+  const c = rest / 100;
+  const d = rest - c * 100;
+  store<u32>(buf, pair(top));
+  store<u32>(buf, pair(a), 4);
+  store<u32>(buf, pair(b), 8);
+  store<u32>(buf, pair(c), 12);
+  store<u32>(buf, pair(d), 16);
+  return 10;
+}
+
+/**
+ * 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 {
+  const a = v / 1_000_000;
+  let rest = v - a * 1_000_000;
+  const b = rest / 10_000;
+  rest = rest - b * 10_000;
+  const c = rest / 100;
+  const d = rest - c * 100;
+  store<u32>(buf, pair(a));
+  store<u32>(buf, pair(b), 4);
+  store<u32>(buf, pair(c), 8);
+  store<u32>(buf, pair(d), 12);
+}
+
+/**
+ * jeaiii-style u64 -> UTF-16 stringification.
+ * Small values delegate to `itoaU32`. For 11+ digit values, peel 8 digits
+ * from the bottom (always fits in u32), emit the remaining top via the
+ * u32 path, then emit the 8 trailing digits with leading-zero padding.
+ * 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 {
+  if (v <= <u64>u32.MAX_VALUE) {
+    return itoaU32(buf, <u32>v);
+  }
+  const lo8 = <u32>(v % 100_000_000);
+  const hi = v / 100_000_000;
+  if (hi <= <u64>u32.MAX_VALUE) {
+    const written = itoaU32(buf, <u32>hi);
+    writeU32Padded8(buf + ((<usize>written) << 1), lo8);
+    return written + 8;
+  }
+  // 17-20 digit case: peel a second group of 8.
+  const mid8 = <u32>(hi % 100_000_000);
+  const top = <u32>(hi / 100_000_000);
+  const written = itoaU32(buf, top);
+  writeU32Padded8(buf + ((<usize>written) << 1), mid8);
+  writeU32Padded8(buf + ((<usize>written) << 1) + 16, lo8);
+  return written + 16;
+}
+
+/**
+ * Generic integer -> UTF-16 entry point. Signed types peel `-` and pass
+ * the absolute value (via two's complement negation, which works for the
+ * minimum-value edge case because `u32(-i32.MIN_VALUE) == 2147483648`
+ * and likewise for i64).
+ *
+ * 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 {
+  if (sizeof<T>() <= 4) {
+    if (isSigned<T>()) {
+      let v = <i32>value;
+      if (v < 0) {
+        store<u16>(buf, 0x2d); // '-'
+        return 1 + itoaU32(buf + 2, <u32>-v);
+      }
+      return itoaU32(buf, <u32>v);
+    }
+    return itoaU32(buf, <u32>value);
+  }
+  if (isSigned<T>()) {
+    let v = <i64>value;
+    if (v < 0) {
+      store<u16>(buf, 0x2d); // '-'
+      return 1 + itoaU64(buf + 2, <u64>-v);
+    }
+    return itoaU64(buf, <u64>v);
+  }
+  return itoaU64(buf, <u64>value);
+}

package/assembly/util/masks.ts

@@ -25,7 +25,24 @@ export function block_to_string(block: u64): string {
 export function mask_to_string_v128(vec: v128): string {
   let result = "0x";
 
-  const lanes: i8[] = [i8x16.extract_lane_s(vec, 0), i8x16.extract_lane_s(vec, 1), i8x16.extract_lane_s(vec, 2), i8x16.extract_lane_s(vec, 3), i8x16.extract_lane_s(vec, 4), i8x16.extract_lane_s(vec, 5), i8x16.extract_lane_s(vec, 6), i8x16.extract_lane_s(vec, 7), i8x16.extract_lane_s(vec, 8), i8x16.extract_lane_s(vec, 9), i8x16.extract_lane_s(vec, 10), i8x16.extract_lane_s(vec, 11), i8x16.extract_lane_s(vec, 12), i8x16.extract_lane_s(vec, 13), i8x16.extract_lane_s(vec, 14), i8x16.extract_lane_s(vec, 15)];
+  const lanes: i8[] = [
+    i8x16.extract_lane_s(vec, 0),
+    i8x16.extract_lane_s(vec, 1),
+    i8x16.extract_lane_s(vec, 2),
+    i8x16.extract_lane_s(vec, 3),
+    i8x16.extract_lane_s(vec, 4),
+    i8x16.extract_lane_s(vec, 5),
+    i8x16.extract_lane_s(vec, 6),
+    i8x16.extract_lane_s(vec, 7),
+    i8x16.extract_lane_s(vec, 8),
+    i8x16.extract_lane_s(vec, 9),
+    i8x16.extract_lane_s(vec, 10),
+    i8x16.extract_lane_s(vec, 11),
+    i8x16.extract_lane_s(vec, 12),
+    i8x16.extract_lane_s(vec, 13),
+    i8x16.extract_lane_s(vec, 14),
+    i8x16.extract_lane_s(vec, 15),
+  ];
 
   for (let i = 15; i >= 0; i--) {
     const byte = lanes[i];

package/assembly/util/parsefloat-fast.ts

@@ -0,0 +1,167 @@
+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
+// https://github.com/fastfloat/fast_float.
+//
+// The "fast path" applies when:
+//   - the mantissa fits in a u64 (<=19 decimal digits), and
+//   - the total decimal exponent is in [-22, 22], so the matching
+//     `1e<exp>` power-of-ten is representable exactly in f64.
+//
+// In that regime `value = mantissa * 10^exp` rounds correctly under
+// IEEE-754: both operands are exact in f64 and the single fmul is
+// correctly rounded, so the result is the same as the strictly-rounded
+// reference. This covers the overwhelming majority of JSON float
+// payloads (most fields are <20 significant digits and modest
+// exponents). Out-of-range inputs delegate to AS std's `f64.parse`
+// (Grisu-based; correctly rounded for all f64).
+//
+// Compared to the original digit-by-digit accumulator (`value = value *
+// 10.0 + digit`) this saves both wall-time (fewer fmul/fdiv) and
+// precision (one rounding instead of N).
+
+// 23-entry table: 10^0 .. 10^22, all exact in f64. f32 fast-paths can
+// reuse the same table (since 10^k for k <= 22 fits in f32 only up to
+// 10^7, but the multiplication is done in f64 and narrowed at the end).
+const POW10_F64_POS: usize = memory.data<f64>([
+  1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14,
+  1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22,
+]);
+
+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 {
+  return load<f64>(POW10_F64_POS + ((<usize>exp) << 3));
+}
+
+
+@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+  const s = ptrToStr(srcStart, srcEnd);
+  // @ts-ignore: type
+  const type: T = 0;
+  // @ts-ignore: type
+  if (type instanceof f64) return <T>f64.parse(s);
+  // @ts-ignore: cast
+  return <T>(<f32>f32.parse(s));
+}
+
+/**
+ * Fast path for `deserializeFloat`. `srcStart..srcEnd` must contain only
+ * the float content (no surrounding whitespace, no `null`). Returns the
+ * parsed value; on the slow path falls back to `f64.parse` /
+ * `f32.parse` over the same range so behavior is preserved for every
+ * input the previous parser accepted.
+ *
+ * Structure mirrors the existing parser's split integer/fraction loops
+ * (TurboFan schedules these tighter than a single fused loop) but uses
+ * u64 accumulators throughout so a 17-digit "3.141592653589793" stays
+ * 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 {
+  const origStart = srcStart;
+  let p = srcStart;
+  let negative = false;
+  if (p < srcEnd && load<u16>(p) == 45) {
+    negative = true;
+    p += 2;
+  }
+
+  // Integer part.
+  let mantissa: u64 = 0;
+  let intDigits: i32 = 0;
+  while (p < srcEnd) {
+    const d = <u32>load<u16>(p) - 48;
+    if (d > 9) break;
+    mantissa = mantissa * 10 + <u64>d;
+    intDigits++;
+    p += 2;
+  }
+
+  // Optional fractional part.
+  let fracDigits: i32 = 0;
+  if (p < srcEnd && load<u16>(p) == 46) {
+    p += 2;
+    while (p < srcEnd) {
+      const d = <u32>load<u16>(p) - 48;
+      if (d > 9) break;
+      mantissa = mantissa * 10 + <u64>d;
+      fracDigits++;
+      p += 2;
+    }
+  }
+
+  const mantDigits = intDigits + fracDigits;
+  if (mantDigits == 0) {
+    // No digits seen (e.g. `.5`, `NaN`, `Infinity`) - defer to AS std.
+    return fallback<T>(origStart, srcEnd);
+  }
+
+  let exponent: i32 = -fracDigits;
+
+  // Optional `e[+-]NNN` suffix.
+  if (p < srcEnd) {
+    const c = load<u16>(p);
+    if (c == 101 || c == 69) {
+      p += 2;
+      if (p >= srcEnd) return fallback<T>(origStart, srcEnd);
+      let expNeg = false;
+      const sc = load<u16>(p);
+      if (sc == 45) {
+        expNeg = true;
+        p += 2;
+      } else if (sc == 43) {
+        p += 2;
+      }
+      if (p >= srcEnd) return fallback<T>(origStart, srcEnd);
+      let exp: i32 = 0;
+      let expDigits: i32 = 0;
+      while (p < srcEnd) {
+        const d = <u32>load<u16>(p) - 48;
+        if (d > 9) break;
+        exp = exp * 10 + <i32>d;
+        expDigits++;
+        if (expDigits > 4) {
+          // Pathological exponent - fall back for safety.
+          return fallback<T>(origStart, srcEnd);
+        }
+        p += 2;
+      }
+      if (expDigits == 0) return fallback<T>(origStart, srcEnd);
+      exponent += expNeg ? -exp : exp;
+    }
+  }
+
+  // Fast path eligibility: mantissa fits exactly in an f64 and exponent
+  // is in the exactly-representable pow10 range. Both halves are needed
+  // for the result to be correctly rounded. Capping `mantDigits` at 19
+  // is a cheaper proxy for "didn't overflow u64".
+  if (mantDigits > 19 || mantissa > MAX_EXACT_MANTISSA) {
+    return fallback<T>(origStart, srcEnd);
+  }
+  if (exponent > MAX_EXACT_POW10 || exponent < -MAX_EXACT_POW10) {
+    return fallback<T>(origStart, srcEnd);
+  }
+
+  let result = <f64>mantissa;
+  if (exponent > 0) {
+    result *= loadPow10(<u32>exponent);
+  } else if (exponent < 0) {
+    result /= loadPow10(<u32>-exponent);
+  }
+  if (negative) result = -result;
+
+  // @ts-ignore: type
+  const type: T = 0;
+  // @ts-ignore: type
+  if (type instanceof f64) return <T>result;
+  // @ts-ignore: cast
+  return <T>(<f32>result);
+}

package/assembly/util/simd-int.ts

@@ -0,0 +1,191 @@
+// SIMD (v128) integer-digit parsing kernels over UTF-16 sources.
+//
+// Requires `--enable simd` at compile time. Imported only by the SIMD-mode
+// dispatch paths and dead-code-eliminated when JSON_MODE != SIMD.
+//
+// Algorithm is the Lemire-style narrow-extmul-dot pipeline used by simdjson:
+//
+// 1. `i16x8.sub` subtracts `'0'` from each UTF-16 lane.
+// 2. `i8x16.narrow_i16x8_u` packs two 8-lane u16 vectors into one 16-lane u8
+//    vector. This pack is free in SIMD and is the move that makes the SWAR
+//    packing problem disappear.
+// 3. `i16x8.extmul_low/high_i8x16_u(packed, (10, 1, ...))` multiplies
+//    adjacent bytes by 10 and 1, encoding the first pair-fold step in a
+//    vector op.
+// 4. `i32x4.extadd_pairwise_i16x8_u` pairwise-sums adjacent u16 lanes into
+//    u32 lanes, completing the first pair-fold.
+// 5. `i16x8.narrow_i32x4_u + i32x4.dot_i16x8_s(_, (100, 1, 100, 1, ...))`
+//    folds 4 u32 pair-values into 2 u32 group-values per lane via dot
+//    product.
+
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_30 = i16x8.splat(0x30);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const SPLAT_09 = i16x8.splat(9);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const ZERO_I16X8 = i16x8.splat(0);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const ZERO_I32X4 = i32x4.splat(0);
+
+// Weights for the first pair-fold step (`digit_lo * 10 + digit_hi`).
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const PACK_WEIGHTS_10_1 = i8x16(
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const PACK_WEIGHTS_10_1_FULL = i8x16(
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+  10,
+  1,
+);
+
+// Weights for the second fold step (`pair_lo * 100 + pair_hi`).
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const PAIR_WEIGHTS_100_1 = i16x8(100, 1, 100, 1, 0, 0, 0, 0);
+// @ts-expect-error: @lazy is a valid decorator
+@lazy const PAIR_WEIGHTS_100_1_FULL = i16x8(100, 1, 100, 1, 100, 1, 100, 1);
+
+/**
+ * Parse eight UTF-16 ASCII digits (16 source bytes) into the 8-digit `u32`
+ * value using SIMD.
+ *
+ * Returns `U32.MAX_VALUE` on any non-digit lane.
+ *
+ * @param srcStart Pointer to 16 source bytes (8 UTF-16 chars).
+ * @returns The parsed 8-digit value, or `U32.MAX_VALUE` on invalid input.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse8Digits_SIMD(srcStart: usize): u32 {
+  const block = load<v128>(srcStart);
+  const digits = i16x8.sub(block, SPLAT_30);
+  if (v128.any_true(i16x8.gt_u(digits, SPLAT_09))) return U32.MAX_VALUE;
+  const packed = i8x16.narrow_i16x8_u(digits, ZERO_I16X8);
+  const products = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1);
+  const pairs = i32x4.extadd_pairwise_i16x8_u(products);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs, ZERO_I32X4);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1);
+  const lo = i32x4.extract_lane(groups, 0);
+  const hi = i32x4.extract_lane(groups, 1);
+  return <u32>lo * 10_000 + <u32>hi;
+}
+
+/**
+ * Same as {@link parse8Digits_SIMD} but with the validation step removed.
+ * Used in consume-to-end paths.
+ *
+ * @param srcStart Pointer to 16 source bytes (8 UTF-16 chars).
+ * @returns The parsed 8-digit value.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse8Digits_SIMD_Unsafe(srcStart: usize): u32 {
+  const block = load<v128>(srcStart);
+  const digits = i16x8.sub(block, SPLAT_30);
+  const packed = i8x16.narrow_i16x8_u(digits, ZERO_I16X8);
+  const products = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1);
+  const pairs = i32x4.extadd_pairwise_i16x8_u(products);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs, ZERO_I32X4);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1);
+  const lo = i32x4.extract_lane(groups, 0);
+  const hi = i32x4.extract_lane(groups, 1);
+  return <u32>lo * 10_000 + <u32>hi;
+}
+
+/**
+ * Parse sixteen UTF-16 ASCII digits (32 source bytes) into one 16-digit
+ * `u64` value using SIMD.
+ *
+ * Two `v128` loads. Combined OR'd validation across both halves means one
+ * branch covers all 16 digits. Both halves' `extmul`s feed a single dot
+ * product, producing 4 four-digit groups that the final parallel-pair
+ * scalar combine merges.
+ *
+ * Returns `U64.MAX_VALUE` on any non-digit lane.
+ *
+ * @param srcStart Pointer to 32 source bytes (16 UTF-16 chars).
+ * @returns The parsed 16-digit value, or `U64.MAX_VALUE` on invalid input.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse16Digits_SIMD(srcStart: usize): u64 {
+  const block0 = load<v128>(srcStart);
+  const block1 = load<v128>(srcStart, 16);
+
+  const digits0 = i16x8.sub(block0, SPLAT_30);
+  const digits1 = i16x8.sub(block1, SPLAT_30);
+
+  const bad0 = i16x8.gt_u(digits0, SPLAT_09);
+  const bad1 = i16x8.gt_u(digits1, SPLAT_09);
+  if (v128.any_true(v128.or(bad0, bad1))) return U64.MAX_VALUE;
+
+  const packed = i8x16.narrow_i16x8_u(digits0, digits1);
+  const products_lo = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1_FULL);
+  const products_hi = i16x8.extmul_high_i8x16_u(packed, PACK_WEIGHTS_10_1_FULL);
+  const pairs_lo = i32x4.extadd_pairwise_i16x8_u(products_lo);
+  const pairs_hi = i32x4.extadd_pairwise_i16x8_u(products_hi);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs_lo, pairs_hi);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1_FULL);
+
+  const g0 = i32x4.extract_lane(groups, 0);
+  const g1 = i32x4.extract_lane(groups, 1);
+  const g2 = i32x4.extract_lane(groups, 2);
+  const g3 = i32x4.extract_lane(groups, 3);
+  const pair01 = <u64>g0 * 10_000 + <u64>g1;
+  const pair23 = <u64>g2 * 10_000 + <u64>g3;
+  return pair01 * 100_000_000 + pair23;
+}
+
+/**
+ * Same as {@link parse16Digits_SIMD} but with the validation step removed.
+ * Used in consume-to-end paths.
+ *
+ * @param srcStart Pointer to 32 source bytes (16 UTF-16 chars).
+ * @returns The parsed 16-digit value.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function parse16Digits_SIMD_Unsafe(srcStart: usize): u64 {
+  const block0 = load<v128>(srcStart);
+  const block1 = load<v128>(srcStart, 16);
+  const digits0 = i16x8.sub(block0, SPLAT_30);
+  const digits1 = i16x8.sub(block1, SPLAT_30);
+  const packed = i8x16.narrow_i16x8_u(digits0, digits1);
+  const products_lo = i16x8.extmul_low_i8x16_u(packed, PACK_WEIGHTS_10_1_FULL);
+  const products_hi = i16x8.extmul_high_i8x16_u(packed, PACK_WEIGHTS_10_1_FULL);
+  const pairs_lo = i32x4.extadd_pairwise_i16x8_u(products_lo);
+  const pairs_hi = i32x4.extadd_pairwise_i16x8_u(products_hi);
+  const pairs16 = i16x8.narrow_i32x4_u(pairs_lo, pairs_hi);
+  const groups = i32x4.dot_i16x8_s(pairs16, PAIR_WEIGHTS_100_1_FULL);
+  const g0 = i32x4.extract_lane(groups, 0);
+  const g1 = i32x4.extract_lane(groups, 1);
+  const g2 = i32x4.extract_lane(groups, 2);
+  const g3 = i32x4.extract_lane(groups, 3);
+  const pair01 = <u64>g0 * 10_000 + <u64>g1;
+  const pair23 = <u64>g2 * 10_000 + <u64>g3;
+  return pair01 * 100_000_000 + pair23;
+}

package/assembly/util/snp.ts

@@ -7,7 +7,10 @@ import { POW_TEN_TABLE_32, POW_TEN_TABLE_64 } from "../globals/tables";
 import { atoi } from "./atoi";
 
 // @ts-ignore: Decorator valid here
-@inline export function snp<T extends number>(srcStart: usize, srcEnd: usize): T {
+@inline export function snp<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
   // @ts-ignore: type
   let val: T = 0;
   let char = load<u16>(srcStart) - 48;