json-as 1.3.6 → 1.3.7

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

@@ -1,7 +1,17 @@
-import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA, QUOTE } from "../../../custom/chars";
-
-
-@inline export function ensureArrayField<T extends Array<any>>(fieldPtr: usize): T {
+import {
+  BACK_SLASH,
+  BRACE_LEFT,
+  BRACE_RIGHT,
+  BRACKET_LEFT,
+  BRACKET_RIGHT,
+  COMMA,
+  QUOTE,
+} from "../../../custom/chars";
+
+
+@inline export function ensureArrayField<T extends Array<any>>(
+  fieldPtr: usize,
+): T {
   let out = load<T>(fieldPtr);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
@@ -11,7 +21,10 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 }
 
 
-@inline export function ensureArrayFieldAt<T extends Array<any>>(dstObj: usize, dstOffset: usize): T {
+@inline export function ensureArrayFieldAt<T extends Array<any>>(
+  dstObj: usize,
+  dstOffset: usize,
+): T {
   let out = load<T>(dstObj, dstOffset);
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
@@ -24,25 +37,35 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 @inline function backslashOrQuoteMask(block: u64): u64 {
   const b = block ^ 0x005c_005c_005c_005c;
   const q = block ^ 0x0022_0022_0022_0022;
-  return (((q - 0x0001_0001_0001_0001) & ~q) | ((b - 0x0001_0001_0001_0001) & ~b)) & 0x0080_0080_0080_0080;
+  return (
+    (((q - 0x0001_0001_0001_0001) & ~q) | ((b - 0x0001_0001_0001_0001) & ~b)) &
+    0x0080_0080_0080_0080
+  );
 }
 
 
-@inline export function ensureArrayElementSlot<T extends Array<any>>(out: T, index: i32): usize {
+@inline export function ensureArrayElementSlot<T extends Array<any>>(
+  out: T,
+  index: i32,
+): usize {
   const nextLength = index + 1;
   if (out.length < nextLength) {
     out.length = nextLength;
     const slot = out.dataStart + <usize>index * sizeof<valueof<T>>();
     // Reference arrays can allocate recursively before the caller stores the new element.
     // Zero the newly exposed slot immediately so incremental GC never observes a garbage pointer.
-    if (isManaged<valueof<T>>() || isReference<valueof<T>>()) store<usize>(slot, 0);
+    if (isManaged<valueof<T>>() || isReference<valueof<T>>())
+      store<usize>(slot, 0);
     return slot;
   }
   return out.dataStart + <usize>index * sizeof<valueof<T>>();
 }
 
 
-@inline export function scanQuotedValueEnd_SWAR(srcStart: usize, srcEnd: usize): usize {
+@inline export function scanQuotedValueEnd_SWAR(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
   srcStart += 2;
   const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
 
@@ -67,7 +90,8 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 
   while (srcStart < srcEnd) {
     const char = load<u16>(srcStart);
-    if (char == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH) return srcStart + 2;
+    if (char == QUOTE && load<u16>(srcStart - 2) != BACK_SLASH)
+      return srcStart + 2;
     srcStart += 2;
   }
 
@@ -103,7 +127,8 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
-    if (code == COMMA || code == BRACKET_RIGHT || code == BRACE_RIGHT) return srcStart;
+    if (code == COMMA || code == BRACKET_RIGHT || code == BRACE_RIGHT)
+      return srcStart;
     srcStart += 2;
   }
 

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

@@ -3,7 +3,11 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 import { deserializeStringField_SWAR } from "../string";
 
 
-@inline export function deserializeStringArrayInto<T extends string[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline export function deserializeStringArrayInto<T extends string[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   let index = 0;
 
   do {
@@ -17,7 +21,11 @@ import { deserializeStringField_SWAR } from "../string";
 
     while (srcStart < srcEnd) {
       const slot = ensureArrayElementSlot<T>(out, index);
-      srcStart = deserializeStringField_SWAR<valueof<T>>(srcStart, srcEnd, slot);
+      srcStart = deserializeStringField_SWAR<valueof<T>>(
+        srcStart,
+        srcEnd,
+        slot,
+      );
       if (!srcStart || srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
@@ -38,6 +46,14 @@ import { deserializeStringField_SWAR } from "../string";
 }
 
 
-@inline export function deserializeStringArrayField<T extends string[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  return deserializeStringArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+@inline export function deserializeStringArrayField<T extends string[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
+  return deserializeStringArrayInto<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
 }

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

@@ -2,7 +2,11 @@ import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
 
-@inline export function deserializeStructArrayInto<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@inline export function deserializeStructArrayInto<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  out: T,
+): usize {
   let index = 0;
 
   do {
@@ -18,7 +22,9 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
       const slot = ensureArrayElementSlot<T>(out, index);
       let value = load<valueof<T>>(slot);
       if (changetype<usize>(value) == 0) {
-        value = changetype<valueof<T>>(__new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<valueof<T>>>()));
+        value = changetype<valueof<T>>(
+          __new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<valueof<T>>>()),
+        );
         // @ts-ignore: supplied by transform
         if (isDefined(changetype<nonnull<valueof<T>>>(value).__INITIALIZE)) {
           // @ts-ignore: supplied by transform
@@ -29,12 +35,18 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
       const valueStart = srcStart;
       // @ts-ignore: supplied by transform
-      if (isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)) {
+      if (
+        isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)
+      ) {
         // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<valueof<T>>(valueStart, srcEnd, value);
+        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<
+          valueof<T>
+        >(valueStart, srcEnd, value);
       } else {
         // @ts-ignore: supplied by transform
-        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<valueof<T>>(valueStart, srcEnd, value);
+        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<
+          valueof<T>
+        >(valueStart, srcEnd, value);
       }
       if (!srcStart || srcStart >= srcEnd) break;
 
@@ -56,6 +68,14 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 }
 
 
-@inline export function deserializeStructArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  return deserializeStructArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+@inline export function deserializeStructArrayField<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  fieldPtr: usize,
+): usize {
+  return deserializeStructArrayInto<T>(
+    srcStart,
+    srcEnd,
+    ensureArrayField<T>(fieldPtr),
+  );
 }

package/assembly/deserialize/swar/array.ts

@@ -21,7 +21,12 @@ import { deserializeStringArrayInto } from "./array/string";
 import { deserializeStructArrayInto } from "./array/struct";
 
 
-@inline export function deserializeArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+@inline export function deserializeArrayField<T extends unknown[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
   const fieldPtr = dstObj + dstOffset;
   if (isString<valueof<T>>()) {
     return deserializeStringArrayField<T>(srcStart, srcEnd, fieldPtr);
@@ -53,7 +58,10 @@ import { deserializeStructArrayInto } from "./array/struct";
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
       return deserializeStructArrayField<T>(srcStart, srcEnd, fieldPtr);
       // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
+    } else if (
+      isDefined(type.__DESERIALIZE_SLOW) ||
+      isDefined(type.__DESERIALIZE_FAST)
+    ) {
       return deserializeStructArrayField<T>(srcStart, srcEnd, fieldPtr);
     }
     throw new Error("Could not parse array field of type " + nameof<T>() + "!");
@@ -63,7 +71,11 @@ import { deserializeStructArrayInto } from "./array/struct";
 }
 
 
-@inline export function deserializeArrayInto_SWAR<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+@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>>()) {
@@ -94,7 +106,10 @@ import { deserializeStructArrayInto } from "./array/struct";
     } 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)) {
+    } 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>() + "!");

package/assembly/deserialize/swar/integer.ts

@@ -0,0 +1,246 @@
+// SWAR integer deserializers (signed + unsigned) over UTF-16 sources.
+//
+// Consume-to-end paths use the full tiered stride hierarchy:
+//
+// - parse16 (32 bytes / 16 digits): best for long inputs
+// - parse8  (16 bytes /  8 digits)
+// - parse4  ( 8 bytes /  4 digits)
+// - scalar  ( 2 bytes /  1 digit )
+//
+// Scan paths use asymmetric tuning based on empirical h2h benches:
+//
+// - Unsigned scan: parse8 + scalar (no parse4). For unsigned inputs the
+//   digit run is aligned, so parse8 either succeeds cleanly or terminates
+//   early. The intermediate parse4 stride costs more in wasted-validate
+//   than it saves in successful work.
+// - Signed scan: parse4 + scalar (no parse8). The leading minus consumes
+//   2 bytes, shifting the digit run into parse8's "terminator-in-load"
+//   zone where validate-fail is common. parse4 is a smaller failure unit.
+//
+// parse16 is omitted from scan entirely: a 16-character digit run plus
+// terminator fits in its 32-byte load, so the terminator triggers a wasted
+// validate-fail at the boundary.
+
+import {
+  parse4Digits_PairMul,
+  parse4Digits_PairMul_Unsafe,
+  parse8Digits_PairMul,
+  parse8Digits_PairMul_Unsafe,
+  parse16Digits_SWAR,
+  parse16Digits_SWAR_Unsafe,
+} from "../../util/swar-int";
+
+const ASCII_MINUS: u16 = 45;
+const ASCII_ZERO: u16 = 48;
+
+/**
+ * Store a signed value into a typed integer field, truncating to `T`'s width.
+ *
+ * @param dstPtr Destination pointer (already includes any field offset).
+ * @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 {
+  if (sizeof<T>() == 1) {
+    store<i8>(dstPtr, <i8>value);
+  } else if (sizeof<T>() == 2) {
+    store<i16>(dstPtr, <i16>value);
+  } else if (sizeof<T>() == 4) {
+    store<i32>(dstPtr, <i32>value);
+  } else {
+    store<i64>(dstPtr, <i64>value);
+  }
+}
+
+/**
+ * Store an unsigned value into a typed integer field, truncating to `T`'s
+ * width.
+ *
+ * @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>(
+  dstPtr: usize,
+  value: u64,
+): void {
+  if (sizeof<T>() == 1) {
+    store<u8>(dstPtr, <u8>value);
+  } else if (sizeof<T>() == 2) {
+    store<u16>(dstPtr, <u16>value);
+  } else if (sizeof<T>() == 4) {
+    store<u32>(dstPtr, <u32>value);
+  } else {
+    store<u64>(dstPtr, value);
+  }
+}
+
+/**
+ * Parse a signed integer by consuming the entire `[srcStart, srcEnd)` range
+ * as a digit run, with an optional leading `-`.
+ *
+ * Caller guarantees the range is well-formed (optional minus followed by
+ * digits only). Uses the unsafe SWAR kernels with no per-stride validation.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @param srcEnd   Pointer just past the last code unit.
+ * @returns The parsed value, two's-complement truncated to `T`.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeInteger_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  let negative = false;
+  if (srcStart < srcEnd && load<u16>(srcStart) == ASCII_MINUS) {
+    negative = true;
+    srcStart += 2;
+  }
+  let value: u64 = 0;
+  while (srcStart + 30 < srcEnd) {
+    value =
+      value * 10_000_000_000_000_000 + parse16Digits_SWAR_Unsafe(srcStart);
+    srcStart += 32;
+  }
+  while (srcStart + 14 < srcEnd) {
+    value =
+      value * 100_000_000 +
+      parse8Digits_PairMul_Unsafe(load<u64>(srcStart), load<u64>(srcStart, 8));
+    srcStart += 16;
+  }
+  while (srcStart + 6 < srcEnd) {
+    value = value * 10_000 + parse4Digits_PairMul_Unsafe(load<u64>(srcStart));
+    srcStart += 8;
+  }
+  while (srcStart < srcEnd) {
+    value = value * 10 + (<u32>load<u16>(srcStart) - ASCII_ZERO);
+    srcStart += 2;
+  }
+  return <T>(negative ? 0 - value : value);
+}
+
+/**
+ * Scan for a signed integer field, stopping at the first non-digit
+ * character. Writes the parsed value through `dstObj + dstOffset` and
+ * returns the source position immediately after the last digit.
+ *
+ * Used by struct field deserializers, where the digit run is followed by
+ * a `,`, `}`, `]`, whitespace, etc.
+ *
+ * @param srcStart  Pointer to the first UTF-16 code unit.
+ * @param srcEnd    Pointer just past the last code unit.
+ * @param dstObj    Destination object pointer.
+ * @param dstOffset Byte offset of the field within `dstObj`.
+ * @returns The source position immediately after the last digit consumed.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeIntegerField_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  let negative = false;
+  if (srcStart < srcEnd && load<u16>(srcStart) == ASCII_MINUS) {
+    negative = true;
+    srcStart += 2;
+  }
+  let value: u64 = 0;
+  // Signed scan uses parse4 + scalar only (see file header).
+  while (srcStart + 6 < srcEnd) {
+    const parsed = parse4Digits_PairMul(load<u64>(srcStart));
+    if (parsed == U32.MAX_VALUE) break;
+    value = value * 10_000 + parsed;
+    srcStart += 8;
+  }
+  while (srcStart < srcEnd) {
+    const digit = <u32>load<u16>(srcStart) - ASCII_ZERO;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+  storeSignedToField<T>(dstObj + dstOffset, negative ? 0 - value : value);
+  return srcStart;
+}
+
+/**
+ * Parse an unsigned integer by consuming the entire `[srcStart, srcEnd)`
+ * range as a digit run.
+ *
+ * Caller guarantees the range is digits only. Uses the unsafe SWAR kernels
+ * with no per-stride validation.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @param srcEnd   Pointer just past the last code unit.
+ * @returns The parsed value, truncated to `T`.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeUnsigned_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  let value: u64 = 0;
+  while (srcStart + 30 < srcEnd) {
+    value =
+      value * 10_000_000_000_000_000 + parse16Digits_SWAR_Unsafe(srcStart);
+    srcStart += 32;
+  }
+  while (srcStart + 14 < srcEnd) {
+    value =
+      value * 100_000_000 +
+      parse8Digits_PairMul_Unsafe(load<u64>(srcStart), load<u64>(srcStart, 8));
+    srcStart += 16;
+  }
+  while (srcStart + 6 < srcEnd) {
+    value = value * 10_000 + parse4Digits_PairMul_Unsafe(load<u64>(srcStart));
+    srcStart += 8;
+  }
+  while (srcStart < srcEnd) {
+    value = value * 10 + (<u32>load<u16>(srcStart) - ASCII_ZERO);
+    srcStart += 2;
+  }
+  return <T>value;
+}
+
+/**
+ * Scan for an unsigned integer field, stopping at the first non-digit
+ * character. Writes the parsed value through `dstObj + dstOffset` and
+ * returns the source position immediately after the last digit.
+ *
+ * @param srcStart  Pointer to the first UTF-16 code unit.
+ * @param srcEnd    Pointer just past the last code unit.
+ * @param dstObj    Destination object pointer.
+ * @param dstOffset Byte offset of the field within `dstObj`.
+ * @returns The source position immediately after the last digit consumed.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeUnsignedField_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  let value: u64 = 0;
+  // Unsigned scan uses parse8 + scalar only (see file header).
+  while (srcStart + 14 < srcEnd) {
+    const parsed = parse8Digits_PairMul(
+      load<u64>(srcStart),
+      load<u64>(srcStart, 8),
+    );
+    if (parsed == U32.MAX_VALUE) break;
+    value = value * 100_000_000 + parsed;
+    srcStart += 16;
+  }
+  while (srcStart < srcEnd) {
+    const digit = <u32>load<u16>(srcStart) - ASCII_ZERO;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+  storeUnsignedToField<T>(dstObj + dstOffset, value);
+  return srcStart;
+}