json-as 1.2.6 → 1.3.1

package/assembly/serialize/index/arbitrary.ts

@@ -0,0 +1,75 @@
+import { JSON } from "../..";
+import { bs } from "../../../lib/as-bs";
+import { serializeArray } from "./array";
+import { serializeBool } from "./bool";
+import { serializeFloat } from "./float";
+import { serializeInteger } from "./integer";
+import { serializeMap } from "./map";
+import { serializeObject } from "./object";
+import { serializeString } from "./string";
+import { serializeDynamic } from "./typedarray";
+
+export function serializeArbitrary(src: JSON.Value): void {
+  switch (src.type) {
+    case JSON.Types.Null:
+      bs.proposeSize(8);
+      store<u64>(bs.offset, 30399761348886638);
+      bs.offset += 8;
+      break;
+    case JSON.Types.U8:
+      serializeInteger<u8>(src.get<u8>());
+      break;
+    case JSON.Types.U16:
+      serializeInteger<u16>(src.get<u16>());
+      break;
+    case JSON.Types.U32:
+      serializeInteger<u32>(src.get<u32>());
+      break;
+    case JSON.Types.U64:
+      serializeInteger<u64>(src.get<u64>());
+      break;
+    case JSON.Types.I8:
+      serializeInteger<i8>(src.get<i8>());
+      break;
+    case JSON.Types.I16:
+      serializeInteger<i16>(src.get<i16>());
+      break;
+    case JSON.Types.I32:
+      serializeInteger<i32>(src.get<i32>());
+      break;
+    case JSON.Types.I64:
+      serializeInteger<i64>(src.get<i64>());
+      break;
+    case JSON.Types.F32:
+      serializeFloat<f32>(src.get<f32>());
+      break;
+    case JSON.Types.F64:
+      serializeFloat<f64>(src.get<f64>());
+      break;
+    case JSON.Types.String:
+      serializeString(src.get<string>());
+      break;
+    case JSON.Types.Bool:
+      serializeBool(src.get<bool>());
+      break;
+    case JSON.Types.Array:
+      serializeArray(src.get<JSON.Value[]>());
+      break;
+    case JSON.Types.Object:
+      serializeObject(src.get<JSON.Obj>());
+      break;
+    case JSON.Types.Map:
+      serializeMap(src.get<Map<string, JSON.Value>>());
+      break;
+    case JSON.Types.TypedArray:
+    case JSON.Types.ArrayBuffer:
+      serializeDynamic(src.type, src.get<usize>());
+      break;
+    default: {
+      const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
+      const ptr = src.get<usize>();
+      call_indirect<void>(fn, 0, ptr);
+      break;
+    }
+  }
+}

package/assembly/serialize/index/array.ts

@@ -0,0 +1 @@
+export { serializeArray } from "../simple/array";

package/assembly/serialize/index/bool.ts

@@ -0,0 +1 @@
+export { serializeBool } from "../simple/bool";

package/assembly/serialize/index/date.ts

@@ -0,0 +1 @@
+export { serializeDate } from "../simple/date";

package/assembly/serialize/index/float.ts

@@ -0,0 +1 @@
+export { serializeFloat } from "../simple/float";

package/assembly/serialize/index/integer.ts

@@ -0,0 +1 @@
+export { serializeInteger } from "../simple/integer";

package/assembly/serialize/index/map.ts

@@ -0,0 +1 @@
+export { serializeMap } from "../simple/map";

package/assembly/serialize/index/object.ts

