json-as 1.5.0 → 1.6.1

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

@@ -20,12 +20,22 @@ export function deserializeGenericArrayBody<T extends unknown[]>(
   if (load<u16>(srcStart) == BRACKET_RIGHT) return srcStart + 2;
 
   let index = 0;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
+  const reusableDataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
 
   while (srcStart < srcEnd) {
     const valueEnd = scanValueEnd(srcStart, srcEnd);
     if (!valueEnd || valueEnd <= srcStart) break;
 
-    const slot = ensureArrayElementSlot<T>(out, index++);
+    const slot =
+      index < reusableLength
+        ? reusableDataStart + <usize>index * elementSize
+        : ensureArrayElementSlot<T>(out, index);
+    index++;
     store<valueof<T>>(slot, JSON.__deserialize<valueof<T>>(srcStart, valueEnd));
     srcStart = valueEnd;
 
@@ -38,7 +48,7 @@ export function deserializeGenericArrayBody<T extends unknown[]>(
       continue;
     }
     if (code == BRACKET_RIGHT) {
-      out.length = index;
+      if (reusableLength != index) out.length = index;
       return srcStart + 2;
     }
     break;

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

@@ -1,6 +1,7 @@
 import { deserializeIntegerArray_NAIVE } from "../../naive/array/integer";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { isSpace } from "../../../util";
+import { markProductionParseError } from "../../error";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 import { parse4Digits_PairMul } from "../../../util/swar-int";
 
@@ -40,7 +41,7 @@ function storeUnsignedIntegerE<E extends number>(
   }
 }
 
-// The four parse helpers below take a `slot` pointer (`writePtr`) and store
+// The parse helpers below take a `slot` pointer (`writePtr`) and store
 // the value directly via `store<valueof<T>>(slot, ...)`. The outer dispatcher
 // owns the array's `out.length = maxElements` pre-allocation and the
 // `writePtr` advance, so the per-element `Array.push` capacity check and
@@ -49,57 +50,6 @@ function storeUnsignedIntegerE<E extends number>(
 // Parsers are also E-parameterised so they're shareable with
 // `swar/typedarray.ts`. The body is byte-identical to the prior version
 // modulo s/valueof<T>/E/.
-export function parseSignedIntegerScalar<E extends number>(
-  srcStart: usize,
-  srcEnd: usize,
-  slot: usize,
-): usize {
-  let negative = false;
-  let code = load<u16>(srcStart);
-  if (code == 45) {
-    negative = true;
-    srcStart += 2;
-    if (srcStart >= srcEnd) return 0;
-    code = load<u16>(srcStart);
-  }
-
-  let digit = <u32>code - 48;
-  if (digit > 9) return 0;
-
-  let value: u64 = digit;
-  srcStart += 2;
-  while (srcStart < srcEnd) {
-    digit = <u32>load<u16>(srcStart) - 48;
-    if (digit > 9) break;
-    value = value * 10 + digit;
-    srcStart += 2;
-  }
-
-  storeSignedIntegerE<E>(slot, negative ? -(<i64>value) : <i64>value);
-  return srcStart;
-}
-
-export function parseUnsignedIntegerScalar<E extends number>(
-  srcStart: usize,
-  srcEnd: usize,
-  slot: usize,
-): usize {
-  let digit = <u32>load<u16>(srcStart) - 48;
-  if (digit > 9) return 0;
-
-  let value: u64 = digit;
-  srcStart += 2;
-  while (srcStart < srcEnd) {
-    digit = <u32>load<u16>(srcStart) - 48;
-    if (digit > 9) break;
-    value = value * 10 + digit;
-    srcStart += 2;
-  }
-
-  storeUnsignedIntegerE<E>(slot, value);
-  return srcStart;
-}
-
 export function parseSignedIntegerSWAR<E extends number>(
   srcStart: usize,
   srcEnd: usize,
@@ -227,7 +177,8 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
 
   out.length = 0;
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) {
-    throw new Error("Failed to parse JSON!");
+    markProductionParseError();
+    return changetype<T>(0);
   }
 
   srcStart += 2;
@@ -295,7 +246,8 @@ export function deserializeIntegerArray_SLOW<T extends number[]>(
     break;
   }
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return changetype<T>(0);
 }
 
 function deserializeIntegerArrayImpl<T extends number[]>(
@@ -308,7 +260,10 @@ function deserializeIntegerArrayImpl<T extends number[]>(
     dst || changetype<usize>(instantiate<T>()),
   );
   const originalSrcStart = srcStart;
-  const reusableLength = out.length;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
 
   if (useSWAR && reusableLength != 0) {
     const dataStart = out.dataStart;
@@ -448,9 +403,11 @@ function deserializeIntegerArrayImpl<T extends number[]>(
 
     if (isSigned<valueof<T>>()) {
       while (srcStart < srcEnd) {
-        const next = useSWAR
-          ? parseSignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr)
-          : parseSignedIntegerScalar<valueof<T>>(srcStart, srcEnd, writePtr);
+        const next = parseSignedIntegerSWAR<valueof<T>>(
+          srcStart,
+          srcEnd,
+          writePtr,
+        );
         if (!next) break;
         writePtr += elementSize;
         srcStart = next;
@@ -469,9 +426,11 @@ function deserializeIntegerArrayImpl<T extends number[]>(
       }
     } else {
       while (srcStart < srcEnd) {
-        const next = useSWAR
-          ? parseUnsignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr)
-          : parseUnsignedIntegerScalar<valueof<T>>(srcStart, srcEnd, writePtr);
+        const next = parseUnsignedIntegerSWAR<valueof<T>>(
+          srcStart,
+          srcEnd,
+          writePtr,
+        );
         if (!next) break;
         writePtr += elementSize;
         srcStart = next;
@@ -686,7 +645,8 @@ function deserializeIntegerArrayBody<T extends number[]>(
     }
   } while (false);
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return 0;
 }
 
 export function deserializeIntegerArrayField<T extends number[]>(

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

@@ -13,6 +13,12 @@ function deserializeObjectArrayBody<T extends unknown[]>(
   out: T,
 ): usize {
   let index = 0;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
+  const reusableDataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
@@ -25,7 +31,10 @@ function deserializeObjectArrayBody<T extends unknown[]>(
     }
 
     while (srcStart < srcEnd) {
-      const slot = ensureArrayElementSlot<T>(out, index);
+      const slot =
+        index < reusableLength
+          ? reusableDataStart + <usize>index * elementSize
+          : ensureArrayElementSlot<T>(out, index);
       const valueStart = srcStart;
       const valueEnd = scanValueEnd(valueStart, srcEnd);
       if (!valueEnd) break;
@@ -48,7 +57,7 @@ function deserializeObjectArrayBody<T extends unknown[]>(
       }
       if (code == BRACKET_RIGHT) {
         const nextLen = index + 1;
-        if (out.length != nextLen) out.length = nextLen;
+        if (reusableLength != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;

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

@@ -72,7 +72,7 @@ export function ensureArrayElementSlot<T extends Array<any>>(
 
 export function scanQuotedValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
   srcStart += 2;
-  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
+  const srcEnd8 = srcEnd - 8;
 
   while (srcStart <= srcEnd8) {
     let mask = backslashOrQuoteMask(load<u64>(srcStart));

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

@@ -7,6 +7,7 @@ import {
 import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 import { deserializeStringField_SWAR } from "../string";
+import { markProductionParseError } from "../../error";
 
 function skipStringArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
@@ -19,6 +20,15 @@ function deserializeStringArrayBody<T extends string[]>(
   out: T,
 ): usize {
   let index = 0;
+  // Reused struct fields normally retain their array backing store. Cache the
+  // original slot range so the common path avoids an Array.length load and
+  // growth branch for every string.
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
+  const reusableDataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
@@ -31,7 +41,10 @@ function deserializeStringArrayBody<T extends string[]>(
     }
 
     while (srcStart < srcEnd) {
-      const slot = ensureArrayElementSlot<T>(out, index);
+      const slot =
+        index < reusableLength
+          ? reusableDataStart + <usize>index * elementSize
+          : ensureArrayElementSlot<T>(out, index);
       // Null fast path for `(string | null)[]`. "null" is 4 UTF-16 chars
       // = 8 bytes, exactly one u64 compare. Store 0 (the AS null reference)
       // and skip 8 bytes.
@@ -66,14 +79,15 @@ function deserializeStringArrayBody<T extends string[]>(
       }
       if (code == BRACKET_RIGHT) {
         const nextLen = index + 1;
-        if (out.length != nextLen) out.length = nextLen;
+        if (reusableLength != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
     }
   } while (false);
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return 0;
 }
 
 export function deserializeStringArrayField<T extends string[]>(
@@ -106,6 +120,11 @@ export function deserializeStringArray_SWAR<T extends string[]>(
     dst || changetype<usize>(instantiate<T>()),
   );
 
+  // Top-level exact-range entry. Field arrays use the cursor-returning body
+  // above, so trimming here preserves valid document whitespace without
+  // touching the hot generated-struct path.
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+
   // Worst-case sizing: shortest possible element is `""` followed by `,` =
   // 6 UTF-16 bytes, so `(srcLen + 5) / 6` upper-bounds the count. Clamp to
   // AS's BLOCK_MAXSIZE / sizeof<string ref> = (1<<28) - 4 elements; payloads
@@ -126,11 +145,16 @@ export function deserializeStringArray_SWAR<T extends string[]>(
   // Caller guarantees srcStart is at the opening `[`.
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) {
     out.length = 0;
-    return out;
+    markProductionParseError();
+    return changetype<T>(0);
   }
   srcStart += 2;
   srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
   if (srcStart < srcEnd && load<u16>(srcStart) == BRACKET_RIGHT) {
+    if (srcStart + 2 != srcEnd) {
+      markProductionParseError();
+      return changetype<T>(0);
+    }
     out.length = 0;
     return out;
   }
@@ -159,6 +183,10 @@ export function deserializeStringArray_SWAR<T extends string[]>(
       continue;
     }
     if (code == BRACKET_RIGHT) {
+      if (srcStart + 2 != srcEnd) {
+        markProductionParseError();
+        return changetype<T>(0);
+      }
       const finalLen = i32(<usize>(writePtr - dataStart) / elementSize);
       if (out.length != finalLen) out.length = finalLen;
       return out;
@@ -166,5 +194,6 @@ export function deserializeStringArray_SWAR<T extends string[]>(
     break;
   }
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return changetype<T>(0);
 }

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

@@ -1,8 +1,33 @@
-import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import {
+  BRACE_LEFT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+} from "../../../custom/chars";
 import { isSpace } from "../../../util";
-import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+import {
+  ensureArrayElementSlot,
+  ensureArrayField,
+  scanValueEnd,
+} from "./shared";
+import { markProductionParseError } from "../../error";
 
+
+@inline
 function skipStructArrayWhitespace(srcStart: usize, srcEnd: usize): usize {
+  // JSON.stringify(..., null, 2) at a root struct-array boundary emits exactly
+  // LF + two spaces + the next object (or LF + closing bracket). Keep that
+  // overwhelmingly common shape to two scalar loads; nested/foreign layouts
+  // retain the fully general fallback below.
+  if (
+    ASC_FEATURE_SIMD &&
+    srcStart + 8 <= srcEnd &&
+    load<u16>(srcStart) == 10 &&
+    load<u32>(srcStart, 2) == 0x0020_0020
+  ) {
+    const next = load<u16>(srcStart, 6);
+    if (next == BRACE_LEFT || next == BRACKET_RIGHT) return srcStart + 6;
+  }
   while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
   return srcStart;
 }
@@ -28,11 +53,22 @@ function deserializeStructArrayBody<T extends unknown[]>(
   out: T,
 ): usize {
   let index = 0;
+  const reusableLength = load<i32>(
+    changetype<usize>(out),
+    offsetof<T>("length_"),
+  );
+  const reusableDataStart = out.dataStart;
+  const elementSize = sizeof<valueof<T>>();
+  let pretty = false;
 
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
-    srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+    if (srcStart < srcEnd && load<u16>(srcStart) != BRACE_LEFT) {
+      const code = load<u16>(srcStart);
+      pretty = ASC_FEATURE_SIMD && (code == 10 || code == 13);
+      srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+    }
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -40,7 +76,10 @@ function deserializeStructArrayBody<T extends unknown[]>(
     }
 
     while (srcStart < srcEnd) {
-      const slot = ensureArrayElementSlot<T>(out, index);
+      const slot =
+        index < reusableLength
+          ? reusableDataStart + <usize>index * elementSize
+          : ensureArrayElementSlot<T>(out, index);
       let value = load<valueof<T>>(slot);
       if (changetype<usize>(value) == 0) {
         value = changetype<valueof<T>>(
@@ -54,31 +93,70 @@ function deserializeStructArrayBody<T extends unknown[]>(
         store<valueof<T>>(slot, value);
       }
 
+      const valueStart = srcStart;
       let next: usize = 0;
       if (
         // @ts-ignore: supplied by transform
         isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)
       ) {
+        // Omit the explicit type arg so AS infers it from `value` — passing
+        // `<valueof<T>>` explicitly collides when the element type is itself
+        // generic (e.g. GenericTest<string>) because AS resolves `T` against
+        // the element class's own generic rather than this function's `T`.
         // @ts-ignore: supplied by transform
-        next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<
-          valueof<T>
-        >(srcStart, srcEnd, value);
+        // @ts-ignore: supplied by transform in SIMD builds
+        if (
+          pretty &&
+          isDefined(
+            changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST_PRETTY,
+          )
+        ) {
+          // @ts-ignore: supplied by transform
+          next = changetype<nonnull<valueof<T>>>(
+            value,
+          ).__DESERIALIZE_FAST_PRETTY(srcStart, srcEnd, value);
+        } else {
+          next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST(
+            srcStart,
+            srcEnd,
+            value,
+          );
+        }
       }
       if (!next) {
+        // __DESERIALIZE_SLOW requires srcEnd to point just past the closing
+        // `}` of *this* element (it asserts srcEnd-2 == `}`). Scan the value
+        // boundary first, then re-initialize the object so any partial state
+        // from the failed FAST attempt is cleared.
+        const valueEnd = scanValueEnd(valueStart, srcEnd);
+        if (!valueEnd) break;
+        // @ts-ignore: supplied by transform
+        if (isDefined(changetype<nonnull<valueof<T>>>(value).__INITIALIZE)) {
+          // @ts-ignore: supplied by transform
+          changetype<nonnull<valueof<T>>>(value).__INITIALIZE();
+        }
         // @ts-ignore: supplied by transform
-        next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<
-          valueof<T>
-        >(srcStart, srcEnd, value);
+        changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW(
+          valueStart,
+          valueEnd,
+          value,
+        );
+        next = valueEnd;
       }
       if (!next) break;
       srcStart = next;
-      srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
       if (srcStart >= srcEnd) break;
 
-      const code = load<u16>(srcStart);
+      let code = load<u16>(srcStart);
+      if (code != COMMA && code != BRACKET_RIGHT) {
+        srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+        if (srcStart >= srcEnd) break;
+        code = load<u16>(srcStart);
+      }
       if (code == COMMA) {
         srcStart += 2;
-        srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+        if (srcStart < srcEnd && load<u16>(srcStart) != BRACE_LEFT)
+          srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
         index++;
         continue;
       }
@@ -87,15 +165,31 @@ function deserializeStructArrayBody<T extends unknown[]>(
         // right length (e.g. canada-style geometry rings whose count
         // matches a previous parse).
         const nextLen = index + 1;
-        if (out.length != nextLen) out.length = nextLen;
+        if (reusableLength != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
     }
   } while (false);
 
-  throw new Error("Failed to parse JSON!");
+  markProductionParseError();
+  return 0;
 }
+export function deserializeStructArray_SWAR<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  while (srcEnd > srcStart && isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+  const end = deserializeStructArrayBody<T>(srcStart, srcEnd, out);
+  if (end == srcEnd) return out;
+  markProductionParseError();
+  return changetype<T>(0);
+}
+
 export function deserializeStructArrayField<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,

package/assembly/deserialize/swar/float.ts

@@ -19,6 +19,7 @@
 import { ptrToStr } from "../../util/ptrToStr";
 import { parse4Digits_PairMul } from "../../util/swar-int";
 import { scientific } from "../../util/scientific";
+import { eiselLemire22 } from "../../util/eisel-lemire";
 
 export const POW10_F64_POS: usize = memory.data<f64>([
   1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14,
@@ -72,37 +73,37 @@ export function deserializeFloat_SWAR<T>(srcStart: usize, srcEnd: usize): T {
   // Integer part: scalar. Most JSON integers are 1-3 digits, so parse4 would
   // waste a validate per call.
   let mantissa: u64 = 0;
-  let intDigits: i32 = 0;
+  const intStart = p;
   while (p < srcEnd) {
     const d = <u32>load<u16>(p) - ASCII_ZERO;
     if (d > 9) break;
     mantissa = mantissa * 10 + <u64>d;
-    intDigits++;
     p += 2;
   }
+  const intDigits = <i32>((p - intStart) >> 1);
 
   // Fractional part: parse4 stride (8 bytes / 4 digits) → scalar tail.
   // parse8 was tried and benchmarked even/worse; the saved mantissa mul
   // didn't outweigh the extra load and combined-validation latency, and the
   // dependency chain is the same length either way.
-  let fracDigits: i32 = 0;
+  let fracStart = p;
   if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
     p += 2;
+    fracStart = p;
     while (p + 6 < srcEnd) {
       const parsed = parse4Digits_PairMul(load<u64>(p));
       if (parsed == U32.MAX_VALUE) break;
       mantissa = mantissa * 10_000 + <u64>parsed;
-      fracDigits += 4;
       p += 8;
     }
     while (p < srcEnd) {
       const d = <u32>load<u16>(p) - ASCII_ZERO;
       if (d > 9) break;
       mantissa = mantissa * 10 + <u64>d;
-      fracDigits++;
       p += 2;
     }
   }
+  const fracDigits = <i32>((p - fracStart) >> 1);
 
   const mantDigits = intDigits + fracDigits;
   if (mantDigits == 0) return fallback<T>(origStart, srcEnd);
@@ -158,7 +159,10 @@ export function deserializeFloat_SWAR<T>(srcStart: usize, srcEnd: usize): T {
       result /= loadPow10(<u32>-exponent);
     }
   } else if (mantDigits <= 19) {
-    result = scientific(mantissa, exponent);
+    result =
+      exponent >= -22 && exponent <= 22
+        ? eiselLemire22(mantissa, exponent)
+        : scientific(mantissa, exponent);
   } else {
     return fallback<T>(origStart, srcEnd);
   }
@@ -188,33 +192,33 @@ export function deserializeFloatField_SWAR<T extends number>(
   }
 
   let mantissa: u64 = 0;
-  let intDigits: i32 = 0;
+  const intStart = p;
   while (p < srcEnd) {
     const d = <u32>load<u16>(p) - ASCII_ZERO;
     if (d > 9) break;
     mantissa = mantissa * 10 + <u64>d;
-    intDigits++;
     p += 2;
   }
+  const intDigits = <i32>((p - intStart) >> 1);
 
-  let fracDigits: i32 = 0;
+  let fracStart = p;
   if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
     p += 2;
+    fracStart = p;
     while (p + 6 < srcEnd) {
       const parsed = parse4Digits_PairMul(load<u64>(p));
       if (parsed == U32.MAX_VALUE) break;
       mantissa = mantissa * 10_000 + <u64>parsed;
-      fracDigits += 4;
       p += 8;
     }
     while (p < srcEnd) {
       const d = <u32>load<u16>(p) - ASCII_ZERO;
       if (d > 9) break;
       mantissa = mantissa * 10 + <u64>d;
-      fracDigits++;
       p += 2;
     }
   }
+  const fracDigits = <i32>((p - fracStart) >> 1);
 
   const mantDigits = intDigits + fracDigits;
   if (mantDigits == 0) unreachable();
@@ -277,7 +281,10 @@ export function deserializeFloatField_SWAR<T extends number>(
       result /= loadPow10(<u32>-exponent);
     }
   } else if (mantDigits <= 19) {
-    result = scientific(mantissa, exponent);
+    result =
+      exponent >= -22 && exponent <= 22
+        ? eiselLemire22(mantissa, exponent)
+        : scientific(mantissa, exponent);
   } else {
     fallbackField<T>(origStart, p, fieldPtr);
     return p;