jseption 0.0.5 → 0.0.7

package/dist/builtins/typedarray.js

@@ -8,42 +8,57 @@
  * access goes through host typed array / DataView views created over it.
  */
 import * as Q from "../quickjs.js";
-import { JS_EXCEPTION, JS_IsException, JS_IsUndefined, JS_IsObject, JS_IsNull, JSArrayBuffer, JSTypedArray, JS_NewObject, JS_NewObjectProto, JS_NewArray, JS_NewCFunction2, JS_NewCFunction3, JS_DefinePropertyValue, JS_DefinePropertyValueStr, JS_DefinePropertyValueInt64, JS_PROP_WRITABLE, JS_PROP_CONFIGURABLE, JS_PROP_C_W_E, JS_PROP_THROW, JS_GetProperty, JS_GetPropertyInt64, JS_SetPropertyInt64, JS_GetPropertyUint32, JS_SetPropertyUint32, JS_GetPropertyValue, JS_SetPropertyValue, JS_ToString, JS_ToBoolFree, JS_ToFloat64, JS_ToUint32Free, JS_ToUint8ClampFree, JS_ToBigInt64, JS_ToIndex, JS_ToInt64Sat, JS_ToInt32Clamp, JS_ToInt64Clamp, JS_ToLengthFree, JS_ToPrimitive, HINT_NUMBER, JS_ToObject, js_get_length64, JS_ThrowTypeError, JS_ThrowRangeError, JS_ThrowTypeErrorInvalidClass, JS_IsFunction, JS_Call, JS_CallConstructor, JS_Invoke, js_create_from_ctor, js_same_value, JS_GetIterator2, JS_IteratorNext, JS_CreateDataPropertyUint32, JS_GetOpaque2, JS_AtomToString, JS_SetPropertyFunctionList, JS_NewGlobalCConstructorOnly, JS_NewGlobalCConstructor2, JS_SetConstructor, JS_CFUNC_DEF, JS_CFUNC_MAGIC_DEF, JS_NATIVE_DEF, JS_CGETSET_DEF, JS_CGETSET_MAGIC_DEF, JS_ALIAS_DEF, JS_PROP_STRING_DEF, JS_ATOM_length, JS_ATOM_toString, JS_ATOM_toLocaleString, JS_ATOM_join, JS_ATOM_next, JS_ATOM_set, JS_ATOM_Symbol_iterator, JS_ATOM_Symbol_species, JS_ATOM_Symbol_toStringTag, JS_ATOM_Uint8ClampedArray, } from "../quickjs.js";
+import { JS_EXCEPTION, JS_IsException, JS_IsUndefined, JS_IsObject, JS_IsNull, JSArrayBuffer, JSTypedArray, JS_NewObject, JS_NewObjectProto, JS_NewArray, JS_NewCFunction2, JS_NewCFunction3, JS_DefinePropertyValue, JS_DefinePropertyValueStr, JS_DefinePropertyValueInt64, JS_PROP_WRITABLE, JS_PROP_CONFIGURABLE, JS_PROP_C_W_E, JS_PROP_THROW, JS_GetProperty, JS_GetPropertyInt64, JS_SetPropertyInt64, JS_GetPropertyUint32, JS_SetPropertyUint32, JS_GetPropertyValue, JS_SetPropertyValue, JS_ToString, JS_ToBoolFree, JS_ToFloat64, JS_ToUint32Free, JS_ToUint8ClampFree, JS_ToBigInt64, JS_ToIndex, JS_ToInt64Sat, JS_ToInt32Clamp, JS_ToInt64Clamp, JS_ToLengthFree, JS_ToPrimitive, HINT_NUMBER, JS_ToObject, js_get_length64, JS_ThrowTypeError, JS_ThrowRangeError, JS_ThrowSyntaxError, JS_GetPropertyStr, JS_ThrowTypeErrorInvalidClass, JS_IsFunction, JS_Call, JS_CallConstructor, JS_Invoke, js_create_from_ctor, js_same_value, JS_GetIterator2, JS_IteratorNext, JS_CreateDataPropertyUint32, JS_GetOpaque2, JS_AtomToString, JS_SetPropertyFunctionList, JS_NewGlobalCConstructorOnly, JS_NewGlobalCConstructor2, JS_SetConstructor, JS_CFUNC_DEF, JS_CFUNC_MAGIC_DEF, JS_NATIVE_DEF, JS_CGETSET_DEF, JS_CGETSET_MAGIC_DEF, JS_ALIAS_DEF, JS_PROP_STRING_DEF, JS_ATOM_length, JS_ATOM_toString, JS_ATOM_toLocaleString, JS_ATOM_join, JS_ATOM_next, JS_ATOM_set, JS_ATOM_Symbol_iterator, JS_ATOM_Symbol_species, JS_ATOM_Symbol_toStringTag, JS_ATOM_Uint8ClampedArray, } from "../quickjs.js";
 import { JS_SpeciesConstructor, check_function } from "./promise.js";
 import { fix_array_iterator } from "./native.js";