@@ -0,0 +1,46 @@
+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";
+
+export function serializeObject(src: JSON.Obj): void {
+  const srcSize = src.size;
+  const srcEnd = srcSize - 1;
+
+  if (srcSize == 0) {
+    bs.proposeSize(4);
+    store<u32>(bs.offset, 8192123);
+    bs.offset += 4;
+    return;
+  }
+
+  const keys = src.keys();
+  const values = src.values();
+
+  bs.growSize(2);
+  store<u16>(bs.offset, BRACE_LEFT);
+  bs.offset += 2;
+
+  for (let i = 0; i < srcEnd; i++) {
+    serializeString(unchecked(keys[i]));
+    bs.growSize(2);
+    store<u16>(bs.offset, COLON);
+    bs.offset += 2;
+
+    serializeArbitrary(unchecked(values[i]));
+    bs.growSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  serializeString(unchecked(keys[srcEnd]));
+  bs.growSize(2);
+  store<u16>(bs.offset, COLON);
+  bs.offset += 2;
+  serializeArbitrary(unchecked(values[srcEnd]));
+
+  bs.growSize(2);
+  store<u16>(bs.offset, BRACE_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/index/raw.ts

@@ -0,0 +1 @@
+export { serializeRaw } from "../simple/raw";

package/assembly/serialize/index/set.ts

@@ -0,0 +1 @@
+export { serializeSet } from "../simple/set";

package/assembly/serialize/index/staticarray.ts

@@ -0,0 +1 @@
+export { serializeStaticArray } from "../simple/staticarray";

package/assembly/serialize/index/string.ts

@@ -0,0 +1,15 @@
+import { JSONMode } from "../..";
+import { serializeString as serializeString_NAIVE } from "../simple/string";
+import { serializeString_SIMD } from "../simd/string";
+import { serializeString_SWAR } from "../swar/string";
+
+
+@inline export function serializeString(src: string): void {
+  if (JSON_MODE == JSONMode.SIMD) {
+    serializeString_SIMD(src);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    serializeString_NAIVE(src);
+  } else {
+    serializeString_SWAR(src);
+  }
+}

package/assembly/serialize/index/struct.ts

@@ -0,0 +1 @@
+export { serializeStruct } from "../simple/struct";

package/assembly/serialize/index/typedarray.ts

@@ -0,0 +1,66 @@
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { JSON } from "../..";
+export { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typedarray";
+import { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typedarray";
+
+
+@inline export function serializeDynamic(type: u16, data: usize): void {
+  if (type == JSON.Types.ArrayBuffer) {
+    serializeArrayBufferUnsafe(data, changetype<OBJECT>(data - TOTAL_OVERHEAD).rtSize);
+  } else if (type == JSON.Types.TypedArray) {
+    const id = changetype<OBJECT>(data - TOTAL_OVERHEAD).rtId;
+    if (id == idof<Int8Array>()) {
+      serializeTypedArray<Int8Array>(changetype<Int8Array>(data));
+    } else if (id == idof<Uint8Array>()) {
+      serializeTypedArray<Uint8Array>(changetype<Uint8Array>(data));
+    } else if (id == idof<Uint8ClampedArray>()) {
+      serializeTypedArray<Uint8ClampedArray>(changetype<Uint8ClampedArray>(data));
+    } else if (id == idof<Int16Array>()) {
+      serializeTypedArray<Int16Array>(changetype<Int16Array>(data));
+    } else if (id == idof<Uint16Array>()) {
+      serializeTypedArray<Uint16Array>(changetype<Uint16Array>(data));
+    } else if (id == idof<Int32Array>()) {
+      serializeTypedArray<Int32Array>(changetype<Int32Array>(data));
+    } else if (id == idof<Uint32Array>()) {
+      serializeTypedArray<Uint32Array>(changetype<Uint32Array>(data));
+    } else if (id == idof<Int64Array>()) {
+      serializeTypedArray<Int64Array>(changetype<Int64Array>(data));
+    } else if (id == idof<Uint64Array>()) {
+      serializeTypedArray<Uint64Array>(changetype<Uint64Array>(data));
+    } else if (id == idof<Float32Array>()) {
+      serializeTypedArray<Float32Array>(changetype<Float32Array>(data));
+    } else if (id == idof<Float64Array>()) {
+      serializeTypedArray<Float64Array>(changetype<Float64Array>(data));
+    } else if (changetype<Int8Array>(data) instanceof Int8Array) {
+      serializeTypedArray<Int8Array>(changetype<Int8Array>(data));
+    } else if (changetype<Uint8Array>(data) instanceof Uint8Array) {
+      serializeTypedArray<Uint8Array>(changetype<Uint8Array>(data));
+    } else if (changetype<Uint8ClampedArray>(data) instanceof Uint8ClampedArray) {
+      serializeTypedArray<Uint8ClampedArray>(changetype<Uint8ClampedArray>(data));
+    } else if (changetype<Int16Array>(data) instanceof Int16Array) {
+      serializeTypedArray<Int16Array>(changetype<Int16Array>(data));
+    } else if (changetype<Uint16Array>(data) instanceof Uint16Array) {
+      serializeTypedArray<Uint16Array>(changetype<Uint16Array>(data));
+    } else if (changetype<Int32Array>(data) instanceof Int32Array) {
+      serializeTypedArray<Int32Array>(changetype<Int32Array>(data));
+    } else if (changetype<Uint32Array>(data) instanceof Uint32Array) {
+      serializeTypedArray<Uint32Array>(changetype<Uint32Array>(data));
+    } else if (changetype<Int64Array>(data) instanceof Int64Array) {
+      serializeTypedArray<Int64Array>(changetype<Int64Array>(data));
+    } else if (changetype<Uint64Array>(data) instanceof Uint64Array) {
+      serializeTypedArray<Uint64Array>(changetype<Uint64Array>(data));
+    } else if (changetype<Float32Array>(data) instanceof Float32Array) {
+      serializeTypedArray<Float32Array>(changetype<Float32Array>(data));
+    } else if (changetype<Float64Array>(data) instanceof Float64Array) {
+      serializeTypedArray<Float64Array>(changetype<Float64Array>(data));
+    } else {
+      throw new Error("Unsupported typed array in JSON.Value");
+    }
+  }
+}
+
+
+@inline export function serializeArrayBuffer(data: ArrayBuffer): void {
+  const dataStart = changetype<usize>(data);
+  serializeArrayBufferUnsafe(dataStart, changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize);
+}

package/assembly/serialize/index.ts

@@ -0,0 +1,13 @@
+export * from "./index/arbitrary";
+export * from "./index/array";
+export * from "./index/bool";
+export * from "./index/date";
+export * from "./index/float";
+export * from "./index/integer";
+export * from "./index/map";
+export * from "./index/object";
+export * from "./index/raw";
+export * from "./index/set";
+export * from "./index/staticarray";
+export * from "./index/string";
+export * from "./index/struct";

package/assembly/serialize/simd/string.ts

@@ -2,6 +2,7 @@ import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { bs, sc } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { u16_to_hex4_swar } from "../../util/swar";
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const U00_MARKER = 13511005048209500;
 // @ts-expect-error: @lazy is a valid decorator
@@ -118,7 +119,7 @@ export function serializeString_SIMD(src: string): void {
       // unpaired high/low surrogate
       const dstIdx = bs.offset + laneIdx - 1;
       store<u32>(dstIdx, U_MARKER); // \u
-      store<u64>(dstIdx, load<u64>(changetype<usize>(code.toString(16))), 4);
+      store<u64>(dstIdx, u16_to_hex4_swar(code), 4);
       // memory.copy(dstIdx + 12, srcIdx + 1, 15 - laneIdx);
       store<v128>(dstIdx, load<v128>(srcIdx, 1), 12);
       bs.offset += 10;
@@ -174,23 +175,13 @@ export function serializeString_SIMD(src: string): void {
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
 
-  if (isDefined(JSON_CACHE))
-    sc.insertCached(changetype<usize>(src), srcStart, srcSize);
+  if (isDefined(JSON_CACHE)) sc.insertCached(changetype<usize>(src), srcStart, srcSize);
 }
 
 // @ts-expect-error: @inline is a valid decorator
 @inline function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
-  // write hex digits (lowercase, matches tests)
-  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xf));
-  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xf));
-  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xf));
-  store<u16>(bs.offset + 10, hexNibble(code & 0xf));
+  store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
   bs.offset += 12;
 }
