json-as 1.3.9 → 1.5.0

package/assembly/serialize/index/arbitrary.ts

@@ -1,21 +1,77 @@
 import { JSON } from "../..";
 import { bs } from "../../../lib/as-bs";
-import { serializeArray } from "./array";
+import { bytes } from "../../util/bytes";
+import { QUOTE } from "../../custom/chars";
 import { serializeBool } from "./bool";
 import { serializeFloat32, serializeFloat64 } from "./float";
 import { serializeInteger } from "./integer";
+import { serializeJsonArray } from "./jsonarray";
 import { serializeMap } from "./map";
 import { serializeObject } from "./object";
+import { serializeRaw } from "../naive/raw";
 import { serializeString } from "./string";
 import { serializeDynamic } from "./typedarray";
 
+// True if any code unit would need JSON-escaping on serialize: a quote,
+// backslash, control char (< 0x20), or a surrogate (handled conservatively -
+// even valid pairs route to the full path, since they can't be bulk-copied as a
+// plain run). A clean string is none of these, so it emits as a verbatim memcpy.
+// @ts-ignore: decorator
+@inline function stringNeedsEscape(src: string): bool {
+  let ptr = changetype<usize>(src);
+  const end = ptr + <usize>bytes(src);
+  while (ptr < end) {
+    const code = load<u16>(ptr);
+    if (
+      code == 0x22 ||
+      code == 0x5c ||
+      code < 0x20 ||
+      (code >= 0xd800 && code <= 0xdfff)
+    )
+      return true;
+    ptr += 2;
+  }
+  return false;
+}
+
+// Fast path for a string already known to need no escaping: quote + a single
+// bulk copy of the UTF-16 bytes + quote. Skips the per-char escape scan that
+// serializeString would otherwise do (and its trailing second pass).
+function serializeStringClean(src: string): void {
+  const size = <usize>bytes(src);
+  bs.proposeSize(size + 4);
+  store<u16>(bs.offset, QUOTE);
+  bs.offset += 2;
+  memory.copy(bs.offset, changetype<usize>(src), size);
+  bs.offset += size;
+  store<u16>(bs.offset, QUOTE);
+  bs.offset += 2;
+}
+
 export function serializeArbitrary(src: JSON.Value): void {
+  // Verbatim passthrough: an untouched (still-deferred) value emits its original
+  // source bytes directly - no materialization, no re-encoding. Peek the slice
+  // without reading `src.type` (which would force materialization).
+  const lz = src.__lazySlice();
+  if (lz != 0) {
+    const start = <usize>(lz >>> 32);
+    const size = <usize>(<u32>lz) - start;
+    bs.proposeSize(size);
+    memory.copy(bs.offset, start, size);
+    bs.offset += size;
+    return;
+  }
   switch (src.type) {
     case JSON.Types.Null:
       bs.proposeSize(8);
       store<u64>(bs.offset, 30399761348886638);
       bs.offset += 8;
       break;
+    case JSON.Types.Raw:
+      // A materialized JSON.Raw value (e.g. set into a JSON.Obj/Arr) emits its
+      // pre-formatted bytes as-is - without this it fell into the struct default.
+      serializeRaw(src.get<JSON.Raw>());
+      break;
     case JSON.Types.U8:
       serializeInteger<u8>(src.get<u8>());
       break;
@@ -46,14 +102,24 @@ export function serializeArbitrary(src: JSON.Value): void {
     case JSON.Types.F64:
       serializeFloat64(src.get<f64>());
       break;
-    case JSON.Types.String:
-      serializeString(src.get<string>());
+    case JSON.Types.String: {
+      const str = src.get<string>();
+      // Reuse the cached escape class; classify once on first serialize. Clean
+      // strings (the common case) then emit as a single memcpy on every reuse.
+      let cls = src.__strClass();
+      if (cls == 0) {
+        cls = stringNeedsEscape(str) ? 2 : 1;
+        src.__setStrClass(cls);
+      }
+      if (cls == 1) serializeStringClean(str);
+      else serializeString(str);
       break;
+    }
     case JSON.Types.Bool:
       serializeBool(src.get<bool>());
       break;
     case JSON.Types.Array:
-      serializeArray(src.get<JSON.Value[]>());
+      serializeJsonArray(src.get<JSON.Arr>());
       break;
     case JSON.Types.Object:
       serializeObject(src.get<JSON.Obj>());

package/assembly/serialize/index/jsonarray.ts

@@ -0,0 +1,51 @@
+import { bs } from "../../../lib/as-bs";
+import { JSON } from "../..";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
+import { serializeArbitrary } from "./arbitrary";
+
+export function serializeJsonArray(src: JSON.Arr): void {
+  const n = src.length;
+
+  if (n == 0) {
+    bs.proposeSize(4);
+    store<u32>(bs.offset, 6094939); // "[]"
+    bs.offset += 4;
+    return;
+  }
+
+  const vals = src._vals;
+  // Source base + upper bound for resolving a deferred slot's value range.
+  const srcBase = changetype<usize>(src._src);
+  const srcEnd = srcBase + ((<usize>src._src.length) << 1);
+
+  bs.proposeSize(4 + <u32>(n - 1) * 2);
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+
+  // A still-deferred slot is copied out verbatim from the source; an
+  // eager/materialized slot is serialized from its boxed bits.
+  for (let i = 0; i < n; i++) {
+    if (i != 0) {
+      store<u16>(bs.offset, COMMA);
+      bs.offset += 2;
+    }
+    const slot = unchecked(vals[i]);
+    if (JSON.Value.slotIsLazy(slot)) {
+      const start = JSON.Value.slotPtr(slot, srcBase);
+      const end = JSON.Value.slotEnd(slot, srcBase, srcEnd);
+      const size = end - start;
+      bs.proposeSize(size);
+      memory.copy(bs.offset, start, size);
+      bs.offset += size;
+    } else {
+      const v = JSON.Value.fromBits(slot);
+      serializeArbitrary(v);
+      // Persist a cached String escape-class back into the slot (see object.ts).
+      const nb = v.__bits();
+      if (nb != slot) unchecked((vals[i] = nb));
+    }
+  }
+
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/index/object.ts

@@ -2,11 +2,10 @@ import { bs } from "../../../lib/as-bs";
 import { JSON } from "../..";
 import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
 import { serializeArbitrary } from "./arbitrary";
-import { serializeString } from "./string";
+import { serializeStringRange } from "../naive/string";
 
 export function serializeObject(src: JSON.Obj): void {
   const srcSize = src.size;
-  const srcEnd = srcSize - 1;
 
   if (srcSize == 0) {
     bs.proposeSize(4);
@@ -15,28 +14,54 @@ export function serializeObject(src: JSON.Obj): void {
     return;
   }
 
-  const keys = src.keys();
-  const values = src.values();
+  const vals = src._vals;
+  const kbuf = changetype<usize>(src._kbuf);
+  const kused = src._kused;
+  // Source base + upper bound for resolving a deferred slot's value range.
+  const srcBase = changetype<usize>(src._src);
+  const srcEnd = srcBase + ((<usize>src._src.length) << 1);
 
   bs.proposeSize(4 + <u32>(srcSize - 1) * 2 + <u32>srcSize * 2);
   store<u16>(bs.offset, BRACE_LEFT);
   bs.offset += 2;
 
-  for (let i = 0; i < srcEnd; i++) {
-    serializeString(unchecked(keys[i]));
+  // Walk the length-prefixed key buffer in lockstep with the value slots,
+  // emitting each key straight from its slice (no per-key string
+  // materialization). A still-deferred slot is copied out verbatim from the
+  // source; an eager/materialized slot is serialized from its boxed bits.
+  let pos = 0;
+  let i = 0;
+  while (pos < kused) {
+    const len = <i32>load<u16>(kbuf + ((<usize>pos) << 1));
+    if (i != 0) {
+      store<u16>(bs.offset, COMMA);
+      bs.offset += 2;
+    }
+    serializeStringRange(kbuf + ((<usize>(pos + 1)) << 1), (<usize>len) << 1);
     store<u16>(bs.offset, COLON);
     bs.offset += 2;
 
-    serializeArbitrary(unchecked(values[i]));
-    store<u16>(bs.offset, COMMA);
-    bs.offset += 2;
+    const slot = unchecked(vals[i]);
+    if (JSON.Value.slotIsLazy(slot)) {
+      const start = JSON.Value.slotPtr(slot, srcBase);
+      const end = JSON.Value.slotEnd(slot, srcBase, srcEnd);
+      const size = end - start;
+      bs.proposeSize(size);
+      memory.copy(bs.offset, start, size);
+      bs.offset += size;
+    } else {
+      const v = JSON.Value.fromBits(slot);
+      serializeArbitrary(v);
+      // Persist any escape-class the serializer cached on a materialized String
+      // slot back into the flat slot, so re-serializing this object reuses it
+      // (the memcpy fast path) instead of re-scanning. No-op for other types.
+      const nb = v.__bits();
+      if (nb != slot) unchecked((vals[i] = nb));
+    }
+    pos += 1 + len;
+    i++;
   }
 
-  serializeString(unchecked(keys[srcEnd]));
-  store<u16>(bs.offset, COLON);
-  bs.offset += 2;
-  serializeArbitrary(unchecked(values[srcEnd]));
-
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/index/string.ts

@@ -3,8 +3,7 @@ import { serializeString_NAIVE } from "../naive/string";
 import { serializeString_SIMD } from "../simd/string";
 import { serializeString_SWAR } from "../swar/string";
 
-
-@inline export function serializeString(src: string): void {
+export function serializeString(src: string): void {
   if (JSON_MODE == JSONMode.SIMD) {
     serializeString_SIMD(src);
   } else if (JSON_MODE == JSONMode.NAIVE) {

package/assembly/serialize/index/typedarray.ts

@@ -9,8 +9,7 @@ import {
   serializeTypedArray,
 } from "../naive/typedarray";
 
-
-@inline export function serializeDynamic(type: u16, data: usize): void {
+export function serializeDynamic(type: u16, data: usize): void {
   if (type == JSON.Types.ArrayBuffer) {
     serializeArrayBufferUnsafe(
       data,

package/assembly/serialize/index.ts

@@ -4,6 +4,7 @@ export * from "./index/bool";
 export * from "./index/date";
 export * from "./index/float";
 export * from "./index/integer";
+export * from "./index/jsonarray";
 export * from "./index/map";
 export * from "./index/object";
 export * from "./index/raw";

package/assembly/serialize/naive/array.ts

@@ -5,13 +5,8 @@ import { serializeBoolUnsafe } from "./bool";
 import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 import { serializeString } from "../index/string";
-import {
-  dragonbox_f32_buffered,
-  dragonbox_f64_buffered,
-} from "../../util/dragonbox";
+import { dtoa_buffered, ftoa_buffered } from "xjb-as";
 
-
-@inline
 function maxIntegerBytes<T extends number>(): u32 {
   if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
   if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
@@ -19,8 +14,6 @@ function maxIntegerBytes<T extends number>(): u32 {
   return isSigned<T>() ? 42 : 40;
 }
 
-
-@inline
 function reservePrimitiveArray<T>(len: i32): void {
   if (len <= 0) return;
   if (isBoolean<T>()) {
@@ -34,8 +27,6 @@ function reservePrimitiveArray<T>(len: i32): void {
   }
 }
 
-
-@inline
 function serializeArrayElement<T>(value: T): void {
   if (isString<T>()) {
     serializeString(value as string);
@@ -78,15 +69,13 @@ function serializeArrayElement<T>(value: T): void {
 // comma-store + advance per element that the generic `serializeArray` does.
 
 // `"true,"` packed UTF-16: `t,r,u,e,,` lanes 0..4 = bytes 0..9.
-@inline const TRUE_COMMA_LO: u64 = 0x0065_0075_0072_0074;
+const TRUE_COMMA_LO: u64 = 0x0065_0075_0072_0074;
 
-
-@inline const TRUE_COMMA_HI: u16 = 0x002c;
+const TRUE_COMMA_HI: u16 = 0x002c;
 // `"false,"` packed UTF-16: `f,a,l,s,e,,` lanes 0..5 = bytes 0..11.
-@inline const FALSE_COMMA_LO: u64 = 0x0073_006c_0061_0066;
-
+const FALSE_COMMA_LO: u64 = 0x0073_006c_0061_0066;
 
-@inline const FALSE_COMMA_HI: u32 = 0x002c_0065;
+const FALSE_COMMA_HI: u32 = 0x002c_0065;
 
 function serializeBoolArrayFast(src: bool[]): void {
   const len = src.length;
@@ -152,8 +141,7 @@ function initU8Lut(): void {
   _u8LutInited = true;
 }
 
-
-@inline function ensureU8Lut(): void {
+function ensureU8Lut(): void {
   if (!_u8LutInited) initU8Lut();
 }
 
@@ -181,20 +169,20 @@ function serializeU8ArrayFast(src: u8[]): void {
   store<u16>(bs.offset - 2, BRACKET_RIGHT);
 }
 
-// Specialized float-array serializer: dragonbox + trailing comma in a
+// Specialized float-array serializer: xjb writer + trailing comma in a
 // uniform per-iteration body, then overwrite the final comma with `]`. The
 // generic dispatcher splits the loop into "N-1 elements with comma, then
-// last element without, then `]`" — the branch on each `i < end` check
+// last element without, then `]`" - the branch on each `i < end` check
 // stalls the loop's tight bs.offset advance pattern. This variant runs the
-// same number of stores per iteration (dragonbox output + COMMA), but the
+// same number of stores per iteration (xjb output + COMMA), but the
 // uniform loop body inlines better and the trailing `]` is a single fixed
 // overwrite outside the loop.
 function serializeF64ArrayFast(src: f64[]): void {
   const len = src.length;
-  // Worst case per element: ~24 chars for f64 + comma = 50 bytes.
-  // Slight over-reserve (66) matches the existing `reservePrimitiveArray`
-  // budget and keeps a safety margin for any NaN/Inf spelling.
-  bs.proposeSize(4 + <u32>len * 66);
+  // Worst case per element: a 21-char fixed integer (e.g. 1e20) or a ~24-char
+  // exponent form, + comma = ~52 bytes; plus the writer's SIMD stores can
+  // overshoot the logical end by up to 16 bytes. 80 covers both comfortably.
+  bs.proposeSize(4 + <u32>len * 80);
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
   if (len == 0) {
@@ -210,9 +198,9 @@ function serializeF64ArrayFast(src: f64[]): void {
   let offset = bs.offset;
   for (let i: i32 = 0; i < len; i++) {
     const v = load<f64>(dataStart + ((<usize>i) << 3));
-    const size = dragonbox_f64_buffered(offset, v) << 1;
-    store<u16>(offset + size, COMMA);
-    offset += size + 2;
+    offset += dtoa_buffered(offset, v) << 1;
+    store<u16>(offset, COMMA);
+    offset += 2;
   }
   // Overwrite the final trailing comma with `]`.
   store<u16>(offset - 2, BRACKET_RIGHT);
@@ -221,9 +209,10 @@ function serializeF64ArrayFast(src: f64[]): void {
 
 function serializeF32ArrayFast(src: f32[]): void {
   const len = src.length;
-  // Worst case for f32 is ~16 chars + comma = ~34 bytes; mirror the budget
-  // used by `reservePrimitiveArray`.
-  bs.proposeSize(4 + <u32>len * 34);
+  // Worst case for f32 is a 21-char fixed integer (e.g. 1e20 rounds to a
+  // 21-digit value), + comma = ~44 bytes, plus up to 16 bytes of SIMD store
+  // overshoot. 64 covers it.
+  bs.proposeSize(4 + <u32>len * 64);
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
   if (len == 0) {
@@ -236,9 +225,9 @@ function serializeF32ArrayFast(src: f32[]): void {
   let offset = bs.offset;
   for (let i: i32 = 0; i < len; i++) {
     const v = load<f32>(dataStart + ((<usize>i) << 2));
-    const size = dragonbox_f32_buffered(offset, v) << 1;
-    store<u16>(offset + size, COMMA);
-    offset += size + 2;
+    offset += ftoa_buffered(offset, v) << 1;
+    store<u16>(offset, COMMA);
+    offset += 2;
   }
   store<u16>(offset - 2, BRACKET_RIGHT);
   bs.offset = offset;

package/assembly/serialize/naive/bool.ts

@@ -4,7 +4,6 @@ import { bs } from "../../../lib/as-bs";
  * @param data data to serialize
  * @returns void
  */
-@inline
 export function serializeBoolUnsafe(data: bool): void {
   if (data === true) {
     store<u64>(bs.offset, 28429475166421108);

package/assembly/serialize/naive/float.ts

@@ -1,43 +1,34 @@
 import { bs } from "../../../lib/as-bs";
-import {
-  dragonbox_f32_buffered,
-  dragonbox_f64_buffered,
-} from "../../util/dragonbox";
+import { dtoa_buffered, ftoa_buffered } from "xjb-as";
 
+// Float serialization is backed by xjb-as (a Schubfach/xjb shortest-decimal
+// writer with SWAR + WASM-SIMD digit kernels). The *_buffered writers emit
+// UTF-16 straight into the `bs` buffer and return the number of characters
+// written, so advancing the offset is `count << 1` bytes.
 
-@inline
 export function serializeFloat32Unsafe(data: f32): void {
-  const size = dragonbox_f32_buffered(bs.offset, data) << 1;
-  bs.offset += size;
+  bs.offset += ftoa_buffered(bs.offset, data) << 1;
 }
 
-
-@inline
 export function serializeFloat64Unsafe(data: f64): void {
-  const size = dragonbox_f64_buffered(bs.offset, data) << 1;
-  bs.offset += size;
+  bs.offset += dtoa_buffered(bs.offset, data) << 1;
 }
 
-
-@inline
 export function serializeFloat32(data: f32): void {
-  bs.ensureSize(64);
-  const size = dragonbox_f32_buffered(bs.offset, data) << 1;
-  bs.stackSize += size;
-  bs.offset += size;
+  bs.ensureSize(128);
+  const bytes = ftoa_buffered(bs.offset, data) << 1;
+  bs.stackSize += bytes;
+  bs.offset += bytes;
 }
 
-
-@inline
 export function serializeFloat64(data: f64): void {
-  bs.ensureSize(64);
-  const size = dragonbox_f64_buffered(bs.offset, data) << 1;
-  bs.stackSize += size;
-  bs.offset += size;
+  bs.ensureSize(128);
+  const bytes = dtoa_buffered(bs.offset, data) << 1;
+  bs.stackSize += bytes;
+  bs.offset += bytes;
 }
 
-// @ts-ignore: inline
-@inline export function serializeFloat<T extends number>(data: T): void {
+export function serializeFloat<T extends number>(data: T): void {
   if (sizeof<T>() == 4) serializeFloat32(<f32>data);
   else serializeFloat64(<f64>data);
 }

package/assembly/serialize/naive/integer.ts

@@ -1,16 +1,12 @@
 import { bs } from "../../../lib/as-bs";
 import { ensureItoaPairs, itoaFast } from "../../util/itoa-fast";
 
-
-@inline
 export function serializeIntegerUnsafe<T extends number>(data: T): void {
   ensureItoaPairs();
   const charsWritten = itoaFast<T>(bs.offset, data);
   bs.offset += (<usize>charsWritten) << 1;
 }
-
-// @ts-ignore: inline
-@inline export function serializeInteger<T extends number>(data: T): void {
+export function serializeInteger<T extends number>(data: T): void {
   ensureItoaPairs();
   bs.ensureSize(sizeof<T>() << 3);
   const charsWritten = itoaFast<T>(bs.offset, data);

package/assembly/serialize/naive/raw.ts

@@ -7,8 +7,7 @@ import { bytes } from "../../util";
  * @param data data to serialize
  * @returns void
  */
-// @ts-ignore: inline
-@inline export function serializeRaw(data: JSON.Raw): void {
+export function serializeRaw(data: JSON.Raw): void {
   const dataSize = bytes(data.data);
   bs.proposeSize(dataSize);
   memory.copy(

package/assembly/serialize/naive/set.ts

@@ -6,8 +6,6 @@ import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 import { serializeString } from "../index/string";
 
-
-@inline
 function maxIntegerBytes<T extends number>(): u32 {
   if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
   if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
@@ -15,8 +13,6 @@ function maxIntegerBytes<T extends number>(): u32 {
   return isSigned<T>() ? 42 : 40;
 }
 
-
-@inline
 function reservePrimitiveSet<T>(len: i32): void {
   if (len <= 0) return;
   if (isBoolean<T>()) {

package/assembly/serialize/naive/staticarray.ts

@@ -6,17 +6,12 @@ import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 import { serializeString } from "../index/string";
 
-
-@inline
 function maxIntegerBytes<T extends number>(): u32 {
   if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
   if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
   if (sizeof<T>() == 4) return isSigned<T>() ? 22 : 20;
   return isSigned<T>() ? 42 : 40;
 }
-
-
-@inline
 function reservePrimitiveStaticArray<T>(len: i32): void {
   if (len <= 0) return;
   if (isBoolean<T>()) {

package/assembly/serialize/naive/string.ts

@@ -15,11 +15,17 @@ import { serializeStruct } from "./struct";
  * @param src string
  * @returns void
  */
-// @ts-ignore: inline
-@inline export function serializeString_NAIVE(src: string): void {
-  const srcSize = bytes(src);
+export function serializeString_NAIVE(src: string): void {
+  serializeStringRange(changetype<usize>(src), bytes(src));
+}
+
+/**
+ * Serializes a raw UTF-16 range as a quoted, escaped JSON string. Lets callers
+ * (e.g. JSON.Obj key serialization) emit a string straight from a buffer slice
+ * without first materializing a heap `string`.
+ */
+export function serializeStringRange(srcPtr: usize, srcSize: usize): void {
   bs.proposeSize(srcSize + 4);
-  let srcPtr = changetype<usize>(src);
   const srcEnd = srcPtr + srcSize;
 
   store<u16>(bs.offset, QUOTE);
@@ -79,9 +85,7 @@ import { serializeStruct } from "./struct";
   store<u16>(bs.offset, QUOTE);
   bs.offset += 2;
 }
-
-// @ts-ignore: inline
-@inline function write_u_escape(code: u16): void {
+function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
   store<u64>(bs.offset, u16_to_hex4_swar(code), 4);

package/assembly/serialize/naive/typedarray.ts

@@ -3,8 +3,6 @@ import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
 import { serializeFloat32Unsafe, serializeFloat64Unsafe } from "./float";
 import { serializeIntegerUnsafe } from "./integer";
 
-
-@inline
 function maxIntegerBytes<T extends number>(): u32 {
   if (sizeof<T>() == 1) return isSigned<T>() ? 8 : 6;
   if (sizeof<T>() == 2) return isSigned<T>() ? 12 : 10;
@@ -12,8 +10,6 @@ function maxIntegerBytes<T extends number>(): u32 {
   return isSigned<T>() ? 42 : 40;
 }
 
-
-@inline
 function reserveTypedArray<T extends ArrayLike<number>>(len: i32): void {
   if (len <= 0) return;
   if (isFloat<valueof<T>>()) {
@@ -23,8 +19,6 @@ function reserveTypedArray<T extends ArrayLike<number>>(len: i32): void {
   }
 }
 
-
-@inline
 function serializeTypedArrayElement<T extends ArrayLike<number>>(
   src: T,
   index: i32,

package/assembly/serialize/simd/string.ts

@@ -207,9 +207,7 @@ export function serializeString_SIMD(src: string): void {
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
 }
-
-// @ts-expect-error: @inline is a valid decorator
-@inline function write_u_escape(code: u16): void {
+function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
   store<u64>(bs.offset, u16_to_hex4_swar(code), 4);

package/assembly/serialize/swar/string.ts

@@ -174,16 +174,14 @@ export function serializeString_SWAR(src: string): void {
   bs.offset += 2;
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function write_u_escape(code: u16): void {
+function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
   store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
   bs.offset += 12;
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline export function detect_escapable_u64_swar_safe(block: u64): u64 {
+export function detect_escapable_u64_swar_safe(block: u64): u64 {
   const hi = block & 0xff00_ff00_ff00_ff00;
   const lo = block & 0x00ff_00ff_00ff_00ff;
   // Setting bit 8 of each 16-bit lane (high byte LSB) prevents borrow from a