json-as 1.3.7 → 1.3.9

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

@@ -1,9 +1,24 @@
-import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import {
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+  NULL_WORD_U64,
+} from "../../../custom/chars";
+import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 import { deserializeStringField_SWAR } from "../string";
 
 
-@inline export function deserializeStringArrayInto<T extends string[]>(
+@inline function skipStringArrayWhitespace(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  return srcStart;
+}
+
+
+@inline function deserializeStringArrayBody<T extends string[]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -13,6 +28,7 @@ import { deserializeStringField_SWAR } from "../string";
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
+    srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -21,21 +37,41 @@ import { deserializeStringField_SWAR } from "../string";
 
     while (srcStart < srcEnd) {
       const slot = ensureArrayElementSlot<T>(out, index);
-      srcStart = deserializeStringField_SWAR<valueof<T>>(
-        srcStart,
-        srcEnd,
-        slot,
-      );
-      if (!srcStart || srcStart >= srcEnd) break;
+      // 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.
+      //
+      // We accept null tokens unconditionally rather than gating on
+      // `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
+      // `string[]` arrays is one extra u64 compare per element; a
+      // well-formed `string[]` input never matches it.
+      if (srcStart + 8 <= srcEnd && load<u64>(srcStart) == NULL_WORD_U64) {
+        store<usize>(slot, 0);
+        srcStart += 8;
+      } else {
+        srcStart = deserializeStringField_SWAR<valueof<T>>(
+          srcStart,
+          srcEnd,
+          slot,
+        );
+      }
+      if (!srcStart) break;
+      srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
+      if (srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
       if (code == COMMA) {
         srcStart += 2;
+        srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
         index++;
         continue;
       }
       if (code == BRACKET_RIGHT) {
-        out.length = index + 1;
+        const nextLen = index + 1;
+        if (out.length != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -51,9 +87,90 @@ import { deserializeStringField_SWAR } from "../string";
   srcEnd: usize,
   fieldPtr: usize,
 ): usize {
-  return deserializeStringArrayInto<T>(
+  return deserializeStringArrayBody<T>(
     srcStart,
     srcEnd,
     ensureArrayField<T>(fieldPtr),
   );
 }
+
+// Top-level entry for `JSON.parse<string[]>` / `JSON.parse<(string | null)[]>`.
+//
+// Pre-grows the destination array to a worst-case bound in one allocation,
+// then writes elements via `writePtr` direct stores. This sidesteps the
+// per-element growth cost of `deserializeStringArrayBody`'s
+// `ensureArrayElementSlot` path. The incremental runtime zero-initializes
+// new allocations, so `null` slots need no per-element store on cold
+// arrays (we still write 0 to handle reused arrays whose old refs would
+// otherwise leak through).
+export function deserializeStringArray_SWAR<T extends string[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+
+  // 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
+  // that exceed this would fail the `out.length =` setter anyway. For a
+  // 1 GiB UTF-16 source that maxes at ~256M slot allocation = ~1 GiB.
+  const elementSize: usize = sizeof<usize>();
+  const maxBlockElements: i32 = i32((<usize>0x40000000 - 16) / elementSize);
+  let maxElements: i32 = i32((<usize>(srcEnd - srcStart) + 5) / 6);
+  if (maxElements < 0 || maxElements > maxBlockElements) {
+    maxElements = maxBlockElements;
+  }
+  if (out.length < maxElements) out.length = maxElements;
+
+  const dataStart: usize = out.dataStart;
+  let writePtr: usize = dataStart;
+  const writePtrLimit: usize = dataStart + <usize>maxElements * elementSize;
+
+  // Caller guarantees srcStart is at the opening `[`.
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) {
+    out.length = 0;
+    return out;
+  }
+  srcStart += 2;
+  srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
+  if (srcStart < srcEnd && load<u16>(srcStart) == BRACKET_RIGHT) {
+    out.length = 0;
+    return out;
+  }
+
+  while (srcStart < srcEnd && writePtr < writePtrLimit) {
+    // Null fast path: one u64 compare.
+    if (srcStart + 8 <= srcEnd && load<u64>(srcStart) == NULL_WORD_U64) {
+      store<usize>(writePtr, 0);
+      srcStart += 8;
+    } else {
+      srcStart = deserializeStringField_SWAR<valueof<T>>(
+        srcStart,
+        srcEnd,
+        writePtr,
+      );
+      if (!srcStart) break;
+    }
+    writePtr += elementSize;
+    srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
+    if (srcStart >= srcEnd) break;
+
+    const code = load<u16>(srcStart);
+    if (code == COMMA) {
+      srcStart += 2;
+      srcStart = skipStringArrayWhitespace(srcStart, srcEnd);
+      continue;
+    }
+    if (code == BRACKET_RIGHT) {
+      const finalLen = i32(<usize>(writePtr - dataStart) / elementSize);
+      if (out.length != finalLen) out.length = finalLen;
+      return out;
+    }
+    break;
+  }
+
+  throw new Error("Failed to parse JSON!");
+}

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

@@ -1,8 +1,32 @@
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
 
-@inline export function deserializeStructArrayInto<T extends unknown[]>(
+@inline function skipStructArrayWhitespace(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  return srcStart;
+}
+
+// Per-element worker for `@json class Foo[]` fields. Each element is a
+// managed reference whose value is produced by the transform-generated
+// `__DESERIALIZE_FAST` / `__DESERIALIZE_SLOW` methods, so the loop pattern
+// is structurally different from primitive-array bodies:
+//
+//   - The slot stores a *reference*; reused arrays may already hold an
+//     allocated instance whose fields we just overwrite. Only allocate +
+//     `__INITIALIZE` when the slot is null.
+//   - `__DESERIALIZE_FAST` returns the cursor past the closing `}` on
+//     success, or `0` to signal "bail to slow path". We mirror the
+//     dispatcher in `JSON.__deserialize` here: try FAST first, fall back
+//     to SLOW on `0`.
+//   - Whitespace is skipped at each separator boundary so struct-array
+//     fields tolerate the same `[ {...} , {...} ]` shape that top-level
+//     `JSON.parse` does.
+@inline function deserializeStructArrayBody<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -12,6 +36,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
+    srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -33,31 +58,40 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
         store<valueof<T>>(slot, value);
       }
 
-      const valueStart = srcStart;
-      // @ts-ignore: supplied by transform
+      let next: usize = 0;
       if (
+        // @ts-ignore: supplied by transform
         isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)
       ) {
         // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<
+        next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<
           valueof<T>
-        >(valueStart, srcEnd, value);
-      } else {
+        >(srcStart, srcEnd, value);
+      }
+      if (!next) {
         // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<
+        next = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<
           valueof<T>
-        >(valueStart, srcEnd, value);
+        >(srcStart, srcEnd, value);
       }
-      if (!srcStart || srcStart >= srcEnd) break;
+      if (!next) break;
+      srcStart = next;
+      srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
+      if (srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
       if (code == COMMA) {
         srcStart += 2;
+        srcStart = skipStructArrayWhitespace(srcStart, srcEnd);
         index++;
         continue;
       }
       if (code == BRACKET_RIGHT) {
-        out.length = index + 1;
+        // Skip `ensureCapacity` when the reused array already has the
+        // 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;
         return srcStart + 2;
       }
       break;
@@ -73,7 +107,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   srcEnd: usize,
   fieldPtr: usize,
 ): usize {
-  return deserializeStructArrayInto<T>(
+  return deserializeStructArrayBody<T>(
     srcStart,
     srcEnd,
     ensureArrayField<T>(fieldPtr),

package/assembly/deserialize/swar/array.ts

@@ -11,14 +11,8 @@ import { deserializeObjectArrayField } from "./array/object";
 import { deserializeRawArrayField } from "./array/raw";
 import { deserializeStringArrayField } from "./array/string";
 import { deserializeStructArrayField } from "./array/struct";
-import { deserializeArrayArrayInto } from "./array/array";
-import { deserializeBooleanArrayInto } from "./array/bool";
-import { deserializeFloatArrayInto } from "./array/float";
-import { deserializeGenericArrayInto } from "./array/generic";
-import { deserializeIntegerArrayInto } from "./array/integer";
-import { deserializeObjectArrayInto } from "./array/object";
-import { deserializeStringArrayInto } from "./array/string";
-import { deserializeStructArrayInto } from "./array/struct";
+
+export { deserializeArrayField as deserializeArrayField_SWAR };
 
 
 @inline export function deserializeArrayField<T extends unknown[]>(
@@ -69,51 +63,3 @@ import { deserializeStructArrayInto } from "./array/struct";
     throw new Error("Could not parse array field of type " + nameof<T>() + "!");
   }
 }
-
-
-@inline export function deserializeArrayInto_SWAR<T extends unknown[]>(
-  srcStart: usize,
-  srcEnd: usize,
-  out: T,
-): usize {
-  if (isString<valueof<T>>()) {
-    return deserializeStringArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isBoolean<valueof<T>>()) {
-    return deserializeBooleanArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isInteger<valueof<T>>()) {
-    return deserializeIntegerArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isFloat<valueof<T>>()) {
-    return deserializeFloatArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isArray<valueof<T>>()) {
-    return deserializeArrayArrayInto<T>(srcStart, srcEnd, out);
-  } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
-    const type = changetype<nonnull<valueof<T>>>(0);
-    if (type instanceof JSON.Value) {
-      return deserializeGenericArrayInto<T>(srcStart, srcEnd, out);
-    } else if (type instanceof JSON.Box) {
-      throw new Error("Failed to parse JSON!");
-    } else if (type instanceof JSON.Obj) {
-      return deserializeObjectArrayInto<T>(srcStart, srcEnd, out);
-    } else if (type instanceof JSON.Raw) {
-      throw new Error("Failed to parse JSON!");
-    } else if (type instanceof Date) {
-      return deserializeGenericArrayInto<T>(srcStart, srcEnd, out);
-    } else if (type instanceof Set) {
-      return deserializeGenericArrayInto<T>(srcStart, srcEnd, out);
-    } else if (type instanceof Map) {
-      throw new Error("Failed to parse JSON!");
-      // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
-      return deserializeStructArrayInto<T>(srcStart, srcEnd, out);
-      // @ts-ignore: defined by transform
-    } else if (
-      isDefined(type.__DESERIALIZE_SLOW) ||
-      isDefined(type.__DESERIALIZE_FAST)
-    ) {
-      return deserializeStructArrayInto<T>(srcStart, srcEnd, out);
-    }
-    throw new Error("Could not parse array field of type " + nameof<T>() + "!");
-  } else {
-    throw new Error("Could not parse array field of type " + nameof<T>() + "!");
-  }
-}

package/assembly/deserialize/swar/float.ts

@@ -0,0 +1,304 @@
+// SWAR float deserializers. Lemire-style fast path with parse4 SWAR digit
+// folding on the fractional accumulator. Output is bit-identical to
+// `f64.parse` / `f32.parse` (the NAIVE baseline) on the fast path because:
+//
+//   - the u64 mantissa accumulator is exact (no rounding in the digit loop),
+//   - `1e0 .. 1e22` are exactly representable in f64, and
+//   - a single fmul/fdiv on two exact operands is correctly rounded.
+//
+// Pathological inputs (>19 mantissa digits, mantissa > 2^53, or |exp| > 22)
+// fall through to `f64.parse` / `f32.parse` over the float's own range so the
+// SWAR result matches the NAIVE result for every input.
+//
+// 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
+// stride there pays the wasted-validate cost on every call without saving
+// enough scalar iterations.
+
+import { ptrToStr } from "../../util/ptrToStr";
+import { parse4Digits_PairMul } from "../../util/swar-int";
+import { scientific } from "../../util/scientific";
+
+export 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,
+]);
+export const MAX_EXACT_POW10: i32 = 22;
+// 2^53. Any u64 mantissa <= this is exact in f64.
+export const MAX_EXACT_MANTISSA: u64 = 1 << 53;
+
+const ASCII_PLUS: u16 = 43;
+const ASCII_MINUS: u16 = 45;
+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 {
+  return load<f64>(POW10_F64_POS + ((<usize>exp) << 3));
+}
+
+// @ts-ignore: inline
+@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+  const s = ptrToStr(srcStart, srcEnd);
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return <T>f64.parse(s);
+  // @ts-ignore
+  return <T>(<f32>f32.parse(s));
+}
+
+// @ts-ignore: inline
+@inline function fallbackField<T extends number>(
+  origStart: usize,
+  end: usize,
+  fieldPtr: usize,
+): void {
+  const s = ptrToStr(origStart, end);
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, f32.parse(s));
+  } else {
+    store<f64>(fieldPtr, f64.parse(s));
+  }
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloat_SWAR<T>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  const origStart = srcStart;
+  let p = srcStart;
+  let negative = false;
+  if (p < srcEnd && load<u16>(p) == ASCII_MINUS) {
+    negative = true;
+    p += 2;
+  }
+
+  // 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;
+  while (p < srcEnd) {
+    const d = <u32>load<u16>(p) - ASCII_ZERO;
+    if (d > 9) break;
+    mantissa = mantissa * 10 + <u64>d;
+    intDigits++;
+    p += 2;
+  }
+
+  // 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;
+  if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
+    p += 2;
+    while (p + 6 < srcEnd) {
+      const parsed = inline.always(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 mantDigits = intDigits + fracDigits;
+  if (mantDigits == 0) return fallback<T>(origStart, srcEnd);
+
+  let exponent: i32 = -fracDigits;
+
+  // Optional `e[+-]NNN` suffix.
+  if (p < srcEnd) {
+    const c = load<u16>(p);
+    if (c == ASCII_E_LO || c == ASCII_E_UP) {
+      const expStart = p;
+      p += 2;
+      if (p >= srcEnd) return fallback<T>(origStart, expStart);
+      let expNeg = false;
+      const sc = load<u16>(p);
+      if (sc == ASCII_MINUS) {
+        expNeg = true;
+        p += 2;
+      } else if (sc == ASCII_PLUS) {
+        p += 2;
+      }
+      if (p >= srcEnd) return fallback<T>(origStart, expStart);
+      let exp: i32 = 0;
+      let expDigits: i32 = 0;
+      while (p < srcEnd) {
+        const d = <u32>load<u16>(p) - ASCII_ZERO;
+        if (d > 9) break;
+        exp = exp * 10 + <i32>d;
+        expDigits++;
+        if (expDigits > 4) return fallback<T>(origStart, srcEnd);
+        p += 2;
+      }
+      if (expDigits == 0) return fallback<T>(origStart, expStart);
+      exponent += expNeg ? -exp : exp;
+    }
+  }
+
+  // Lemire fast path when fully in range; `scientific` for u64-fitting
+  // mantissas that exceed 2^53 or |exp| > 22 (still correctly rounded, but
+  // via the scaledown/scaleup path); `f*.parse` fallback only for >19
+  // mantissa digits where the sticky-bit handling matters.
+  let result: f64;
+  if (
+    mantDigits <= 19 &&
+    mantissa <= MAX_EXACT_MANTISSA &&
+    exponent <= MAX_EXACT_POW10 &&
+    exponent >= -MAX_EXACT_POW10
+  ) {
+    result = <f64>mantissa;
+    if (exponent > 0) {
+      result *= loadPow10(<u32>exponent);
+    } else if (exponent < 0) {
+      result /= loadPow10(<u32>-exponent);
+    }
+  } else if (mantDigits <= 19) {
+    result = scientific(mantissa, exponent);
+  } else {
+    return fallback<T>(origStart, srcEnd);
+  }
+  if (negative) result = -result;
+
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return <T>result;
+  // @ts-ignore
+  return <T>(<f32>result);
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloatField_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const fieldPtr = dstObj + dstOffset;
+  const origStart = srcStart;
+  let p = srcStart;
+  let negative = false;
+  if (p < srcEnd && load<u16>(p) == ASCII_MINUS) {
+    negative = true;
+    p += 2;
+  }
+
+  let mantissa: u64 = 0;
+  let intDigits: i32 = 0;
+  while (p < srcEnd) {
+    const d = <u32>load<u16>(p) - ASCII_ZERO;
+    if (d > 9) break;
+    mantissa = mantissa * 10 + <u64>d;
+    intDigits++;
+    p += 2;
+  }
+
+  let fracDigits: i32 = 0;
+  if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
+    p += 2;
+    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 mantDigits = intDigits + fracDigits;
+  if (mantDigits == 0) unreachable();
+
+  let exponent: i32 = -fracDigits;
+
+  if (p < srcEnd) {
+    const c = load<u16>(p);
+    if (c == ASCII_E_LO || c == ASCII_E_UP) {
+      const expStart = p;
+      p += 2;
+      if (p >= srcEnd) {
+        fallbackField<T>(origStart, expStart, fieldPtr);
+        return expStart;
+      }
+      let expNeg = false;
+      const sc = load<u16>(p);
+      if (sc == ASCII_MINUS) {
+        expNeg = true;
+        p += 2;
+      } else if (sc == ASCII_PLUS) {
+        p += 2;
+      }
+      if (p >= srcEnd) {
+        fallbackField<T>(origStart, expStart, fieldPtr);
+        return expStart;
+      }
+      let exp: i32 = 0;
+      let expDigits: i32 = 0;
+      while (p < srcEnd) {
+        const d = <u32>load<u16>(p) - ASCII_ZERO;
+        if (d > 9) break;
+        exp = exp * 10 + <i32>d;
+        expDigits++;
+        if (expDigits > 4) {
+          fallbackField<T>(origStart, p, fieldPtr);
+          return p;
+        }
+        p += 2;
+      }
+      if (expDigits == 0) {
+        fallbackField<T>(origStart, expStart, fieldPtr);
+        return expStart;
+      }
+      exponent += expNeg ? -exp : exp;
+    }
+  }
+
+  let result: f64;
+  if (
+    mantDigits <= 19 &&
+    mantissa <= MAX_EXACT_MANTISSA &&
+    exponent <= MAX_EXACT_POW10 &&
+    exponent >= -MAX_EXACT_POW10
+  ) {
+    result = <f64>mantissa;
+    if (exponent > 0) {
+      result *= loadPow10(<u32>exponent);
+    } else if (exponent < 0) {
+      result /= loadPow10(<u32>-exponent);
+    }
+  } else if (mantDigits <= 19) {
+    result = scientific(mantissa, exponent);
+  } else {
+    fallbackField<T>(origStart, p, fieldPtr);
+    return p;
+  }
+  if (negative) result = -result;
+
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, <f32>result);
+  } else {
+    store<f64>(fieldPtr, result);
+  }
+
+  return p;
+}