-
-// @ts-expect-error: @inline is a valid decorator
-@inline function hexNibble(n: u16): u16 {
-  return n < 10 ? 48 + n : 87 + n;
-}

package/assembly/serialize/simple/arbitrary.ts

@@ -7,6 +7,7 @@ import { serializeInteger } from "./integer";
 import { serializeMap } from "./map";
 import { serializeObject } from "./object";
 import { serializeString } from "./string";
+import { serializeDynamic } from "../index/typedarray";
 
 export function serializeArbitrary(src: JSON.Value): void {
   switch (src.type) {
@@ -63,6 +64,11 @@ export function serializeArbitrary(src: JSON.Value): void {
       serializeMap(src.get<Map<string, JSON.Value>>());
       break;
     }
+    case JSON.Types.TypedArray:
+    case JSON.Types.ArrayBuffer: {
+      serializeDynamic(src.type, src.get<usize>());
+      break;
+    }
     default: {
       const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
       const ptr = src.get<usize>();

package/assembly/serialize/simple/raw.ts

@@ -11,10 +11,6 @@ import { bytes } from "../../util";
 @inline export function serializeRaw(data: JSON.Raw): void {
   const dataSize = bytes(data.data);
   bs.proposeSize(dataSize);
-  memory.copy(
-    changetype<usize>(bs.offset),
-    changetype<usize>(data.data),
-    dataSize,
-  );
+  memory.copy(changetype<usize>(bs.offset), changetype<usize>(data.data), dataSize);
   bs.offset += dataSize;
 }

package/assembly/serialize/simple/string.ts

@@ -3,6 +3,7 @@ import { _intTo16 } from "../../custom/util";
 import { bytes } from "../../util/bytes";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { u16_to_hex4_swar } from "../../util/swar";
 import { serializeStruct } from "./struct";
 
 // @ts-ignore: decorator allowed
@@ -68,7 +69,7 @@ import { serializeStruct } from "./struct";
     // unpaired high/low surrogate
     bs.growSize(10);
     store<u32>(bs.offset, U_MARKER); // \u
-    store<u64>(bs.offset, load<u64>(changetype<usize>(code.toString(16))), 4);
+    store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
     bs.offset += 12;
     lastPtr = srcPtr;
     continue;
@@ -84,15 +85,6 @@ import { serializeStruct } from "./struct";
 @inline function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
-  // write hex digits (lowercase, matches tests)
-  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xf));
-  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xf));
-  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xf));
-  store<u16>(bs.offset + 10, hexNibble(code & 0xf));
+  store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
   bs.offset += 12;
 }
