json-as 1.3.0 → 1.3.2

package/assembly/serialize/index/object.ts

@@ -18,29 +18,25 @@ export function serializeObject(src: JSON.Obj): void {
   const keys = src.keys();
   const values = src.values();
 
-  bs.growSize(2);
+  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]));
-    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/typedarray.ts

@@ -1 +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/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
@@ -54,16 +55,15 @@ export function serializeString_SIMD(src: string): void {
     // console.log("lt20   : " + mask_to_string_v128(lt20) + " -> " + mask_to_string_v128(SPLAT_0020));
     // console.log("gteD8  : " + mask_to_string_v128(gteD8) + " -> " + mask_to_string_v128(SPLAT_FFD8));
 
-    const sieve = v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8)));
-    // console.log("sieve  : " + mask_to_string_v128(sieve));
+    let mask = i8x16.bitmask(v128.or(eq22, v128.or(eq5C, v128.or(lt20, gteD8))));
 
-    if (!v128.any_true(sieve)) {
+    if (mask == 0) {
       bs.offset += 16;
       srcStart += 16;
       continue;
     }
 
-    let mask = i8x16.bitmask(sieve);
+    bs.growSize(popcnt(mask) * 10 + 12);
 
     do {
       const laneIdx = ctz(mask);
@@ -109,7 +109,7 @@ export function serializeString_SIMD(src: string): void {
         const next = load<u16>(srcIdx, 1);
         if (next >= 0xdc00 && next <= 0xdfff) {
           // paired surrogate
-          mask &= mask - 1;
+          mask &= ~(0b11 << (laneIdx + 1));
           continue;
         }
       }
@@ -118,7 +118,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;
@@ -181,15 +181,6 @@ export function serializeString_SIMD(src: string): void {
 @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

@@ -2,11 +2,12 @@ import { JSON } from "../..";
 import { bs } from "../../../lib/as-bs";
 import { serializeArray } from "./array";
 import { serializeBool } from "./bool";
-import { serializeFloat } from "./float";
+import { serializeFloat32, serializeFloat64 } from "./float";
 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) {
@@ -40,10 +41,10 @@ export function serializeArbitrary(src: JSON.Value): void {
       serializeInteger<i64>(src.get<i64>());
       break;
     case JSON.Types.F32:
-      serializeFloat<f32>(src.get<f32>());
+      serializeFloat32(src.get<f32>());
       break;
     case JSON.Types.F64:
-      serializeFloat<f64>(src.get<f64>());
+      serializeFloat64(src.get<f64>());
       break;
     case JSON.Types.String:
       serializeString(src.get<string>());
@@ -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/array.ts

@@ -1,16 +1,29 @@
 import { bs } from "../../../lib/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
+import { serializeFloat32, serializeFloat64 } from "./float";
+
+@inline
+function serializeArrayElement<T>(value: T): void {
+  if (isFloat<T>()) {
+    if (sizeof<T>() == 4) serializeFloat32(<f32>value);
+    else serializeFloat64(<f64>value);
+    return;
+  }
+  JSON.__serialize<T>(value);
+}
 
 export function serializeArray<T extends any[]>(src: T): void {
-  bs.proposeSize(4);
-  const end = src.length - 1;
+  const len = src.length;
+  const end = len - 1;
   let i = 0;
   if (end == -1) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939);
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(len - 1) * 2);
   // {} = 4
   // xi, = n << 1
 
@@ -19,15 +32,13 @@ export function serializeArray<T extends any[]>(src: T): void {
 
   while (i < end) {
     const block = unchecked(src[i++]);
-    JSON.__serialize<valueof<T>>(block);
-    bs.growSize(2);
+    serializeArrayElement<valueof<T>>(block);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
   const lastBlock = unchecked(src[end]);
-  JSON.__serialize<valueof<T>>(lastBlock);
-  // bs.growSize(2);
+  serializeArrayElement<valueof<T>>(lastBlock);
   store<u16>(bs.offset, BRACKET_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/float.ts

@@ -1,10 +1,24 @@
 import { bs } from "../../../lib/as-bs";
-import { dtoa_buffered } from "util/number";
+import { dragonbox_f32_buffered, dragonbox_f64_buffered } from "../../util/dragonbox";
 
-// @ts-ignore: inline
-@inline export function serializeFloat<T extends number>(data: T): void {
+@inline
+export function serializeFloat32(data: f32): void {
   bs.ensureSize(64);
-  const size = dtoa_buffered(bs.offset, data) << 1;
+  const size = dragonbox_f32_buffered(bs.offset, data) << 1;
   bs.stackSize += size;
   bs.offset += size;
 }
+
+@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;
+}
+
+// @ts-ignore: inline
+@inline export function serializeFloat<T extends number>(data: T): void {
+  if (sizeof<T>() == 4) serializeFloat32(<f32>data);
+  else serializeFloat64(<f64>data);
+}

package/assembly/serialize/simple/map.ts

@@ -15,52 +15,35 @@ export function serializeMap<T extends Map<any, any>>(src: T): void {
 
   let keys = src.keys();
   let values = src.values();
+  const keyIsString = isString<indexof<T>>();
 
-  bs.proposeSize(4);
+  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++) {
-    // @ts-ignore: Valid
-    if (!isString<indexof<T>>()) {
-      bs.growSize(6);
-      store<u16>(bs.offset, 34);
-      bs.offset += 2;
+    if (keyIsString) {
       JSON.__serialize(unchecked(keys[i]));
-      store<u16>(bs.offset, 34);
-      store<u16>(bs.offset, COLON, 2);
-      bs.offset += 4;
     } else {
-      JSON.__serialize(unchecked(keys[i]));
-      bs.growSize(2);
-      store<u16>(bs.offset, COLON);
-      bs.offset += 2;
+      JSON.__serialize<string>(JSON.internal.stringify<indexof<T>>(unchecked(keys[i])));
     }
+    store<u16>(bs.offset, COLON);
+    bs.offset += 2;
     JSON.__serialize(unchecked(values[i]));
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }
 
-  // @ts-ignore: Valid
-  if (!isString<indexof<T>>()) {
-    bs.growSize(6);
-    store<u16>(bs.offset, 34);
-    bs.offset += 2;
+  if (keyIsString) {
     JSON.__serialize(unchecked(keys[srcEnd]));
-    store<u16>(bs.offset, 34);
-    store<u16>(bs.offset, COLON, 2);
-    bs.offset += 4;
   } else {
-    JSON.__serialize(unchecked(keys[srcEnd]));
-    bs.growSize(2);
-    store<u16>(bs.offset, COLON);
-    bs.offset += 2;
+    JSON.__serialize<string>(JSON.internal.stringify<indexof<T>>(unchecked(keys[srcEnd])));
   }
+  store<u16>(bs.offset, COLON);
+  bs.offset += 2;
 
   JSON.__serialize(unchecked(values[srcEnd]));
-  // bs.growSize(2);
   store<u16>(bs.offset, BRACE_RIGHT);
   bs.offset += 2;
 }

package/assembly/serialize/simple/object.ts

@@ -18,29 +18,25 @@ export function serializeObject(src: JSON.Obj): void {
   const keys = src.keys();
   const values = src.values();
 
-  bs.growSize(2);
+  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_SWAR(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_SWAR(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/simple/set.ts

@@ -3,25 +3,24 @@ import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
 
 export function serializeSet<T extends Set<any>>(src: T): void {
-  bs.proposeSize(4);
   const srcSize = src.size;
   if (srcSize == 0) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939); // []
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(srcSize - 1) * 2);
 
   const values = src.values();
-  const end = srcSize - 1;
-
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
 
+  const end = srcSize - 1;
   for (let i = 0; i < end; i++) {
     const block = unchecked(values[i]);
     // @ts-ignore: type
     JSON.__serialize<indexof<T>>(block);
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }

package/assembly/serialize/simple/staticarray.ts

@@ -3,14 +3,16 @@ import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
 
 export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
-  bs.proposeSize(4);
-  const end = src.length - 1;
+  const len = src.length;
+  const end = len - 1;
   let i = 0;
   if (end == -1) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939); // []
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(len - 1) * 2);
 
   store<u16>(bs.offset, BRACKET_LEFT);
   bs.offset += 2;
@@ -18,7 +20,6 @@ export function serializeStaticArray<T extends StaticArray<any>>(src: T): void {
   while (i < end) {
     const block = unchecked(src[i++]);
     JSON.__serialize<valueof<T>>(block);
-    bs.growSize(2);
     store<u16>(bs.offset, COMMA);
     bs.offset += 2;
   }

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

@@ -1,33 +1,35 @@
 import { bs } from "../../../lib/as-bs";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
-import { serializeFloat } from "./float";
+import { serializeFloat32, serializeFloat64 } 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]));
+    if (sizeof<valueof<T>>() == 4) serializeFloat32(<f32>unchecked(src[index]));
+    else serializeFloat64(<f64>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;
+  const len = src.length;
+  const end = len - 1;
   if (end == -1) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939);
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(len - 1) * 2);
 
   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;
   }
@@ -40,19 +42,19 @@ export function serializeTypedArray<T extends ArrayLike<number>>(src: T): void {
 export function serializeArrayBufferUnsafe(srcStart: usize, byteLength: i32): void {
   const end = byteLength - 1;
 
-  bs.proposeSize(4);
   if (end == -1) {
+    bs.proposeSize(4);
     store<u32>(bs.offset, 6094939);
     bs.offset += 4;
     return;
   }
+  bs.proposeSize(4 + <u32>(end) * 2);
 
   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;
   }

package/assembly/serialize/swar/string.ts

@@ -1,10 +1,10 @@
 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
-// @ts-nocheck
 @lazy const U00_MARKER = 13511005048209500;
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const U_MARKER = 7667804;
@@ -89,7 +89,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);
@@ -152,19 +152,10 @@ export function serializeString_SWAR(src: string): void {
 @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;

package/assembly/tsconfig.json

@@ -2,6 +2,7 @@
   "extends": "assemblyscript/std/assembly.json",
   "include": ["./**/*.ts"],
   "compilerOptions": {
+    "allowImportingTsExtensions": true,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
 
@@ -18,6 +19,6 @@
     "noUnusedParameters": false,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": false
-  }
+    "noUncheckedIndexedAccess": false,
+  },
 }