+import { tofp16, fromfp16, f16round } from "./float16.js";
+import { B64_ALPHABET_BASE64, B64_ALPHABET_BASE64URL, B64_LAST_LOOSE, B64_LAST_STRICT, B64_LAST_STOP_BEFORE_PARTIAL, b64_encode, from_base64, u8a_hex_encode, u8a_hex_decode, } from "./base64.js";
 const HOST_TYPED_ARRAY_PROTO = Object.getPrototypeOf(Uint8Array.prototype);
 /* JS_ITERATOR_KIND_xxx (same values as JSIteratorKind in index.ts) */
 const JS_ITERATOR_KIND_KEY = 0;
 const JS_ITERATOR_KIND_VALUE = 1;
 const JS_ITERATOR_KIND_KEY_AND_VALUE = 2;
-const JS_TYPED_ARRAY_COUNT = 31 /* JSClassID.FLOAT64_ARRAY */ - 21 /* JSClassID.UINT8C_ARRAY */ + 1;
+const JS_TYPED_ARRAY_COUNT = 32 /* JSClassID.FLOAT64_ARRAY */ - 21 /* JSClassID.UINT8C_ARRAY */ + 1;
 const typed_array_size_log2_tab = [
     0, 0, 0, 1, 1, 2, 2,
     3, 3, /* BigInt64Array, BigUint64Array */
-    2, 3,
+    1, 2, 3, /* Float16Array, Float32Array, Float64Array */
 ];
 function typed_array_size_log2(class_id) {
     return typed_array_size_log2_tab[class_id - 21 /* JSClassID.UINT8C_ARRAY */];
 }
+/* Guest typed arrays are host typed arrays, so Float16Array exists in the
+   guest only when the host has it (its class slot stays empty otherwise).
+   Math.f16round and DataView's float16 methods do not need it. */
+const HostFloat16Array = globalThis.Float16Array;
 const host_ta_ctors = [
     Uint8ClampedArray, Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array,
-    BigInt64Array, BigUint64Array, Float32Array, Float64Array,
+    BigInt64Array, BigUint64Array, HostFloat16Array, Float32Array, Float64Array,
 ];