-
-// @ts-ignore: inline
-@inline function hexNibble(n: u16): u16 {
-  return n < 10 ? 48 + n : 87 + n;
-}

package/assembly/serialize/simple/typedarray.ts

@@ -0,0 +1,63 @@
+import { bs } from "../../../lib/as-bs";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
+import { serializeFloat } from "./float";
+import { serializeInteger } from "./integer";
+
+
+@inline
+function serializeTypedArrayElement<T extends ArrayLike<number>>(src: T, index: i32): void {
+  if (isFloat<valueof<T>>()) {
+    serializeFloat<valueof<T>>(unchecked(src[index]));
+  } else {
+    serializeInteger<valueof<T>>(unchecked(src[index]));
+  }
+}
+
+export function serializeTypedArray<T extends ArrayLike<number>>(src: T): void {
+  bs.proposeSize(4);
+  const end = src.length - 1;
+  if (end == -1) {
+    store<u32>(bs.offset, 6094939);
+    bs.offset += 4;
+    return;
+  }
+
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+
+  for (let i = 0; i < end; i++) {
+    serializeTypedArrayElement(src, i);
+    bs.growSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  serializeTypedArrayElement(src, end);
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}
+
+export function serializeArrayBufferUnsafe(srcStart: usize, byteLength: i32): void {
+  const end = byteLength - 1;
+
+  bs.proposeSize(4);
+  if (end == -1) {
+    store<u32>(bs.offset, 6094939);
+    bs.offset += 4;
+    return;
+  }
+
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+
+  for (let i = 0; i < end; i++) {
+    serializeInteger<u8>(load<u8>(srcStart + <usize>i));
+    bs.growSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  serializeInteger<u8>(load<u8>(srcStart + <usize>end));
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/swar/string.ts

@@ -1,6 +1,7 @@
 import { bs, sc } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { u16_to_hex4_swar } from "../../util/swar";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
 // @ts-expect-error: @lazy is a valid decorator
@@ -89,7 +90,7 @@ export function serializeString_SWAR(src: string): void {
       // unpaired high/low surrogate
       const dstIdx = bs.offset + laneIdx - 1;
       store<u32>(dstIdx, U_MARKER); // \u
-      store<u64>(dstIdx, load<u64>(changetype<usize>(code.toString(16))), 4);
+      store<u64>(dstIdx, u16_to_hex4_swar(code), 4);
       store<u64>(dstIdx, load<u64>(srcIdx, 1), 12);
       bs.offset += 10;
     } while (mask !== 0);
@@ -145,38 +146,22 @@ export function serializeString_SWAR(src: string): void {
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
 
-  if (isDefined(JSON_CACHE))
-    sc.insertCached(changetype<usize>(src), srcStart, srcSize);
+  if (isDefined(JSON_CACHE)) sc.insertCached(changetype<usize>(src), srcStart, srcSize);
 }
 
 // @ts-expect-error: @inline is a valid decorator
 @inline function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
-  // write hex digits (lowercase, matches tests)
-  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xf));
-  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xf));
-  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xf));
-  store<u16>(bs.offset + 10, hexNibble(code & 0xf));
+  store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
   bs.offset += 12;
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function hexNibble(n: u16): u16 {
-  return n < 10 ? 48 + n : 87 + n;
-}
-
 // @ts-expect-error: @inline is a valid decorator
 @inline export function detect_escapable_u64_swar_safe(block: u64): u64 {
   const lo = block & 0x00ff_00ff_00ff_00ff;
-  const ascii_mask =
-    ((lo - 0x0020_0020_0020_0020) |
-      ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) |
-      ((lo ^ 0x005c_005c_005c_005c) - 0x0001_0001_0001_0001)) &
-    (0x0080_0080_0080_0080 & ~lo);
-  const hi_mask =
-    ((block - 0x0100_0100_0100_0100) & ~block & 0x8000_8000_8000_8000) ^
-    0x8000_8000_8000_8000;
+  const ascii_mask = ((lo - 0x0020_0020_0020_0020) | ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) | ((lo ^ 0x005c_005c_005c_005c) - 0x0001_0001_0001_0001)) & (0x0080_0080_0080_0080 & ~lo);
+  const hi_mask = ((block - 0x0100_0100_0100_0100) & ~block & 0x8000_8000_8000_8000) ^ 0x8000_8000_8000_8000;
   return (ascii_mask & (~hi_mask >> 8)) | hi_mask;
 }
 

package/assembly/util/concat.ts

@@ -4,10 +4,6 @@ export function concat(left: string, right: string): string {
   const rightSize: usize = bytes(right);
   const jointSize: usize = leftSize + rightSize;
   const jointPtr = __renew(changetype<usize>(left), jointSize);
-  memory.copy(
-    changetype<usize>(left) + leftSize,
-    changetype<usize>(right),
-    rightSize,
-  );
+  memory.copy(changetype<usize>(left) + leftSize, changetype<usize>(right), rightSize);
   return changetype<string>(jointPtr);
 }

package/assembly/util/index.ts

@@ -3,3 +3,4 @@ export * from "./atoi";
 export * from "./concat";
 export * from "./bytes";
 export * from "./nextPowerOf2";
+export * from "./stringScan";

package/assembly/util/masks.ts

@@ -11,27 +11,21 @@ export function mask_to_string(mask: u64): string {
   return result;
 }
 
+export function block_to_string(block: u64): string {
+  let result = "     ";
+  const buf = changetype<usize>(new ArrayBuffer(8));
+  store<u64>(buf, block);
+  result += String.fromCharCode(load<u16>(buf, 6)) + "     ";
+  result += String.fromCharCode(load<u16>(buf, 4)) + "     ";
+  result += String.fromCharCode(load<u16>(buf, 2)) + "     ";
+  result += String.fromCharCode(load<u16>(buf, 0)) + "     ";
+  return result;
+}
+
 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/snp.ts