+/* true if the host provides the guest typed array class 'class_id' */
+export function typed_array_class_available(class_id) {
+    return host_ta_ctors[class_id - 21 /* JSClassID.UINT8C_ARRAY */] !== undefined;
+}
 /* ---------------------------------------------------------------------
    ArrayBuffer
    --------------------------------------------------------------------- */
 /* array buffer data with the resizable extension. The host buffer is
    resizable (growable when shared) when max_len >= 0; 'data' is a length
-   tracking view over it. */
+   tracking view over it. With 'existing', the guest buffer is that host
+   buffer itself (JS_NewArrayBufferFrom): the two sides share the bytes. */
 export class JSArrayBufferData extends JSArrayBuffer {
     /* maximum byte length for resizable buffers, -1 otherwise */
     max_byte_length = -1;
     /* cached host DataView over 'data' */
     dv = null;
     dv_data = null;
-    constructor(len, shared, max_len) {
+    constructor(len, shared, max_len, existing) {
         let buffer;
-        if (shared)
+        if (existing) {
+            buffer = existing;
+            max_len = (shared ? existing.growable : existing.resizable) ? existing.maxByteLength : -1;
+        }
+        else if (shared)
             buffer = max_len >= 0 ? new SharedArrayBuffer(len, { maxByteLength: max_len }) : new SharedArrayBuffer(len);
         else
             buffer = max_len >= 0 ? new ArrayBuffer(len, { maxByteLength: max_len }) : new ArrayBuffer(len);
@@ -51,6 +66,10 @@ export class JSArrayBufferData extends JSArrayBuffer {
         this.max_byte_length = max_len;
     }
 }
+/* a host SharedArrayBuffer, where the host has one */
+export function isSharedArrayBuffer(v) {
+    return typeof SharedArrayBuffer === 'function' && v instanceof SharedArrayBuffer;
+}
 function array_buffer_get_dv(abuf) {
     const a = abuf;
     if (a.dv === null || a.dv_data !== abuf.data) {
@@ -77,7 +96,7 @@ function JS_ThrowTypeErrorArrayBufferOOB(ctx) {
 }
 /* XXX: we are currently limited to 2 GB */
 const ARRAY_BUFFER_MAX_LENGTH = 0x7fffffff;
-function js_array_buffer_constructor3(ctx, new_target, len, max_len, class_id, buf) {
+function js_array_buffer_constructor3(ctx, new_target, len, max_len, class_id, buf, existing) {
     const obj = js_create_from_ctor(ctx, new_target, class_id);
     if (JS_IsException(obj))
         return obj;
@@ -85,12 +104,21 @@ function js_array_buffer_constructor3(ctx, new_target, len, max_len, class_id, b
         return JS_ThrowRangeError(ctx, 'invalid array buffer length');
     if (max_len > ARRAY_BUFFER_MAX_LENGTH)
         return JS_ThrowRangeError(ctx, 'invalid array buffer maximum length');
-    const abuf = new JSArrayBufferData(len, class_id === 20 /* JSClassID.SHARED_ARRAY_BUFFER */, max_len);
+    const abuf = new JSArrayBufferData(len, class_id === 20 /* JSClassID.SHARED_ARRAY_BUFFER */, max_len, existing);
     if (buf)
         abuf.data.set(buf.subarray(0, len));
     Q.JS_SetOpaque(obj, abuf);
     return obj;
 }
+/* a guest ArrayBuffer (or SharedArrayBuffer) over the host buffer itself, not a
+   copy: what the guest writes the host sees, and the other way round. A
+   buffer is bytes: it reaches no host object, so sharing it keeps the
+   sandbox rules (its guest prototype is the guest's). The guest cannot
+   detach, resize or transfer it beyond what the host buffer allows. */
+export function JS_NewArrayBufferFrom(ctx, buffer) {
+    const shared = isSharedArrayBuffer(buffer);
+    return js_array_buffer_constructor3(ctx, undefined, buffer.byteLength, -1, shared ? 20 /* JSClassID.SHARED_ARRAY_BUFFER */ : 19 /* JSClassID.ARRAY_BUFFER */, null, buffer);
+}
 function js_array_buffer_constructor2(ctx, new_target, len, class_id) {
     return js_array_buffer_constructor3(ctx, new_target, len, -1, class_id, null);
 }
@@ -116,7 +144,7 @@ function js_array_buffer_constructor0(ctx, new_target, argv, class_id) {
             if (max_len < 0)
                 return JS_EXCEPTION;
             if (len > max_len)
-                return JS_ThrowRangeError(ctx, 'invalid array buffer length');
+                return JS_ThrowRangeError(ctx, 'invalid array buffer max length');
         }
     }
     return js_array_buffer_constructor3(ctx, new_target, len, max_len, class_id, null);
@@ -130,7 +158,7 @@ function js_shared_array_buffer_constructor(ctx, new_target, argv) {
 }
 function js_array_buffer_isView(ctx, this_val, argv) {
     const v = argv[0];
-    return Q.JS_IsObject(v) && Q.JS_GetClassID(v) >= 21 /* JSClassID.UINT8C_ARRAY */ && Q.JS_GetClassID(v) <= 32 /* JSClassID.DATAVIEW */;
+    return Q.JS_IsObject(v) && Q.JS_GetClassID(v) >= 21 /* JSClassID.UINT8C_ARRAY */ && Q.JS_GetClassID(v) <= 33 /* JSClassID.DATAVIEW */;
 }
 function js_get_this(ctx, this_val) { return this_val; }
 const js_array_buffer_funcs = [
@@ -316,12 +344,12 @@ const js_shared_array_buffer_proto_funcs = [
    Typed arrays
    --------------------------------------------------------------------- */
 export function is_typed_array_class(class_id) {
-    return class_id >= 21 /* JSClassID.UINT8C_ARRAY */ && class_id <= 31 /* JSClassID.FLOAT64_ARRAY */;
+    return class_id >= 21 /* JSClassID.UINT8C_ARRAY */ && class_id <= 32 /* JSClassID.FLOAT64_ARRAY */;
 }
 function get_typed_array(ctx, this_val, is_dataview) {
     if (Q.JS_IsObject(this_val)) {
         if (is_dataview) {
-            if (Q.JS_GetClassID(this_val) === 32 /* JSClassID.DATAVIEW */)
+            if (Q.JS_GetClassID(this_val) === 33 /* JSClassID.DATAVIEW */)
                 return this_val;
         }
         else {
@@ -357,7 +385,7 @@ function typed_array_get_byte_length(ta, size_log2) {
 }
 /* byte length of a typed array or DataView object (-1 if detached/OOB) */
 function js_typed_array_byte_length(p) {
-    const size_log2 = Q.JS_GetClassID(p) === 32 /* JSClassID.DATAVIEW */ ? 0 : typed_array_size_log2(Q.JS_GetClassID(p));
+    const size_log2 = Q.JS_GetClassID(p) === 33 /* JSClassID.DATAVIEW */ ? 0 : typed_array_size_log2(Q.JS_GetClassID(p));
     return typed_array_get_byte_length(Q.JS_GetAnyOpaque(p), size_log2);
 }
 /* return true if the typed array is detached or out of bounds (resized buffer) */
@@ -951,7 +979,25 @@ function js_typed_array_indexOf(ctx, this_val, argv, special) {
                 scan(d);
             break;
         }
-        case 30 /* JSClassID.FLOAT32_ARRAY */:
+        case 30 /* JSClassID.FLOAT16_ARRAY */:
+            if (is_bigint)
+                break;
+            if (Number.isNaN(d)) {
+                /* special case: indexOf returns -1, includes finds NaN */
+                if (special !== special_includes)
+                    return done();
+                for (; k !== stop; k += inc) {
+                    if (Number.isNaN(view[k])) {
+                        res = k;
+                        break;
+                    }
+                }
+            }
+            else if (f16round(d) === d) {
+                scan(d);
+            }
+            break;
+        case 31 /* JSClassID.FLOAT32_ARRAY */:
             if (is_bigint)
                 break;
             if (Number.isNaN(d)) {
@@ -969,7 +1015,7 @@ function js_typed_array_indexOf(ctx, this_val, argv, special) {
                 scan(d);
             }
             break;
-        case 31 /* JSClassID.FLOAT64_ARRAY */:
+        case 32 /* JSClassID.FLOAT64_ARRAY */:
             if (is_bigint)
                 break;
             if (Number.isNaN(d)) {
@@ -1559,10 +1605,16 @@ function js_typed_array_constructor(ctx, new_target, argv, classid) {
     let len, offset;
     let track_rab = false;
     const arg0 = argv[0];
+    /* the object (its prototype read from new.target) is created before the
+       offset and the length are converted (QuickJS 68caa5f) */
+    let obj;
     if (!Q.JS_IsObject(arg0)) {
         len = JS_ToIndex(ctx, arg0);
         if (len < 0)
             return JS_EXCEPTION;
+        obj = js_create_from_ctor(ctx, new_target, classid);
+        if (JS_IsException(obj))
+            return JS_EXCEPTION;
         buffer = js_array_buffer_constructor1(ctx, undefined, len << size_log2);
         if (JS_IsException(buffer))
             return JS_EXCEPTION;
@@ -1571,15 +1623,20 @@ function js_typed_array_constructor(ctx, new_target, argv, classid) {
     else {
         const p = arg0;
         if (Q.JS_GetClassID(p) === 19 /* JSClassID.ARRAY_BUFFER */ || Q.JS_GetClassID(p) === 20 /* JSClassID.SHARED_ARRAY_BUFFER */) {
+            obj = js_create_from_ctor(ctx, new_target, classid);
+            if (JS_IsException(obj))
+                return JS_EXCEPTION;
             const abuf = Q.JS_GetAnyOpaque(p);
             offset = JS_ToIndex(ctx, argv[1]);
             if (offset < 0)
                 return JS_EXCEPTION;
-            if (abuf.detached)
-                return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
-            if ((offset & ((1 << size_log2) - 1)) !== 0 || offset > abuf.data.length)
+            if ((offset & ((1 << size_log2) - 1)) !== 0)
                 return JS_ThrowRangeError(ctx, 'invalid offset');
             if (JS_IsUndefined(argv[2])) {
+                if (abuf.detached)
+                    return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+                if (offset > abuf.data.length)
+                    return JS_ThrowRangeError(ctx, 'invalid offset');
                 if (array_buffer_is_resizable(abuf)) {
                     track_rab = true;
                     len = (abuf.data.length - offset) >> size_log2;
@@ -1610,9 +1667,6 @@ function js_typed_array_constructor(ctx, new_target, argv, classid) {
             }
         }
     }
-    const obj = js_create_from_ctor(ctx, new_target, classid);
-    if (JS_IsException(obj))
-        return JS_EXCEPTION;
     return typed_array_init(ctx, obj, buffer, offset, len, track_rab);
 }
 /* ---------------------------------------------------------------------
@@ -1635,6 +1689,7 @@ function js_dataview_constructor(ctx, new_target, argv) {
         return JS_ThrowRangeError(ctx, 'invalid byteOffset');
     let len = abuf.data.length - offset;
     let track_rab = false;
+    let recompute_len = false;
     if (argv.length > 2 && !JS_IsUndefined(argv[2])) {
         const l = JS_ToIndex(ctx, argv[2]);
         if (l < 0)
@@ -1644,18 +1699,24 @@ function js_dataview_constructor(ctx, new_target, argv) {
         len = l;
     }
     else {
+        recompute_len = true;
         track_rab = array_buffer_is_resizable(abuf);
     }
-    const obj = js_create_from_ctor(ctx, new_target, 32 /* JSClassID.DATAVIEW */);
+    const obj = js_create_from_ctor(ctx, new_target, 33 /* JSClassID.DATAVIEW */);
     if (JS_IsException(obj))
         return JS_EXCEPTION;
     if (abuf.detached) {
         /* could have been detached in js_create_from_ctor() */
         return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
     }
-    /* the buffer could have been resized in js_create_from_ctor() */
-    if (offset > abuf.data.length || (!track_rab && offset + len > abuf.data.length))
-        return JS_ThrowTypeErrorArrayBufferOOB(ctx);
+    /* the buffer could have been resized in js_create_from_ctor() (a RangeError, as in
+       QuickJS 2026-06-04 and the specification) */
+    if (offset > abuf.data.length)
+        return JS_ThrowRangeError(ctx, 'invalid byteOffset or byteLength');
+    if (recompute_len)
+        len = abuf.data.length - offset;
+    else if (offset + len > abuf.data.length)
+        return JS_ThrowRangeError(ctx, 'invalid byteOffset or byteLength');
     const ta = new JSTypedArray(buffer, offset, len);
     ta.track_rab = track_rab;
     let view;
@@ -1668,7 +1729,7 @@ function js_dataview_constructor(ctx, new_target, argv) {
     return host_view_adopt(ctx, obj, view, ta);
 }
 function js_dataview_getValue(ctx, this_obj, argv, class_id) {
-    const ta = JS_GetOpaque2(ctx, this_obj, 32 /* JSClassID.DATAVIEW */);
+    const ta = JS_GetOpaque2(ctx, this_obj, 33 /* JSClassID.DATAVIEW */);
     if (!ta)
         return JS_EXCEPTION;
     const size = 1 << typed_array_size_log2(class_id);
@@ -1695,13 +1756,14 @@ function js_dataview_getValue(ctx, this_obj, argv, class_id) {
         case 27 /* JSClassID.UINT32_ARRAY */: return dv.getUint32(ptr, littleEndian);
         case 28 /* JSClassID.BIG_INT64_ARRAY */: return dv.getBigInt64(ptr, littleEndian);
         case 29 /* JSClassID.BIG_UINT64_ARRAY */: return dv.getBigUint64(ptr, littleEndian);
-        case 30 /* JSClassID.FLOAT32_ARRAY */: return dv.getFloat32(ptr, littleEndian);
-        case 31 /* JSClassID.FLOAT64_ARRAY */: return dv.getFloat64(ptr, littleEndian);
+        case 30 /* JSClassID.FLOAT16_ARRAY */: return fromfp16(dv.getUint16(ptr, littleEndian));
+        case 31 /* JSClassID.FLOAT32_ARRAY */: return dv.getFloat32(ptr, littleEndian);
+        case 32 /* JSClassID.FLOAT64_ARRAY */: return dv.getFloat64(ptr, littleEndian);
         default: return JS_ThrowTypeError(ctx, 'invalid DataView type');
     }
 }
 function js_dataview_setValue(ctx, this_obj, argv, class_id) {
-    const ta = JS_GetOpaque2(ctx, this_obj, 32 /* JSClassID.DATAVIEW */);
+    const ta = JS_GetOpaque2(ctx, this_obj, 33 /* JSClassID.DATAVIEW */);
     if (!ta)
         return JS_EXCEPTION;
     const size = 1 << typed_array_size_log2(class_id);
@@ -1753,14 +1815,17 @@ function js_dataview_setValue(ctx, this_obj, argv, class_id) {
         case 27 /* JSClassID.UINT32_ARRAY */:
             dv.setUint32(ptr, v, littleEndian);
             break;
-        case 30 /* JSClassID.FLOAT32_ARRAY */:
+        case 30 /* JSClassID.FLOAT16_ARRAY */:
+            dv.setUint16(ptr, tofp16(v), littleEndian);
+            break;
+        case 31 /* JSClassID.FLOAT32_ARRAY */:
             dv.setFloat32(ptr, v, littleEndian);
             break;
         case 28 /* JSClassID.BIG_INT64_ARRAY */:
         case 29 /* JSClassID.BIG_UINT64_ARRAY */:
             dv.setBigInt64(ptr, v64, littleEndian);
             break;
-        case 31 /* JSClassID.FLOAT64_ARRAY */:
+        case 32 /* JSClassID.FLOAT64_ARRAY */:
             dv.setFloat64(ptr, v, littleEndian);
             break;
         default:
@@ -1780,8 +1845,9 @@ const js_dataview_proto_funcs = [
     JS_CFUNC_MAGIC_DEF('getUint32', 1, js_dataview_getValue, 27 /* JSClassID.UINT32_ARRAY */),
     JS_CFUNC_MAGIC_DEF('getBigInt64', 1, js_dataview_getValue, 28 /* JSClassID.BIG_INT64_ARRAY */),
     JS_CFUNC_MAGIC_DEF('getBigUint64', 1, js_dataview_getValue, 29 /* JSClassID.BIG_UINT64_ARRAY */),
-    JS_CFUNC_MAGIC_DEF('getFloat32', 1, js_dataview_getValue, 30 /* JSClassID.FLOAT32_ARRAY */),
-    JS_CFUNC_MAGIC_DEF('getFloat64', 1, js_dataview_getValue, 31 /* JSClassID.FLOAT64_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('getFloat16', 1, js_dataview_getValue, 30 /* JSClassID.FLOAT16_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('getFloat32', 1, js_dataview_getValue, 31 /* JSClassID.FLOAT32_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('getFloat64', 1, js_dataview_getValue, 32 /* JSClassID.FLOAT64_ARRAY */),
     JS_CFUNC_MAGIC_DEF('setInt8', 2, js_dataview_setValue, 22 /* JSClassID.INT8_ARRAY */),
     JS_CFUNC_MAGIC_DEF('setUint8', 2, js_dataview_setValue, 23 /* JSClassID.UINT8_ARRAY */),
     JS_CFUNC_MAGIC_DEF('setInt16', 2, js_dataview_setValue, 24 /* JSClassID.INT16_ARRAY */),
@@ -1790,10 +1856,226 @@ const js_dataview_proto_funcs = [
     JS_CFUNC_MAGIC_DEF('setUint32', 2, js_dataview_setValue, 27 /* JSClassID.UINT32_ARRAY */),
     JS_CFUNC_MAGIC_DEF('setBigInt64', 2, js_dataview_setValue, 28 /* JSClassID.BIG_INT64_ARRAY */),
     JS_CFUNC_MAGIC_DEF('setBigUint64', 2, js_dataview_setValue, 29 /* JSClassID.BIG_UINT64_ARRAY */),
-    JS_CFUNC_MAGIC_DEF('setFloat32', 2, js_dataview_setValue, 30 /* JSClassID.FLOAT32_ARRAY */),
-    JS_CFUNC_MAGIC_DEF('setFloat64', 2, js_dataview_setValue, 31 /* JSClassID.FLOAT64_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('setFloat16', 2, js_dataview_setValue, 30 /* JSClassID.FLOAT16_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('setFloat32', 2, js_dataview_setValue, 31 /* JSClassID.FLOAT32_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('setFloat64', 2, js_dataview_setValue, 32 /* JSClassID.FLOAT64_ARRAY */),
     JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'DataView', JS_PROP_CONFIGURABLE),
 ];
+/* ---------------------------------------------------------------------
+   Uint8Array base64 / hex (tc39 proposal-arraybuffer-base64)
+   --------------------------------------------------------------------- */
+/* JS_STRING_LEN_MAX */
+const JS_STRING_LEN_MAX = (1 << 30) - 1;
+/* a new Uint8Array holding a copy of 'buf' (JS_NewUint8ArrayCopy) */
+function JS_NewUint8ArrayCopy(ctx, buf) {
+    const buffer = js_array_buffer_constructor3(ctx, undefined, buf.length, -1, 19 /* JSClassID.ARRAY_BUFFER */, buf);
+    if (JS_IsException(buffer))
+        return JS_EXCEPTION;
+    const obj = js_create_from_ctor(ctx, undefined, 23 /* JSClassID.UINT8_ARRAY */);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    return typed_array_init(ctx, obj, buffer, 0, buf.length, false);
+}
+/* this_val must be a Uint8Array (type check only, no detach check) */
+function check_uint8array(ctx, this_val) {
+    if (Q.JS_IsObject(this_val) && Q.JS_GetClassID(this_val) === 23 /* JSClassID.UINT8_ARRAY */)
+        return this_val;
+    JS_ThrowTypeError(ctx, 'not a Uint8Array');
+    return null;
+}
+/* the bytes of a Uint8Array, checking for detached and out of bounds buffers.
+   Must be called after the options are read (spec ordering). */
+function get_uint8array_bytes(ctx, p) {
+    if (typed_array_is_oob(ctx, p)) {
+        JS_ThrowTypeErrorArrayBufferOOB(ctx);
+        return null;
+    }
+    return typed_array_get_view(p) ?? new Uint8Array(0);
+}
+/* GetOptionsObject: undefined or an object */
+function check_options_object(ctx, options) {
+    if (JS_IsUndefined(options))
+        return 0;
+    if (!Q.JS_IsObject(options)) {
+        JS_ThrowTypeError(ctx, 'options must be an object');
+        return -1;
+    }
+    return 0;
+}
+/* the 'alphabet' option: B64_ALPHABET_xxx or -1 on exception */
+function parse_alphabet_option(ctx, options) {
+    if (JS_IsUndefined(options))
+        return B64_ALPHABET_BASE64;
+    const val = JS_GetPropertyStr(ctx, options, 'alphabet');
+    if (JS_IsException(val))
+        return -1;
+    if (JS_IsUndefined(val))
+        return B64_ALPHABET_BASE64;
+    if (typeof val !== 'string') {
+        JS_ThrowTypeError(ctx, 'expected string for alphabet');
+        return -1;
+    }
+    if (val === 'base64')
+        return B64_ALPHABET_BASE64;
+    if (val === 'base64url')
+        return B64_ALPHABET_BASE64URL;
+    JS_ThrowTypeError(ctx, 'invalid alphabet');
+    return -1;
+}
+/* the 'lastChunkHandling' option: B64_LAST_xxx or -1 on exception */
+function parse_last_chunk_option(ctx, options) {
+    if (JS_IsUndefined(options))
+        return B64_LAST_LOOSE;
+    const val = JS_GetPropertyStr(ctx, options, 'lastChunkHandling');
+    if (JS_IsException(val))
+        return -1;
+    if (JS_IsUndefined(val))
+        return B64_LAST_LOOSE;
+    if (typeof val !== 'string') {
+        JS_ThrowTypeError(ctx, 'expected string for lastChunkHandling');
+        return -1;
+    }
+    if (val === 'loose')
+        return B64_LAST_LOOSE;
+    if (val === 'strict')
+        return B64_LAST_STRICT;
+    if (val === 'stop-before-partial')
+        return B64_LAST_STOP_BEFORE_PARTIAL;
+    JS_ThrowTypeError(ctx, 'invalid lastChunkHandling option');
+    return -1;
+}
+/* Uint8Array.prototype.toBase64([options]) */
+function js_uint8array_to_base64(ctx, this_val, argv) {
+    const p = check_uint8array(ctx, this_val);
+    if (!p)
+        return JS_EXCEPTION;
+    const options = argv.length > 0 ? argv[0] : undefined;
+    if (check_options_object(ctx, options))
+        return JS_EXCEPTION;
+    const alphabet = parse_alphabet_option(ctx, options);
+    if (alphabet < 0)
+        return JS_EXCEPTION;
+    let omit_padding = false;
+    if (!JS_IsUndefined(options)) {
+        const op_val = JS_GetPropertyStr(ctx, options, 'omitPadding');
+        if (JS_IsException(op_val))
+            return JS_EXCEPTION;
+        omit_padding = JS_ToBoolFree(ctx, op_val);
+    }
+    const data = get_uint8array_bytes(ctx, p);
+    if (!data)
+        return JS_EXCEPTION;
+    if (4 * Math.floor((data.length + 2) / 3) > JS_STRING_LEN_MAX)
+        return JS_ThrowRangeError(ctx, 'output too large');
+    return b64_encode(data, alphabet, omit_padding);
+}
+/* Uint8Array.prototype.toHex() */
+function js_uint8array_to_hex(ctx, this_val, argv) {
+    const p = check_uint8array(ctx, this_val);
+    if (!p)
+        return JS_EXCEPTION;
+    const data = get_uint8array_bytes(ctx, p);
+    if (!data)
+        return JS_EXCEPTION;
+    if (data.length * 2 > JS_STRING_LEN_MAX)
+        return JS_ThrowRangeError(ctx, 'output too large');
+    return u8a_hex_encode(data);
+}
+/* Uint8Array.fromBase64(string[, options]) */
+function js_uint8array_from_base64(ctx, this_val, argv) {
+    const str = argv[0];
+    if (typeof str !== 'string')
+        return JS_ThrowTypeError(ctx, 'expected string');
+    const options = argv.length > 1 ? argv[1] : undefined;
+    if (check_options_object(ctx, options))
+        return JS_EXCEPTION;
+    const alphabet = parse_alphabet_option(ctx, options);
+    if (alphabet < 0)
+        return JS_EXCEPTION;
+    const last_chunk = parse_last_chunk_option(ctx, options);
+    if (last_chunk < 0)
+        return JS_EXCEPTION;
+    const out_cap = Math.floor(str.length / 4) * 3 + 3;
+    const buf = new Uint8Array(out_cap);
+    const r = from_base64(str, buf, out_cap, alphabet, last_chunk);
+    if (r.err)
+        return JS_ThrowSyntaxError(ctx, 'invalid base64 string');
+    return JS_NewUint8ArrayCopy(ctx, buf.subarray(0, r.written));
+}
+/* Uint8Array.fromHex(string) */
+function js_uint8array_from_hex(ctx, this_val, argv) {
+    const str = argv[0];
+    if (typeof str !== 'string')
+        return JS_ThrowTypeError(ctx, 'expected string');
+    const out_cap = Math.floor(str.length / 2) + 1;
+    const buf = new Uint8Array(out_cap);
+    const r = u8a_hex_decode(str, buf, out_cap);
+    if (r.err)
+        return JS_ThrowSyntaxError(ctx, 'invalid hex string');
+    return JS_NewUint8ArrayCopy(ctx, buf.subarray(0, r.written));
+}
+/* a { read, written } result object */
+function js_make_read_written(ctx, read, written) {
+    const obj = JS_NewObject(ctx);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    if (JS_DefinePropertyValueStr(ctx, obj, 'read', read, JS_PROP_C_W_E) < 0)
+        return JS_EXCEPTION;
+    if (JS_DefinePropertyValueStr(ctx, obj, 'written', written, JS_PROP_C_W_E) < 0)
+        return JS_EXCEPTION;
+    return obj;
+}
+/* Uint8Array.prototype.setFromBase64(string[, options]) */
+function js_uint8array_set_from_base64(ctx, this_val, argv) {
+    const p = check_uint8array(ctx, this_val);
+    if (!p)
+        return JS_EXCEPTION;
+    const str = argv[0];
+    if (typeof str !== 'string')
+        return JS_ThrowTypeError(ctx, 'expected string');
+    const options = argv.length > 1 ? argv[1] : undefined;
+    if (check_options_object(ctx, options))
+        return JS_EXCEPTION;
+    const alphabet = parse_alphabet_option(ctx, options);
+    if (alphabet < 0)
+        return JS_EXCEPTION;
+    const last_chunk = parse_last_chunk_option(ctx, options);
+    if (last_chunk < 0)
+        return JS_EXCEPTION;
+    const data = get_uint8array_bytes(ctx, p);
+    if (!data)
+        return JS_EXCEPTION;
+    const r = from_base64(str, data, data.length, alphabet, last_chunk);
+    if (r.err)
+        return JS_ThrowSyntaxError(ctx, 'invalid base64 string');
+    return js_make_read_written(ctx, r.read, r.written);
+}
+/* Uint8Array.prototype.setFromHex(string) */
+function js_uint8array_set_from_hex(ctx, this_val, argv) {
+    const p = check_uint8array(ctx, this_val);
+    if (!p)
+        return JS_EXCEPTION;
+    const str = argv[0];
+    if (typeof str !== 'string')
+        return JS_ThrowTypeError(ctx, 'expected string');
+    const data = get_uint8array_bytes(ctx, p);
+    if (!data)
+        return JS_EXCEPTION;
+    const r = u8a_hex_decode(str, data, data.length);
+    if (r.err)
+        return JS_ThrowSyntaxError(ctx, 'invalid hex string');
+    return js_make_read_written(ctx, r.read, r.written);
+}
+const js_uint8array_proto_funcs = [
+    JS_CFUNC_DEF('toBase64', 0, js_uint8array_to_base64),
+    JS_CFUNC_DEF('toHex', 0, js_uint8array_to_hex),
+    JS_CFUNC_DEF('setFromBase64', 1, js_uint8array_set_from_base64),
+    JS_CFUNC_DEF('setFromHex', 1, js_uint8array_set_from_hex),
+];
+const js_uint8array_funcs = [
+    JS_CFUNC_DEF('fromBase64', 1, js_uint8array_from_base64),
+    JS_CFUNC_DEF('fromHex', 1, js_uint8array_from_hex),
+];
 /* ---------------------------------------------------------------------
    Intrinsics
    --------------------------------------------------------------------- */
@@ -1820,6 +2102,8 @@ export function JS_AddIntrinsicTypedArrays(ctx) {
     JS_SetPropertyFunctionList(ctx, typed_array_base_func, js_typed_array_base_funcs);
     JS_SetConstructor(ctx, typed_array_base_func, typed_array_base_proto);
     for (let i = 21 /* JSClassID.UINT8C_ARRAY */; i < 21 /* JSClassID.UINT8C_ARRAY */ + JS_TYPED_ARRAY_COUNT; i++) {
+        if (!typed_array_class_available(i))
+            continue; /* Float16Array on hosts without it */
         const proto = JS_NewObjectProto(ctx, typed_array_base_proto);
         ctx.class_proto[i] = proto;
         JS_DefinePropertyValueStr(ctx, proto, 'BYTES_PER_ELEMENT', 1 << typed_array_size_log2(i), 0);
@@ -1827,10 +2111,14 @@ export function JS_AddIntrinsicTypedArrays(ctx) {
         const func_obj = JS_NewCFunction3(ctx, js_typed_array_constructor, name, 3, 3 /* JSCFunctionEnum.constructor_magic */, i, typed_array_base_func);
         JS_NewGlobalCConstructor2(ctx, func_obj, name, proto);
         JS_DefinePropertyValueStr(ctx, func_obj, 'BYTES_PER_ELEMENT', 1 << typed_array_size_log2(i), 0);
+        if (i === 23 /* JSClassID.UINT8_ARRAY */) {
+            JS_SetPropertyFunctionList(ctx, func_obj, js_uint8array_funcs);
+            JS_SetPropertyFunctionList(ctx, proto, js_uint8array_proto_funcs);
+        }
     }
     /* DataView */
     const dv_proto = JS_NewObject(ctx);
-    ctx.class_proto[32 /* JSClassID.DATAVIEW */] = dv_proto;
+    ctx.class_proto[33 /* JSClassID.DATAVIEW */] = dv_proto;
     JS_SetPropertyFunctionList(ctx, dv_proto, js_dataview_proto_funcs);
     JS_NewGlobalCConstructorOnly(ctx, 'DataView', js_dataview_constructor, 1, dv_proto);
 }