@@ -7,10 +7,7 @@ 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;

package/assembly/util/stringScan.ts

@@ -0,0 +1,24 @@
+import { BACK_SLASH, QUOTE } from "../custom/chars";
+
+// @ts-ignore
+@inline export function isUnescapedQuote(ptr: usize): bool {
+  if (load<u16>(ptr) != QUOTE) return false;
+
+  let escaped = false;
+  while (ptr >= 2 && load<u16>(ptr - 2) == BACK_SLASH) {
+    escaped = !escaped;
+    ptr -= 2;
+  }
+
+  return !escaped;
+}
+
+// @ts-ignore
+@inline export function scanStringEnd(ptr: usize, end: usize): usize {
+  ptr += 2;
+  while (ptr < end) {
+    if (load<u16>(ptr) == QUOTE && isUnescapedQuote(ptr)) return ptr;
+    ptr += 2;
+  }
+  return end;
+}

package/assembly/util/swar.ts

@@ -1,12 +1,56 @@
+/**
+ * Decode four lowercase ASCII hex digits packed into UTF-16 lanes into one `u16`.
+ *
+ * The input is a `u64` whose four 16-bit lanes each contain one ASCII hex code
+ * unit in the low byte:
+ *
+ * - lane 0: most-significant hex digit
+ * - lane 1: next hex digit
+ * - lane 2: next hex digit
+ * - lane 3: least-significant hex digit
+ *
+ * For example, `0x0034_0033_0032_0031` represents the UTF-16 string `"1234"`
+ * and decodes to `0x1234`.
+ *
+ * This helper assumes the digits are already valid lowercase hexadecimal
+ * characters in the ranges `0-9` or `a-f`.
+ *
+ * @param block Packed UTF-16 ASCII hex digits.
+ * @returns The decoded 16-bit value.
+ */
 // @ts-expect-error: @inline is a valid decorator
 @inline export function hex4_to_u16_swar(block: u64): u16 {
   // (c & 0xF) + 9 * (c >> 6)
   block = (block & 0x0f000f000f000f) + ((block >> 6) & 0x03000300030003) * 9;
 
-  return <u16>(
-    (((block >> 0) << 12) |
-      ((block >> 16) << 8) |
-      ((block >> 32) << 4) |
-      (block >> 48))
-  );
+  return <u16>(((block >> 0) << 12) | ((block >> 16) << 8) | ((block >> 32) << 4) | (block >> 48));
+}
+
+/**
+ * Encode one `u16` into four lowercase ASCII hex digits packed into UTF-16 lanes.
+ *
+ * The returned `u64` is laid out so it can be written directly as four UTF-16
+ * code units:
+ *
+ * - lane 0: most-significant hex digit
+ * - lane 1: next hex digit
+ * - lane 2: next hex digit
+ * - lane 3: least-significant hex digit
+ *
+ * Each lane stores the ASCII character in the low byte and zero in the high
+ * byte. For example, `0x1234` becomes `0x0034_0033_0032_0031`, which
+ * represents the UTF-16 string `"1234"`.
+ *
+ * This helper is the inverse of {@link hex4_to_u16_swar}.
+ *
+ * @param code The 16-bit value to encode.
+ * @returns Four packed UTF-16 ASCII hex digits.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function u16_to_hex4_swar(code: u16): u64 {
+  let block = (<u64>((code >> 12) & 0xf)) | ((<u64>((code >> 8) & 0xf)) << 16) | ((<u64>((code >> 4) & 0xf)) << 32) | ((<u64>(code & 0xf)) << 48);
+
+  const alphaMask = ((block + 0x0006_0006_0006_0006) >> 4) & 0x0001_0001_0001_0001;
+  block += 0x0030_0030_0030_0030 + alphaMask * 39;
+  return block;
 }