jseption 0.0.0-stage → 0.0.2

package/dist/builtins/typedarray.js

@@ -0,0 +1,1838 @@
+/*
+ * ArrayBuffer, SharedArrayBuffer, typed arrays and DataView (port of the
+ * typed array section of quickjs.c).
+ *
+ * Typed arrays are exotic objects: the integer indexed element access is
+ * implemented by the class exotic methods registered on the runtime. The
+ * raw bytes live in the Uint8Array 'data' of the JSArrayBuffer; element
+ * 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_SpeciesConstructor, check_function } from "./promise.js";
+import { fix_array_iterator } from "./native.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 typed_array_size_log2_tab = [
+    0, 0, 0, 1, 1, 2, 2,
+    3, 3, /* BigInt64Array, BigUint64Array */
+    2, 3,
+];
+function typed_array_size_log2(class_id) {
+    return typed_array_size_log2_tab[class_id - 21 /* JSClassID.UINT8C_ARRAY */];
+}
+const host_ta_ctors = [
+    Uint8ClampedArray, Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array,
+    BigInt64Array, BigUint64Array, Float32Array, Float64Array,
+];
+/* ---------------------------------------------------------------------
+   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. */
+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) {
+        let buffer;
+        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);
+        super(buffer, shared);
+        this.max_byte_length = max_len;
+    }
+}
+function array_buffer_get_dv(abuf) {
+    const a = abuf;
+    if (a.dv === null || a.dv_data !== abuf.data) {
+        a.dv = new DataView(abuf.data.buffer, abuf.data.byteOffset, abuf.data.byteLength);
+        a.dv_data = abuf.data;
+    }
+    return a.dv;
+}
+function array_buffer_byte_length(abuf) {
+    return abuf.detached ? 0 : abuf.data.length;
+}
+function array_buffer_max_byte_length(abuf) {
+    const m = abuf.max_byte_length;
+    return (typeof m === 'number') ? m : -1;
+}
+function array_buffer_is_resizable(abuf) {
+    return array_buffer_max_byte_length(abuf) >= 0;
+}
+function JS_ThrowTypeErrorDetachedArrayBuffer(ctx) {
+    return JS_ThrowTypeError(ctx, 'ArrayBuffer is detached');
+}
+function JS_ThrowTypeErrorArrayBufferOOB(ctx) {
+    return JS_ThrowTypeError(ctx, 'ArrayBuffer is detached or resized');
+}
+/* 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) {
+    const obj = js_create_from_ctor(ctx, new_target, class_id);
+    if (JS_IsException(obj))
+        return obj;
+    if (len > ARRAY_BUFFER_MAX_LENGTH)
+        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);
+    if (buf)
+        abuf.data.set(buf.subarray(0, len));
+    Q.JS_SetOpaque(obj, abuf);
+    return obj;
+}
+function js_array_buffer_constructor2(ctx, new_target, len, class_id) {
+    return js_array_buffer_constructor3(ctx, new_target, len, -1, class_id, null);
+}
+function js_array_buffer_constructor1(ctx, new_target, len) {
+    return js_array_buffer_constructor2(ctx, new_target, len, 19 /* JSClassID.ARRAY_BUFFER */);
+}
+export function JS_NewArrayBufferCopy(ctx, buf) {
+    return js_array_buffer_constructor3(ctx, undefined, buf.length, -1, 19 /* JSClassID.ARRAY_BUFFER */, buf);
+}
+/* ArrayBuffer(length, options) / SharedArrayBuffer(length, options) */
+function js_array_buffer_constructor0(ctx, new_target, argv, class_id) {
+    const len = JS_ToIndex(ctx, argv[0]);
+    if (len < 0)
+        return JS_EXCEPTION;
+    let max_len = -1;
+    const options = argv[1];
+    if (JS_IsObject(options)) {
+        const val = JS_GetProperty(ctx, options, JS_NewAtomStr(ctx, 'maxByteLength'));
+        if (JS_IsException(val))
+            return JS_EXCEPTION;
+        if (!JS_IsUndefined(val)) {
+            max_len = JS_ToIndex(ctx, val);
+            if (max_len < 0)
+                return JS_EXCEPTION;
+            if (len > max_len)
+                return JS_ThrowRangeError(ctx, 'invalid array buffer length');
+        }
+    }
+    return js_array_buffer_constructor3(ctx, new_target, len, max_len, class_id, null);
+}
+function JS_NewAtomStr(ctx, s) { return ctx.rt.atoms.newAtomStr(s); }
+function js_array_buffer_constructor(ctx, new_target, argv) {
+    return js_array_buffer_constructor0(ctx, new_target, argv, 19 /* JSClassID.ARRAY_BUFFER */);
+}
+function js_shared_array_buffer_constructor(ctx, new_target, argv) {
+    return js_array_buffer_constructor0(ctx, new_target, argv, 20 /* JSClassID.SHARED_ARRAY_BUFFER */);
+}
+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 */;
+}
+function js_get_this(ctx, this_val) { return this_val; }
+const js_array_buffer_funcs = [
+    JS_CFUNC_DEF('isView', 1, js_array_buffer_isView),
+    JS_CGETSET_DEF(JS_ATOM_Symbol_species, js_get_this, null),
+];
+function js_array_buffer_get_byteLength(ctx, this_val, class_id) {
+    const abuf = JS_GetOpaque2(ctx, this_val, class_id);
+    if (!abuf)
+        return JS_EXCEPTION;
+    /* return 0 if detached */
+    return array_buffer_byte_length(abuf);
+}
+function js_array_buffer_get_maxByteLength(ctx, this_val, class_id) {
+    const abuf = JS_GetOpaque2(ctx, this_val, class_id);
+    if (!abuf)
+        return JS_EXCEPTION;
+    if (abuf.detached)
+        return 0;
+    if (array_buffer_is_resizable(abuf))
+        return array_buffer_max_byte_length(abuf);
+    return abuf.data.length;
+}
+function js_array_buffer_get_resizable(ctx, this_val, class_id) {
+    const abuf = JS_GetOpaque2(ctx, this_val, class_id);
+    if (!abuf)
+        return JS_EXCEPTION;
+    return array_buffer_is_resizable(abuf);
+}
+function js_array_buffer_get_detached(ctx, this_val) {
+    const abuf = JS_GetOpaque2(ctx, this_val, 19 /* JSClassID.ARRAY_BUFFER */);
+    if (!abuf)
+        return JS_EXCEPTION;
+    return abuf.detached;
+}
+export function JS_DetachArrayBuffer(ctx, obj) {
+    if (!Q.JS_IsObject(obj) || Q.JS_GetClassID(obj) !== 19 /* JSClassID.ARRAY_BUFFER */)
+        return;
+    const abuf = Q.JS_GetAnyOpaque(obj);
+    if (!abuf || abuf.detached)
+        return;
+    /* detach the host buffer so that the host views see a length of 0 */
+    try {
+        abuf.buffer.transfer(0);
+    }
+    catch { /* not transferable: keep the data */ }
+    abuf.data = new Uint8Array(0);
+    abuf.detached = true;
+    /* Note: the typed array length and offset fields are not modified */
+}
+/* ArrayBuffer.prototype.resize / SharedArrayBuffer.prototype.grow */
+function js_array_buffer_resize(ctx, this_val, argv, class_id) {
+    const abuf = JS_GetOpaque2(ctx, this_val, class_id);
+    if (!abuf)
+        return JS_EXCEPTION;
+    if (!array_buffer_is_resizable(abuf))
+        return JS_ThrowTypeError(ctx, 'array buffer is not resizable');
+    const len = JS_ToIndex(ctx, argv[0]);
+    if (len < 0)
+        return JS_EXCEPTION;
+    if (abuf.detached)
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    if (len > array_buffer_max_byte_length(abuf))
+        return JS_ThrowRangeError(ctx, 'invalid array buffer length');
+    if (abuf.shared && len < abuf.data.length)
+        return JS_ThrowRangeError(ctx, 'invalid array buffer length');
+    try {
+        if (abuf.shared)
+            abuf.buffer.grow(len);
+        else
+            abuf.buffer.resize(len);
+    }
+    catch (e) {
+        return Q.js_host_exception_to_guest(ctx, e);
+    }
+    /* 'data' is a length tracking view: nothing else to do */
+    return undefined;
+}
+/* ArrayBuffer.prototype.transfer / transferToFixedLength (magic = 1) */
+function js_array_buffer_transfer(ctx, this_val, argv, magic) {
+    const abuf = JS_GetOpaque2(ctx, this_val, 19 /* JSClassID.ARRAY_BUFFER */);
+    if (!abuf)
+        return JS_EXCEPTION;
+    let new_len;
+    if (JS_IsUndefined(argv[0])) {
+        new_len = array_buffer_byte_length(abuf);
+    }
+    else {
+        new_len = JS_ToIndex(ctx, argv[0]);
+        if (new_len < 0)
+            return JS_EXCEPTION;
+    }
+    if (abuf.detached)
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    let max_len = -1;
+    if (magic === 0 && array_buffer_is_resizable(abuf)) {
+        max_len = array_buffer_max_byte_length(abuf);
+        if (new_len > max_len)
+            return JS_ThrowRangeError(ctx, 'invalid array buffer length');
+    }
+    const new_obj = js_array_buffer_constructor3(ctx, undefined, new_len, max_len, 19 /* JSClassID.ARRAY_BUFFER */, abuf.data);
+    if (JS_IsException(new_obj))
+        return JS_EXCEPTION;
+    JS_DetachArrayBuffer(ctx, this_val);
+    return new_obj;
+}
+/* get an ArrayBuffer or SharedArrayBuffer */
+function js_get_array_buffer(ctx, obj) {
+    if (Q.JS_IsObject(obj) && (Q.JS_GetClassID(obj) === 19 /* JSClassID.ARRAY_BUFFER */ || Q.JS_GetClassID(obj) === 20 /* JSClassID.SHARED_ARRAY_BUFFER */)) {
+        return Q.JS_GetAnyOpaque(obj);
+    }
+    JS_ThrowTypeErrorInvalidClass(ctx, 19 /* JSClassID.ARRAY_BUFFER */);
+    return null;
+}
+function js_array_buffer_slice(ctx, this_val, argv, class_id) {
+    const abuf = JS_GetOpaque2(ctx, this_val, class_id);
+    if (!abuf)
+        return JS_EXCEPTION;
+    if (abuf.detached)
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    const len = abuf.data.length;
+    const start = JS_ToInt64Clamp(ctx, argv[0], 0, len, len);
+    if (JS_IsException(start))
+        return JS_EXCEPTION;
+    let end = len;
+    if (!JS_IsUndefined(argv[1])) {
+        end = JS_ToInt64Clamp(ctx, argv[1], 0, len, len);
+        if (JS_IsException(end))
+            return JS_EXCEPTION;
+    }
+    const new_len = Math.max(end - start, 0);
+    const ctor = JS_SpeciesConstructor(ctx, this_val, undefined);
+    if (JS_IsException(ctor))
+        return ctor;
+    let new_obj;
+    if (JS_IsUndefined(ctor)) {
+        new_obj = js_array_buffer_constructor2(ctx, undefined, new_len, class_id);
+    }
+    else {
+        new_obj = JS_CallConstructor(ctx, ctor, [new_len]);
+    }
+    if (JS_IsException(new_obj))
+        return new_obj;
+    const new_abuf = JS_GetOpaque2(ctx, new_obj, class_id);
+    if (!new_abuf)
+        return JS_EXCEPTION;
+    if (js_same_value(ctx, new_obj, this_val))
+        return JS_ThrowTypeError(ctx, 'cannot use identical ArrayBuffer');
+    if (new_abuf.detached)
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    if (new_abuf.data.length < new_len)
+        return JS_ThrowTypeError(ctx, 'new ArrayBuffer is too small');
+    /* must test again because of side effects */
+    if (abuf.detached)
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    new_abuf.data.set(abuf.data.subarray(start, start + new_len));
+    return new_obj;
+}
+const js_array_buffer_proto_funcs = [
+    JS_CGETSET_MAGIC_DEF('byteLength', js_array_buffer_get_byteLength, null, 19 /* JSClassID.ARRAY_BUFFER */),
+    JS_CGETSET_MAGIC_DEF('maxByteLength', js_array_buffer_get_maxByteLength, null, 19 /* JSClassID.ARRAY_BUFFER */),
+    JS_CGETSET_MAGIC_DEF('resizable', js_array_buffer_get_resizable, null, 19 /* JSClassID.ARRAY_BUFFER */),
+    JS_CGETSET_DEF('detached', js_array_buffer_get_detached, null),
+    JS_CFUNC_MAGIC_DEF('resize', 1, js_array_buffer_resize, 19 /* JSClassID.ARRAY_BUFFER */),
+    JS_CFUNC_MAGIC_DEF('slice', 2, js_array_buffer_slice, 19 /* JSClassID.ARRAY_BUFFER */),
+    JS_CFUNC_MAGIC_DEF('transfer', 0, js_array_buffer_transfer, 0),
+    JS_CFUNC_MAGIC_DEF('transferToFixedLength', 0, js_array_buffer_transfer, 1),
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'ArrayBuffer', JS_PROP_CONFIGURABLE),
+];
+/* SharedArrayBuffer */
+const js_shared_array_buffer_funcs = [
+    JS_CGETSET_DEF(JS_ATOM_Symbol_species, js_get_this, null),
+];
+const js_shared_array_buffer_proto_funcs = [
+    JS_CGETSET_MAGIC_DEF('byteLength', js_array_buffer_get_byteLength, null, 20 /* JSClassID.SHARED_ARRAY_BUFFER */),
+    JS_CGETSET_MAGIC_DEF('maxByteLength', js_array_buffer_get_maxByteLength, null, 20 /* JSClassID.SHARED_ARRAY_BUFFER */),
+    JS_CGETSET_MAGIC_DEF('growable', js_array_buffer_get_resizable, null, 20 /* JSClassID.SHARED_ARRAY_BUFFER */),
+    JS_CFUNC_MAGIC_DEF('grow', 1, js_array_buffer_resize, 20 /* JSClassID.SHARED_ARRAY_BUFFER */),
+    JS_CFUNC_MAGIC_DEF('slice', 2, js_array_buffer_slice, 20 /* JSClassID.SHARED_ARRAY_BUFFER */),
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'SharedArrayBuffer', JS_PROP_CONFIGURABLE),
+];
+/* ---------------------------------------------------------------------
+   Typed arrays
+   --------------------------------------------------------------------- */
+export function is_typed_array_class(class_id) {
+    return class_id >= 21 /* JSClassID.UINT8C_ARRAY */ && class_id <= 31 /* 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 */)
+                return this_val;
+        }
+        else {
+            if (is_typed_array_class(Q.JS_GetClassID(this_val)))
+                return this_val;
+        }
+    }
+    JS_ThrowTypeError(ctx, `not a ${is_dataview ? 'DataView' : 'TypedArray'}`);
+    return null;
+}
+/* WARNING: 'p' must be a typed array or a DataView */
+function typed_array_is_detached(ctx, p) {
+    const ta = Q.JS_GetAnyOpaque(p);
+    const abuf = Q.JS_GetAnyOpaque(ta.buffer);
+    return abuf.detached;
+}
+/* byte length of a typed array (size_log2 = element size) or DataView
+   (size_log2 = 0), taking the resizable buffer tracking into account.
+   Returns -1 if out of bounds or detached. */
+function typed_array_get_byte_length(ta, size_log2) {
+    const abuf = Q.JS_GetAnyOpaque(ta.buffer);
+    if (abuf.detached)
+        return -1;
+    const buf_len = abuf.data.length;
+    if (ta.track_rab) {
+        if (ta.offset > buf_len)
+            return -1;
+        return ((buf_len - ta.offset) >> size_log2) << size_log2;
+    }
+    if (ta.offset + ta.length > buf_len)
+        return -1;
+    return ta.length;
+}
+/* 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));
+    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) */
+function typed_array_is_oob(ctx, p) {
+    return js_typed_array_byte_length(p) < 0;
+}
+/* WARNING: 'p' must be a typed array. Works even if the array buffer is
+   detached (returns 0). This is p->u.array.count in the C version. */
+function typed_array_get_length(ctx, p) {
+    const byte_len = js_typed_array_byte_length(p);
+    if (byte_len < 0)
+        return 0;
+    return byte_len >> typed_array_size_log2(Q.JS_GetClassID(p));
+}
+const ta_view_cache = new WeakMap();
+function typed_array_get_view(p) {
+    const ta = Q.JS_GetAnyOpaque(p);
+    const abuf = Q.JS_GetAnyOpaque(ta.buffer);
+    const byte_len = js_typed_array_byte_length(p);
+    if (byte_len < 0)
+        return null;
+    const len = byte_len >> typed_array_size_log2(Q.JS_GetClassID(p));
+    const c = ta_view_cache.get(ta);
+    if (c && c.data === abuf.data && c.len === len && c.offset === ta.offset)
+        return c.view;
+    const ctor = host_ta_ctors[Q.JS_GetClassID(p) - 21 /* JSClassID.UINT8C_ARRAY */];
+    const view = new ctor(abuf.data.buffer, abuf.data.byteOffset + ta.offset, len);
+    ta_view_cache.set(ta, { data: abuf.data, len, offset: ta.offset, view });
+    return view;
+}
+function validate_typed_array(ctx, this_val) {
+    const p = get_typed_array(ctx, this_val, false);
+    if (!p)
+        return -1;
+    if (typed_array_is_detached(ctx, p)) {
+        JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+        return -1;
+    }
+    if (typed_array_is_oob(ctx, p)) {
+        JS_ThrowTypeErrorArrayBufferOOB(ctx);
+        return -1;
+    }
+    return 0;
+}
+function js_typed_array_get_length(ctx, this_val) {
+    const p = get_typed_array(ctx, this_val, false);
+    if (!p)
+        return JS_EXCEPTION;
+    return typed_array_get_length(ctx, p);
+}
+function js_typed_array_get_buffer(ctx, this_val, is_dataview) {
+    const p = get_typed_array(ctx, this_val, is_dataview !== 0);
+    if (!p)
+        return JS_EXCEPTION;
+    return Q.JS_GetAnyOpaque(p).buffer;
+}
+function js_typed_array_get_byteLength(ctx, this_val, is_dataview) {
+    const p = get_typed_array(ctx, this_val, is_dataview !== 0);
+    if (!p)
+        return JS_EXCEPTION;
+    const ta = Q.JS_GetAnyOpaque(p);
+    if (typed_array_is_detached(ctx, p)) {
+        if (is_dataview)
+            return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+        return 0;
+    }
+    const len = js_typed_array_byte_length(p);
+    if (len < 0) {
+        if (is_dataview)
+            return JS_ThrowTypeErrorArrayBufferOOB(ctx);
+        return 0;
+    }
+    void ta;
+    return len;
+}
+function js_typed_array_get_byteOffset(ctx, this_val, is_dataview) {
+    const p = get_typed_array(ctx, this_val, is_dataview !== 0);
+    if (!p)
+        return JS_EXCEPTION;
+    const ta = Q.JS_GetAnyOpaque(p);
+    if (typed_array_is_detached(ctx, p)) {
+        if (is_dataview)
+            return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+        return 0;
+    }
+    if (js_typed_array_byte_length(p) < 0) {
+        if (is_dataview)
+            return JS_ThrowTypeErrorArrayBufferOOB(ctx);
+        return 0;
+    }
+    return ta.offset;
+}
+function js_typed_array_get_toStringTag(ctx, this_val) {
+    if (!Q.JS_IsObject(this_val))
+        return undefined;
+    if (!is_typed_array_class(Q.JS_GetClassID(this_val)))
+        return undefined;
+    return JS_AtomToString(ctx, ctx.rt.class_array[Q.JS_GetClassID(this_val)].class_name);
+}
+/* element access */
+function typed_array_get_element(p, idx) {
+    const view = typed_array_get_view(p);
+    if (!view || idx >= view.length)
+        return undefined;
+    return view[idx];
+}
+/* convert 'val' to the element type. Returns the converted value (number
+   or bigint) or JS_EXCEPTION */
+function typed_array_convert_value(ctx, class_id, val) {
+    if (class_id === 21 /* JSClassID.UINT8C_ARRAY */) {
+        const v = JS_ToUint8ClampFree(ctx, val);
+        if (JS_IsException(v))
+            return JS_EXCEPTION;
+        return v;
+    }
+    else if (class_id <= 27 /* JSClassID.UINT32_ARRAY */) {
+        const v = JS_ToUint32Free(ctx, val);
+        if (JS_IsException(v))
+            return JS_EXCEPTION;
+        return v;
+    }
+    else if (class_id <= 29 /* JSClassID.BIG_UINT64_ARRAY */) {
+        const v = JS_ToBigInt64(ctx, val);
+        if (JS_IsException(v))
+            return JS_EXCEPTION;
+        return v;
+    }
+    else {
+        const v = JS_ToFloat64(ctx, val);
+        if (JS_IsException(v))
+            return JS_EXCEPTION;
+        return v;
+    }
+}
+/* TypedArraySetElement: the value is converted even if the index is out
+   of bounds. Return -1 if exception, TRUE otherwise. */
+function typed_array_set_element(ctx, p, idx, val) {
+    const v = typed_array_convert_value(ctx, Q.JS_GetClassID(p), val);
+    if (JS_IsException(v))
+        return -1;
+    const view = typed_array_get_view(p);
+    if (view && idx >= 0 && idx < view.length)
+        view[idx] = v;
+    return 1;
+}
+/* methods */
+function js_typed_array_set_internal(ctx, dst, src, off) {
+    const p = get_typed_array(ctx, dst, false);
+    if (!p)
+        return JS_EXCEPTION;
+    const offset = JS_ToInt64Sat(ctx, off);
+    if (JS_IsException(offset))
+        return JS_EXCEPTION;
+    if (offset < 0)
+        return JS_ThrowRangeError(ctx, 'invalid array length');
+    if (typed_array_is_detached(ctx, p))
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    const src_obj = JS_ToObject(ctx, src);
+    if (JS_IsException(src_obj))
+        return JS_EXCEPTION;
+    const src_p = src_obj;
+    const dst_len = typed_array_get_length(ctx, p);
+    let src_len;
+    if (is_typed_array_class(Q.JS_GetClassID(src_p))) {
+        if (typed_array_is_detached(ctx, src_p))
+            return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+        src_len = typed_array_get_length(ctx, src_p);
+        if (offset > dst_len - src_len)
+            return JS_ThrowRangeError(ctx, 'invalid array length');
+        /* copying between typed objects */
+        if (Q.JS_GetClassID(src_p) === Q.JS_GetClassID(p)) {
+            /* same type, use memmove */
+            const dst_view = typed_array_get_view(p);
+            const src_view = typed_array_get_view(src_p);
+            dst_view.set(src_view, offset);
+            return undefined;
+        }
+        /* otherwise, default behavior is slow but correct */
+    }
+    else {
+        src_len = js_get_length64(ctx, src_obj);
+        if (src_len < 0)
+            return JS_EXCEPTION;
+        if (offset > dst_len - src_len)
+            return JS_ThrowRangeError(ctx, 'invalid array length');
+    }
+    for (let i = 0; i < src_len; i++) {
+        const val = JS_GetPropertyUint32(ctx, src_obj, i);
+        if (JS_IsException(val))
+            return JS_EXCEPTION;
+        if (JS_SetPropertyUint32(ctx, dst, offset + i, val) < 0)
+            return JS_EXCEPTION;
+    }
+    return undefined;
+}
+function js_typed_array_at(ctx, this_val, argv) {
+    const p = get_typed_array(ctx, this_val, false);
+    if (!p)
+        return JS_EXCEPTION;
+    if (typed_array_is_detached(ctx, p))
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    const r = JS_ToInt64Sat(ctx, argv[0]);
+    if (JS_IsException(r))
+        return JS_EXCEPTION;
+    let idx = r;
+    const len = typed_array_get_length(ctx, p);
+    if (idx < 0)
+        idx = len + idx;
+    if (idx < 0 || idx >= len)
+        return undefined;
+    return JS_GetPropertyInt64(ctx, this_val, idx);
+}
+function js_typed_array_with(ctx, this_val, argv) {
+    const p = get_typed_array(ctx, this_val, false);
+    if (!p)
+        return JS_EXCEPTION;
+    if (typed_array_is_detached(ctx, p))
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    const r = JS_ToInt64Sat(ctx, argv[0]);
+    if (JS_IsException(r))
+        return JS_EXCEPTION;
+    let idx = r;
+    const len = typed_array_get_length(ctx, p);
+    if (idx < 0)
+        idx = len + idx;
+    const val = JS_ToPrimitive(ctx, argv[1], HINT_NUMBER);
+    if (JS_IsException(val))
+        return JS_EXCEPTION;
+    if (typed_array_is_detached(ctx, p) || idx < 0 || idx >= len)
+        return JS_ThrowRangeError(ctx, 'invalid array index');
+    const arr = js_typed_array_constructor_ta(ctx, undefined, this_val, Q.JS_GetClassID(p));
+    if (JS_IsException(arr))
+        return JS_EXCEPTION;
+    if (JS_SetPropertyInt64(ctx, arr, idx, val) < 0)
+        return JS_EXCEPTION;
+    return arr;
+}
+function js_typed_array_set(ctx, this_val, argv) {
+    let offset = undefined;
+    if (argv.length > 1)
+        offset = argv[1];
+    return js_typed_array_set_internal(ctx, this_val, argv[0], offset);
+}
+/* return < 0 if exception */
+function js_typed_array_get_length_internal(ctx, obj) {
+    const p = get_typed_array(ctx, obj, false);
+    if (!p)
+        return -1;
+    if (typed_array_is_detached(ctx, p)) {
+        JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+        return -1;
+    }
+    if (typed_array_is_oob(ctx, p)) {
+        JS_ThrowTypeErrorArrayBufferOOB(ctx);
+        return -1;
+    }
+    return typed_array_get_length(ctx, p);
+}
+function js_typed_array_create(ctx, ctor, argv) {
+    const ret = JS_CallConstructor(ctx, ctor, argv);
+    if (JS_IsException(ret))
+        return ret;
+    /* validate the typed array */
+    const new_len = js_typed_array_get_length_internal(ctx, ret);
+    if (new_len < 0)
+        return JS_EXCEPTION;
+    if (argv.length === 1) {
+        /* ensure that it is large enough */
+        const len = JS_ToLengthFree(ctx, argv[0]);
+        if (len < 0)
+            return JS_EXCEPTION;
+        if (new_len < len)
+            return JS_ThrowTypeError(ctx, 'TypedArray length is too small');
+    }
+    return ret;
+}
+function js_typed_array___speciesCreate(ctx, this_val, argv) {
+    const obj = argv[0];
+    const p = get_typed_array(ctx, obj, false);
+    if (!p)
+        return JS_EXCEPTION;
+    const ctor = JS_SpeciesConstructor(ctx, obj, undefined);
+    if (JS_IsException(ctor))
+        return ctor;
+    const args1 = argv.slice(1);
+    if (JS_IsUndefined(ctor)) {
+        return js_typed_array_constructor(ctx, undefined, args1, Q.JS_GetClassID(p));
+    }
+    return js_typed_array_create(ctx, ctor, args1);
+}
+function js_array_from_iterator(ctx, obj, method) {
+    const arr = JS_NewArray(ctx);
+    if (JS_IsException(arr))
+        return null;
+    const iter = JS_GetIterator2(ctx, obj, method);
+    if (JS_IsException(iter))
+        return null;
+    const next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
+    if (JS_IsException(next_method))
+        return null;
+    let k = 0;
+    const pdone = { done: 0 };
+    for (;;) {
+        const val = JS_IteratorNext(ctx, iter, next_method, [], pdone);
+        if (JS_IsException(val))
+            return null;
+        if (pdone.done)
+            break;
+        if (JS_CreateDataPropertyUint32(ctx, arr, k, val, JS_PROP_THROW) < 0)
+            return null;
+        k++;
+    }
+    return { arr, len: k };
+}
+function js_typed_array_from(ctx, this_val, argv) {
+    // from(items, mapfn = void 0, this_arg = void 0)
+    const items = argv[0];
+    let mapfn = undefined, this_arg = undefined;
+    let mapping = false;
+    if (argv.length > 1) {
+        mapfn = argv[1];
+        if (!JS_IsUndefined(mapfn)) {
+            if (check_function(ctx, mapfn))
+                return JS_EXCEPTION;
+            mapping = true;
+            if (argv.length > 2)
+                this_arg = argv[2];
+        }
+    }
+    const iter = JS_GetProperty(ctx, items, JS_ATOM_Symbol_iterator);
+    if (JS_IsException(iter))
+        return JS_EXCEPTION;
+    let arr;
+    let len;
+    if (!JS_IsUndefined(iter) && !JS_IsNull(iter)) {
+        if (!JS_IsFunction(ctx, iter))
+            return JS_ThrowTypeError(ctx, 'value is not iterable');
+        const r = js_array_from_iterator(ctx, items, iter);
+        if (!r)
+            return JS_EXCEPTION;
+        arr = r.arr;
+        len = r.len;
+    }
+    else {
+        arr = JS_ToObject(ctx, items);
+        if (JS_IsException(arr))
+            return JS_EXCEPTION;
+        len = js_get_length64(ctx, arr);
+        if (len < 0)
+            return JS_EXCEPTION;
+    }
+    const r = js_typed_array_create(ctx, this_val, [len]);
+    if (JS_IsException(r))
+        return JS_EXCEPTION;
+    for (let k = 0; k < len; k++) {
+        let v = JS_GetPropertyInt64(ctx, arr, k);
+        if (JS_IsException(v))
+            return JS_EXCEPTION;
+        if (mapping) {
+            v = JS_Call(ctx, mapfn, this_arg, [v, k]);
+            if (JS_IsException(v))
+                return JS_EXCEPTION;
+        }
+        if (JS_SetPropertyInt64(ctx, r, k, v) < 0)
+            return JS_EXCEPTION;
+    }
+    return r;
+}
+function js_typed_array_of(ctx, this_val, argv) {
+    const obj = js_typed_array_create(ctx, this_val, [argv.length]);
+    if (JS_IsException(obj))
+        return obj;
+    for (let i = 0; i < argv.length; i++) {
+        if (JS_SetPropertyUint32(ctx, obj, i, argv[i]) < 0)
+            return JS_EXCEPTION;
+    }
+    return obj;
+}
+function js_typed_array_copyWithin(ctx, this_val, argv) {
+    const len = js_typed_array_get_length_internal(ctx, this_val);
+    if (len < 0)
+        return JS_EXCEPTION;
+    const to = JS_ToInt32Clamp(ctx, argv[0], 0, len, len);
+    if (JS_IsException(to))
+        return JS_EXCEPTION;
+    const from = JS_ToInt32Clamp(ctx, argv[1], 0, len, len);
+    if (JS_IsException(from))
+        return JS_EXCEPTION;
+    let final = len;
+    if (argv.length > 2 && !JS_IsUndefined(argv[2])) {
+        final = JS_ToInt32Clamp(ctx, argv[2], 0, len, len);
+        if (JS_IsException(final))
+            return JS_EXCEPTION;
+    }
+    const count = Math.min(final - from, len - to);
+    if (count > 0) {
+        const p = this_val;
+        if (typed_array_is_detached(ctx, p))
+            return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+        const view = typed_array_get_view(p);
+        if (view) {
+            /* the buffer may have been resized */
+            const cur_len = view.length;
+            const cnt = Math.min(count, cur_len - from, cur_len - to);
+            if (cnt > 0)
+                view.copyWithin(to, from, from + cnt);
+        }
+    }
+    return this_val;
+}
+function js_typed_array_fill(ctx, this_val, argv) {
+    const len = js_typed_array_get_length_internal(ctx, this_val);
+    if (len < 0)
+        return JS_EXCEPTION;
+    const p = this_val;
+    const v = typed_array_convert_value(ctx, Q.JS_GetClassID(p), argv[0]);
+    if (JS_IsException(v))
+        return JS_EXCEPTION;
+    let k = 0;
+    if (argv.length > 1) {
+        k = JS_ToInt32Clamp(ctx, argv[1], 0, len, len);
+        if (JS_IsException(k))
+            return JS_EXCEPTION;
+    }
+    let final = len;
+    if (argv.length > 2 && !JS_IsUndefined(argv[2])) {
+        final = JS_ToInt32Clamp(ctx, argv[2], 0, len, len);
+        if (JS_IsException(final))
+            return JS_EXCEPTION;
+    }
+    if (typed_array_is_detached(ctx, p))
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    const view = typed_array_get_view(p);
+    if (view) {
+        /* RAB may have been resized by evil .valueOf method */
+        const end = Math.min(final, view.length);
+        if (k < end)
+            view.fill(v, k, end);
+    }
+    return this_val;
+}
+function js_typed_array_find(ctx, this_val, argv, mode) {
+    const len = js_typed_array_get_length_internal(ctx, this_val);
+    if (len < 0)
+        return JS_EXCEPTION;
+    const func = argv[0];
+    if (check_function(ctx, func))
+        return JS_EXCEPTION;
+    let this_arg = undefined;
+    if (argv.length > 1)
+        this_arg = argv[1];
+    let k = 0, dir = 1, end = len;
+    if (mode === 2 /* ArrayFindMode.ArrayFindLast */ || mode === 3 /* ArrayFindMode.ArrayFindLastIndex */) {
+        k = len - 1;
+        dir = -1;
+        end = -1;
+    }
+    for (; k !== end; k += dir) {
+        const index_val = k;
+        const val = JS_GetPropertyValue(ctx, this_val, index_val);
+        if (JS_IsException(val))
+            return JS_EXCEPTION;
+        const res = JS_Call(ctx, func, this_arg, [val, index_val, this_val]);
+        if (JS_IsException(res))
+            return JS_EXCEPTION;
+        if (JS_ToBoolFree(ctx, res)) {
+            if (mode === 1 /* ArrayFindMode.ArrayFindIndex */ || mode === 3 /* ArrayFindMode.ArrayFindLastIndex */)
+                return index_val;
+            return val;
+        }
+    }
+    if (mode === 1 /* ArrayFindMode.ArrayFindIndex */ || mode === 3 /* ArrayFindMode.ArrayFindLastIndex */)
+        return -1;
+    return undefined;
+}
+const special_indexOf = 0;
+const special_lastIndexOf = 1;
+const special_includes = -1;
+/* value range of the integer typed arrays */
+const int_ranges = [
+    [0, 255], [-128, 127], [0, 255], [-32768, 32767], [0, 65535], [-2147483648, 2147483647], [0, 4294967295],
+];
+function js_typed_array_indexOf(ctx, this_val, argv, special) {
+    let res = -1;
+    const len = js_typed_array_get_length_internal(ctx, this_val);
+    if (len < 0)
+        return JS_EXCEPTION;
+    const done = () => special === special_includes ? res >= 0 : res;
+    if (len === 0)
+        return done();
+    let k, stop, inc;
+    if (special === special_lastIndexOf) {
+        k = len - 1;
+        if (argv.length > 1) {
+            const r = JS_ToFloat64(ctx, argv[1]);
+            if (JS_IsException(r))
+                return JS_EXCEPTION;
+            let d = r;
+            if (Number.isNaN(d)) {
+                k = 0;
+            }
+            else {
+                if (d >= 0) {
+                    if (d < k)
+                        k = Math.trunc(d);
+                }
+                else {
+                    d += len;
+                    if (d < 0)
+                        return done();
+                    k = Math.trunc(d);
+                }
+            }
+        }
+        stop = -1;
+        inc = -1;
+    }
+    else {
+        k = 0;
+        if (argv.length > 1) {
+            const r = JS_ToInt32Clamp(ctx, argv[1], 0, len, len);
+            if (JS_IsException(r))
+                return JS_EXCEPTION;
+            k = r;
+        }
+        stop = len;
+        inc = 1;
+    }
+    const p = this_val;
+    /* if the array was detached, no need to go further (but no
+       exception is raised) */
+    if (typed_array_is_detached(ctx, p) || typed_array_is_oob(ctx, p)) {
+        /* "includes" scans all the properties, so "undefined" can match */
+        if (special === special_includes && JS_IsUndefined(argv[0]) && len > 0)
+            res = 0;
+        return done();
+    }
+    const view = typed_array_get_view(p);
+    /* the buffer may have been resized: only scan the current elements */
+    if (view.length < len) {
+        if (inc > 0)
+            stop = view.length;
+        else if (k >= view.length)
+            k = view.length - 1;
+    }
+    const arg = argv[0];
+    let is_int = false, is_bigint = false;
+    let d = 0;
+    let v64 = 0n;
+    if (typeof arg === 'number') {
+        d = arg;
+        if (d >= -9223372036854775808 && d < 9223372036854775808 && Number.isInteger(d))
+            is_int = true;
+    }
+    else if (typeof arg === 'bigint') {
+        if (Q.JS_GetClassID(p) === 28 /* JSClassID.BIG_INT64_ARRAY */) {
+            if (arg < -(1n << 63n) || arg >= (1n << 63n))
+                return done(); /* does not fit an int64 : cannot be found */
+        }
+        else if (Q.JS_GetClassID(p) === 29 /* JSClassID.BIG_UINT64_ARRAY */) {
+            if (arg < 0n || arg >= (1n << 64n))
+                return done();
+        }
+        else {
+            return done();
+        }
+        v64 = arg;
+        is_bigint = true;
+    }
+    else {
+        return done();
+    }
+    const scan = (v) => {
+        for (; k !== stop; k += inc) {
+            if (view[k] === v) {
+                res = k;
+                break;
+            }
+        }
+    };
+    switch (Q.JS_GetClassID(p)) {
+        case 22 /* JSClassID.INT8_ARRAY */:
+        case 21 /* JSClassID.UINT8C_ARRAY */:
+        case 23 /* JSClassID.UINT8_ARRAY */:
+        case 24 /* JSClassID.INT16_ARRAY */:
+        case 25 /* JSClassID.UINT16_ARRAY */:
+        case 26 /* JSClassID.INT32_ARRAY */:
+        case 27 /* JSClassID.UINT32_ARRAY */: {
+            const [min, max] = int_ranges[Q.JS_GetClassID(p) - 21 /* JSClassID.UINT8C_ARRAY */];
+            if (is_int && d >= min && d <= max)
+                scan(d);
+            break;
+        }
+        case 30 /* JSClassID.FLOAT32_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 (Math.fround(d) === d) {
+                scan(d);
+            }
+            break;
+        case 31 /* JSClassID.FLOAT64_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 {
+                scan(d);
+            }
+            break;
+        case 28 /* JSClassID.BIG_INT64_ARRAY */:
+        case 29 /* JSClassID.BIG_UINT64_ARRAY */:
+            if (is_bigint)
+                scan(v64);
+            break;
+    }
+    return done();
+}
+function JS_ToLocaleStringFree(ctx, val) {
+    if (JS_IsUndefined(val) || JS_IsNull(val))
+        return JS_ToString(ctx, val);
+    return JS_Invoke(ctx, val, JS_ATOM_toLocaleString, []);
+}
+function js_typed_array_join(ctx, this_val, argv, toLocaleString) {
+    const n = js_typed_array_get_length_internal(ctx, this_val);
+    if (n < 0)
+        return JS_EXCEPTION;
+    let sep = ','; /* default separator */
+    if (!toLocaleString && argv.length > 0 && !JS_IsUndefined(argv[0])) {
+        const s = JS_ToString(ctx, argv[0]);
+        if (JS_IsException(s))
+            return JS_EXCEPTION;
+        sep = s;
+    }
+    let b = '';
+    /* XXX: optimize with direct access */
+    for (let i = 0; i < n; i++) {
+        if (i > 0)
+            b += sep;
+        let el = JS_GetPropertyUint32(ctx, this_val, i);
+        /* Can return undefined for example if the typed array is detached */
+        if (!JS_IsNull(el) && !JS_IsUndefined(el)) {
+            if (JS_IsException(el))
+                return JS_EXCEPTION;
+            if (toLocaleString) {
+                el = JS_ToLocaleStringFree(ctx, el);
+                if (JS_IsException(el))
+                    return JS_EXCEPTION;
+            }
+            const s = JS_ToString(ctx, el);
+            if (JS_IsException(s))
+                return JS_EXCEPTION;
+            b += s;
+        }
+    }
+    return b;
+}
+function js_typed_array_reverse(ctx, this_val, argv) {
+    const len = js_typed_array_get_length_internal(ctx, this_val);
+    if (len < 0)
+        return JS_EXCEPTION;
+    if (len > 0) {
+        const view = typed_array_get_view(this_val);
+        if (view)
+            view.reverse();
+    }
+    return this_val;
+}
+function js_typed_array_toReversed(ctx, this_val, argv) {
+    const p = get_typed_array(ctx, this_val, false);
+    if (!p)
+        return JS_EXCEPTION;
+    const arr = js_typed_array_constructor_ta(ctx, undefined, this_val, Q.JS_GetClassID(p));
+    if (JS_IsException(arr))
+        return JS_EXCEPTION;
+    return js_typed_array_reverse(ctx, arr, argv);
+}
+/* copy 'len' bytes; the spec mandates a byte copy when the regions overlap */
+function slice_memcpy(dst, dst_pos, src, src_pos, len) {
+    if (dst.buffer !== src.buffer) {
+        dst.set(src.subarray(src_pos, src_pos + len), dst_pos);
+    }
+    else {
+        const d0 = dst.byteOffset + dst_pos, s0 = src.byteOffset + src_pos;
+        if (d0 + len <= s0 || d0 >= s0 + len) {
+            dst.set(src.subarray(src_pos, src_pos + len), dst_pos);
+        }
+        else {
+            for (let i = 0; i < len; i++)
+                dst[dst_pos + i] = src[src_pos + i];
+        }
+    }
+}
+function js_typed_array_slice(ctx, this_val, argv) {
+    const len = js_typed_array_get_length_internal(ctx, this_val);
+    if (len < 0)
+        return JS_EXCEPTION;
+    const start = JS_ToInt32Clamp(ctx, argv[0], 0, len, len);
+    if (JS_IsException(start))
+        return JS_EXCEPTION;
+    let final = len;
+    if (!JS_IsUndefined(argv[1])) {
+        final = JS_ToInt32Clamp(ctx, argv[1], 0, len, len);
+        if (JS_IsException(final))
+            return JS_EXCEPTION;
+    }
+    const count = Math.max(final - start, 0);
+    const p = get_typed_array(ctx, this_val, false);
+    if (!p)
+        return JS_EXCEPTION;
+    const shift = typed_array_size_log2(Q.JS_GetClassID(p));
+    const arr = js_typed_array___speciesCreate(ctx, undefined, [this_val, count]);
+    if (JS_IsException(arr))
+        return JS_EXCEPTION;
+    if (count > 0) {
+        if (validate_typed_array(ctx, this_val) || validate_typed_array(ctx, arr))
+            return JS_EXCEPTION;
+        const p1 = get_typed_array(ctx, arr, false);
+        if (p1 !== null && Q.JS_GetClassID(p) === Q.JS_GetClassID(p1) &&
+            typed_array_get_length(ctx, p1) >= count &&
+            typed_array_get_length(ctx, p) >= start + count) {
+            const ta = Q.JS_GetAnyOpaque(p), ta1 = Q.JS_GetAnyOpaque(p1);
+            const src = Q.JS_GetAnyOpaque(ta.buffer).data, dst = Q.JS_GetAnyOpaque(ta1.buffer).data;
+            slice_memcpy(dst, ta1.offset, src, ta.offset + (start << shift), count << shift);
+        }
+        else {
+            for (let n = 0; n < count; n++) {
+                const val = JS_GetPropertyValue(ctx, this_val, start + n);
+                if (JS_IsException(val))
+                    return JS_EXCEPTION;
+                if (JS_SetPropertyValue(ctx, arr, n, val, JS_PROP_THROW) < 0)
+                    return JS_EXCEPTION;
+            }
+        }
+    }
+    return arr;
+}
+function js_typed_array_subarray(ctx, this_val, argv) {
+    const p = get_typed_array(ctx, this_val, false);
+    if (!p)
+        return JS_EXCEPTION;
+    const len = typed_array_get_length(ctx, p);
+    const start = JS_ToInt32Clamp(ctx, argv[0], 0, len, len);
+    if (JS_IsException(start))
+        return JS_EXCEPTION;
+    let final = len;
+    if (!JS_IsUndefined(argv[1])) {
+        final = JS_ToInt32Clamp(ctx, argv[1], 0, len, len);
+        if (JS_IsException(final))
+            return JS_EXCEPTION;
+    }
+    const count = Math.max(final - start, 0);
+    const byteOffset = js_typed_array_get_byteOffset(ctx, this_val, 0);
+    if (JS_IsException(byteOffset))
+        return JS_EXCEPTION;
+    const shift = typed_array_size_log2(Q.JS_GetClassID(p));
+    const offset = byteOffset + (start << shift);
+    const ta_buffer = js_typed_array_get_buffer(ctx, this_val, 0);
+    if (JS_IsException(ta_buffer))
+        return JS_EXCEPTION;
+    const ta = Q.JS_GetAnyOpaque(p);
+    if (ta.track_rab && JS_IsUndefined(argv[1])) {
+        /* length tracking subarray of a length tracking array */
+        return js_typed_array___speciesCreate(ctx, undefined, [this_val, ta_buffer, offset]);
+    }
+    return js_typed_array___speciesCreate(ctx, undefined, [this_val, ta_buffer, offset, count]);
+}
+/* TypedArray.prototype.sort */
+function js_cmp_doubles(x, y) {
+    if (Number.isNaN(x))
+        return Number.isNaN(y) ? 0 : +1;
+    if (Number.isNaN(y))
+        return -1;
+    if (x < y)
+        return -1;
+    if (x > y)
+        return 1;
+    if (x !== 0)
+        return 0;
+    if (1 / x < 0)
+        return 1 / y < 0 ? 0 : -1;
+    return 1 / y < 0 ? 1 : 0;
+}
+function js_TA_cmp_default(a, b) {
+    if (typeof a === 'bigint')
+        return a < b ? -1 : a > b ? 1 : 0;
+    return js_cmp_doubles(a, b);
+}
+/* stable merge sort of an index array */
+function merge_sort_indices(idx, cmp) {
+    const n = idx.length;
+    let src = idx, dst = new Array(n);
+    for (let width = 1; width < n; width *= 2) {
+        for (let i = 0; i < n; i += 2 * width) {
+            let l = i, r = Math.min(i + width, n);
+            const lend = r, rend = Math.min(i + 2 * width, n);
+            let k = i;
+            while (l < lend && r < rend) {
+                if (cmp(src[l], src[r]) <= 0)
+                    dst[k++] = src[l++];
+                else
+                    dst[k++] = src[r++];
+            }
+            while (l < lend)
+                dst[k++] = src[l++];
+            while (r < rend)
+                dst[k++] = src[r++];
+        }
+        const t = src;
+        src = dst;
+        dst = t;
+    }
+    return src;
+}
+function js_typed_array_sort(ctx, this_val, argv) {
+    const cmp = argv[0];
+    if (!JS_IsUndefined(cmp) && check_function(ctx, cmp))
+        return JS_EXCEPTION;
+    const len = js_typed_array_get_length_internal(ctx, this_val);
+    if (len < 0)
+        return JS_EXCEPTION;
+    if (len > 1) {
+        const p = this_val;
+        const view = typed_array_get_view(p);
+        const vals = new Array(len);
+        for (let i = 0; i < len; i++)
+            vals[i] = view[i];
+        if (!JS_IsUndefined(cmp)) {
+            let exception = 0;
+            const idx = new Array(len);
+            for (let i = 0; i < len; i++)
+                idx[i] = i;
+            const sorted = merge_sort_indices(idx, (a, b) => {
+                if (exception)
+                    return 0;
+                const res = JS_Call(ctx, cmp, undefined, [vals[a], vals[b]]);
+                if (JS_IsException(res)) {
+                    exception = 1;
+                    return 0;
+                }
+                const d = JS_ToFloat64(ctx, res);
+                if (JS_IsException(d)) {
+                    exception = 1;
+                    return 0;
+                }
+                let v = d;
+                if (Number.isNaN(v))
+                    v = 0;
+                /* make sort stable: compare array offsets */
+                if (v === 0)
+                    return a - b;
+                return v < 0 ? -1 : 1;
+            });
+            if (exception)
+                return JS_EXCEPTION;
+            /* the array may have been detached or resized during the sort: no error */
+            const view1 = typed_array_get_view(p);
+            if (view1) {
+                const n = Math.min(len, view1.length);
+                for (let i = 0; i < n; i++)
+                    view1[i] = vals[sorted[i]];
+            }
+        }
+        else {
+            const idx = new Array(len);
+            for (let i = 0; i < len; i++)
+                idx[i] = i;
+            const sorted = merge_sort_indices(idx, (a, b) => js_TA_cmp_default(vals[a], vals[b]));
+            for (let i = 0; i < len; i++)
+                view[i] = vals[sorted[i]];
+        }
+    }
+    return this_val;
+}
+function js_typed_array_toSorted(ctx, this_val, argv) {
+    const p = get_typed_array(ctx, this_val, false);
+    if (!p)
+        return JS_EXCEPTION;
+    const arr = js_typed_array_constructor_ta(ctx, undefined, this_val, Q.JS_GetClassID(p));
+    if (JS_IsException(arr))
+        return JS_EXCEPTION;
+    return js_typed_array_sort(ctx, arr, argv);
+}
+/* every/some/forEach/map/filter (typed array variants of js_array_every) */
+const special_every = 0;
+const special_some = 1;
+const special_forEach = 2;
+const special_map = 3;
+const special_filter = 4;
+const special_TA = 8;
+function js_array_every(ctx, this_val, argv, special) {
+    const obj = this_val;
+    const len = js_typed_array_get_length_internal(ctx, obj);
+    if (len < 0)
+        return JS_EXCEPTION;
+    const func = argv[0];
+    let this_arg = undefined;
+    if (argv.length > 1)
+        this_arg = argv[1];
+    if (check_function(ctx, func))
+        return JS_EXCEPTION;
+    let ret = undefined;
+    switch (special) {
+        case special_every | special_TA:
+            ret = true;
+            break;
+        case special_some | special_TA:
+            ret = false;
+            break;
+        case special_map | special_TA:
+            ret = js_typed_array___speciesCreate(ctx, undefined, [obj, len]);
+            if (JS_IsException(ret))
+                return JS_EXCEPTION;
+            break;
+        case special_filter | special_TA:
+            ret = JS_NewArray(ctx);
+            if (JS_IsException(ret))
+                return JS_EXCEPTION;
+            break;
+    }
+    let n = 0;
+    let k;
+    loop: for (k = 0; k < len; k++) {
+        const val = JS_GetPropertyInt64(ctx, obj, k);
+        if (JS_IsException(val))
+            return JS_EXCEPTION;
+        const res = JS_Call(ctx, func, this_arg, [val, k, obj]);
+        if (JS_IsException(res))
+            return JS_EXCEPTION;
+        switch (special) {
+            case special_every | special_TA:
+                if (!JS_ToBoolFree(ctx, res)) {
+                    ret = false;
+                    break loop;
+                }
+                break;
+            case special_some | special_TA:
+                if (JS_ToBoolFree(ctx, res)) {
+                    ret = true;
+                    break loop;
+                }
+                break;
+            case special_map | special_TA:
+                if (JS_SetPropertyValue(ctx, ret, k, res, JS_PROP_THROW) < 0)
+                    return JS_EXCEPTION;
+                break;
+            case special_filter | special_TA:
+                if (JS_ToBoolFree(ctx, res)) {
+                    if (JS_DefinePropertyValueInt64(ctx, ret, n++, val, JS_PROP_C_W_E | JS_PROP_THROW) < 0)
+                        return JS_EXCEPTION;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    if (special === (special_filter | special_TA)) {
+        const arr = js_typed_array___speciesCreate(ctx, undefined, [obj, n]);
+        if (JS_IsException(arr))
+            return JS_EXCEPTION;
+        const res = JS_Invoke(ctx, arr, JS_ATOM_set, [ret]);
+        if (JS_IsException(res))
+            return JS_EXCEPTION;
+        ret = arr;
+    }
+    return ret;
+}
+const special_reduce = 0;
+const special_reduceRight = 1;
+function js_array_reduce(ctx, this_val, argv, special) {
+    const obj = this_val;
+    const len = js_typed_array_get_length_internal(ctx, obj);
+    if (len < 0)
+        return JS_EXCEPTION;
+    const func = argv[0];
+    if (check_function(ctx, func))
+        return JS_EXCEPTION;
+    let k = 0;
+    let acc;
+    if (argv.length > 1) {
+        acc = argv[1];
+    }
+    else {
+        if (k >= len)
+            return JS_ThrowTypeError(ctx, 'empty array');
+        const k1 = (special & special_reduceRight) ? len - k - 1 : k;
+        k++;
+        acc = JS_GetPropertyInt64(ctx, obj, k1);
+        if (JS_IsException(acc))
+            return JS_EXCEPTION;
+    }
+    for (; k < len; k++) {
+        const k1 = (special & special_reduceRight) ? len - k - 1 : k;
+        const val = JS_GetPropertyInt64(ctx, obj, k1);
+        if (JS_IsException(val))
+            return JS_EXCEPTION;
+        const acc1 = JS_Call(ctx, func, undefined, [acc, val, k1, obj]);
+        if (JS_IsException(acc1))
+            return JS_EXCEPTION;
+        acc = acc1;
+    }
+    return acc;
+}
+/* fallback Array.prototype.toString (used if the Array builtins are not
+   installed yet): port of js_array_toString */
+function js_array_toString(ctx, this_val, argv) {
+    const obj = JS_ToObject(ctx, this_val);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    const method = JS_GetProperty(ctx, obj, JS_ATOM_join);
+    if (JS_IsException(method))
+        return JS_EXCEPTION;
+    if (!JS_IsFunction(ctx, method)) {
+        /* Use intrinsic Object.prototype.toString */
+        const objproto = ctx.class_proto[1 /* JSClassID.OBJECT */];
+        const ts = objproto ? JS_GetProperty(ctx, objproto, JS_ATOM_toString) : undefined;
+        if (JS_IsException(ts))
+            return JS_EXCEPTION;
+        if (JS_IsFunction(ctx, ts))
+            return JS_Call(ctx, ts, obj, []);
+        return '[object Object]';
+    }
+    return JS_Call(ctx, method, obj, []);
+}
+const js_typed_array_base_funcs = [
+    JS_CFUNC_DEF('from', 1, js_typed_array_from),
+    JS_CFUNC_DEF('of', 0, js_typed_array_of),
+    JS_CGETSET_DEF(JS_ATOM_Symbol_species, js_get_this, null),
+];
+const js_typed_array_base_proto_funcs = [
+    JS_CGETSET_DEF(JS_ATOM_length, js_typed_array_get_length, null),
+    JS_CFUNC_DEF('at', 1, js_typed_array_at),
+    JS_CFUNC_DEF('with', 2, js_typed_array_with),
+    JS_CGETSET_MAGIC_DEF('buffer', js_typed_array_get_buffer, null, 0),
+    JS_CGETSET_MAGIC_DEF('byteLength', js_typed_array_get_byteLength, null, 0),
+    JS_CGETSET_MAGIC_DEF('byteOffset', js_typed_array_get_byteOffset, null, 0),
+    JS_CFUNC_DEF('set', 1, js_typed_array_set),
+    /* typed arrays are host typed arrays: the host iterators are used, with
+       the guest Array Iterator prototype */
+    JS_NATIVE_DEF('values', 0, HOST_TYPED_ARRAY_PROTO.values, fix_array_iterator),
+    JS_ALIAS_DEF(JS_ATOM_Symbol_iterator, 'values'),
+    JS_NATIVE_DEF('keys', 0, HOST_TYPED_ARRAY_PROTO.keys, fix_array_iterator),
+    JS_NATIVE_DEF('entries', 0, HOST_TYPED_ARRAY_PROTO.entries, fix_array_iterator),
+    JS_CGETSET_DEF(JS_ATOM_Symbol_toStringTag, js_typed_array_get_toStringTag, null),
+    JS_CFUNC_DEF('copyWithin', 2, js_typed_array_copyWithin),
+    JS_CFUNC_MAGIC_DEF('every', 1, js_array_every, special_every | special_TA),
+    JS_CFUNC_MAGIC_DEF('some', 1, js_array_every, special_some | special_TA),
+    JS_CFUNC_MAGIC_DEF('forEach', 1, js_array_every, special_forEach | special_TA),
+    JS_CFUNC_MAGIC_DEF('map', 1, js_array_every, special_map | special_TA),
+    JS_CFUNC_MAGIC_DEF('filter', 1, js_array_every, special_filter | special_TA),
+    JS_CFUNC_MAGIC_DEF('reduce', 1, js_array_reduce, special_reduce | special_TA),
+    JS_CFUNC_MAGIC_DEF('reduceRight', 1, js_array_reduce, special_reduceRight | special_TA),
+    JS_CFUNC_DEF('fill', 1, js_typed_array_fill),
+    JS_CFUNC_MAGIC_DEF('find', 1, js_typed_array_find, 0 /* ArrayFindMode.ArrayFind */),
+    JS_CFUNC_MAGIC_DEF('findIndex', 1, js_typed_array_find, 1 /* ArrayFindMode.ArrayFindIndex */),
+    JS_CFUNC_MAGIC_DEF('findLast', 1, js_typed_array_find, 2 /* ArrayFindMode.ArrayFindLast */),
+    JS_CFUNC_MAGIC_DEF('findLastIndex', 1, js_typed_array_find, 3 /* ArrayFindMode.ArrayFindLastIndex */),
+    JS_CFUNC_DEF('reverse', 0, js_typed_array_reverse),
+    JS_CFUNC_DEF('toReversed', 0, js_typed_array_toReversed),
+    JS_CFUNC_DEF('slice', 2, js_typed_array_slice),
+    JS_CFUNC_DEF('subarray', 2, js_typed_array_subarray),
+    JS_CFUNC_DEF('sort', 1, js_typed_array_sort),
+    JS_CFUNC_DEF('toSorted', 1, js_typed_array_toSorted),
+    JS_CFUNC_MAGIC_DEF('join', 1, js_typed_array_join, 0),
+    JS_CFUNC_MAGIC_DEF('toLocaleString', 0, js_typed_array_join, 1),
+    JS_CFUNC_MAGIC_DEF('indexOf', 1, js_typed_array_indexOf, special_indexOf),
+    JS_CFUNC_MAGIC_DEF('lastIndexOf', 1, js_typed_array_indexOf, special_lastIndexOf),
+    JS_CFUNC_MAGIC_DEF('includes', 1, js_typed_array_indexOf, special_includes),
+];
+function js_typed_array_base_constructor(ctx, this_val, argv) {
+    return JS_ThrowTypeError(ctx, 'cannot be called');
+}
+/* 'obj' is the allocated placeholder object (its prototype and class are
+   used). Returns the guest typed array object: a host typed array over
+   the buffer, re-prototyped, carrying the metadata. */
+function typed_array_init(ctx, obj, buffer, offset, len, track_rab) {
+    const class_id = Q.JS_GetClassID(obj);
+    const size_log2 = typed_array_size_log2(class_id);
+    const ta = new JSTypedArray(buffer, offset, len << size_log2);
+    ta.track_rab = track_rab;
+    const abuf = Q.JS_GetAnyOpaque(buffer);
+    const ctor = host_ta_ctors[class_id - 21 /* JSClassID.UINT8C_ARRAY */];
+    let view;
+    try {
+        view = track_rab ? new ctor(abuf.buffer, offset) : new ctor(abuf.buffer, offset, len);
+    }
+    catch (e) {
+        return Q.js_host_exception_to_guest(ctx, e);
+    }
+    return host_view_adopt(ctx, obj, view, ta);
+}
+/* move the class metadata of the placeholder 'obj' to the host view */
+function host_view_adopt(ctx, obj, view, ta) {
+    Object.setPrototypeOf(view, Reflect.getPrototypeOf(obj));
+    const m = Q.js_meta.get(obj);
+    m.u = ta;
+    Q.js_meta.set(view, m);
+    Q.js_meta.delete(obj);
+    return view;
+}
+function js_typed_array_constructor_obj(ctx, new_target, obj, classid) {
+    const size_log2 = typed_array_size_log2(classid);
+    let ret = js_create_from_ctor(ctx, new_target, classid);
+    if (JS_IsException(ret))
+        return JS_EXCEPTION;
+    const iter = JS_GetProperty(ctx, obj, JS_ATOM_Symbol_iterator);
+    if (JS_IsException(iter))
+        return JS_EXCEPTION;
+    let arr;
+    let len;
+    if (!JS_IsUndefined(iter) && !JS_IsNull(iter)) {
+        const r = js_array_from_iterator(ctx, obj, iter);
+        if (!r)
+            return JS_EXCEPTION;
+        arr = r.arr;
+        len = r.len;
+    }
+    else {
+        len = js_get_length64(ctx, obj);
+        if (len < 0)
+            return JS_EXCEPTION;
+        arr = obj;
+    }
+    const buffer = js_array_buffer_constructor1(ctx, undefined, len << size_log2);
+    if (JS_IsException(buffer))
+        return JS_EXCEPTION;
+    ret = typed_array_init(ctx, ret, buffer, 0, len, false);
+    if (JS_IsException(ret))
+        return JS_EXCEPTION;
+    for (let i = 0; i < len; i++) {
+        const val = JS_GetPropertyUint32(ctx, arr, i);
+        if (JS_IsException(val))
+            return JS_EXCEPTION;
+        if (JS_SetPropertyUint32(ctx, ret, i, val) < 0)
+            return JS_EXCEPTION;
+    }
+    return ret;
+}
+function js_typed_array_constructor_ta(ctx, new_target, src_obj, classid) {
+    let obj = js_create_from_ctor(ctx, new_target, classid);
+    if (JS_IsException(obj))
+        return obj;
+    const p = src_obj;
+    if (typed_array_is_detached(ctx, p))
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    if (typed_array_is_oob(ctx, p))
+        return JS_ThrowTypeErrorArrayBufferOOB(ctx);
+    const ta = Q.JS_GetAnyOpaque(p);
+    const len = typed_array_get_length(ctx, p);
+    const src_abuf = Q.JS_GetAnyOpaque(ta.buffer);
+    const size_log2 = typed_array_size_log2(classid);
+    const buffer = js_array_buffer_constructor1(ctx, undefined, len << size_log2);
+    if (JS_IsException(buffer))
+        return JS_EXCEPTION;
+    /* necessary because it could have been detached */
+    if (typed_array_is_detached(ctx, p))
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    const abuf = Q.JS_GetAnyOpaque(buffer);
+    obj = typed_array_init(ctx, obj, buffer, 0, len, false);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    if (Q.JS_GetClassID(p) === classid) {
+        /* same type: copy the content */
+        abuf.data.set(src_abuf.data.subarray(ta.offset, ta.offset + abuf.data.length));
+    }
+    else {
+        for (let i = 0; i < len; i++) {
+            const val = JS_GetPropertyUint32(ctx, src_obj, i);
+            if (JS_IsException(val))
+                return JS_EXCEPTION;
+            if (JS_SetPropertyUint32(ctx, obj, i, val) < 0)
+                return JS_EXCEPTION;
+        }
+    }
+    return obj;
+}
+function js_typed_array_constructor(ctx, new_target, argv, classid) {
+    const size_log2 = typed_array_size_log2(classid);
+    let buffer;
+    let len, offset;
+    let track_rab = false;
+    const arg0 = argv[0];
+    if (!Q.JS_IsObject(arg0)) {
+        len = JS_ToIndex(ctx, arg0);
+        if (len < 0)
+            return JS_EXCEPTION;
+        buffer = js_array_buffer_constructor1(ctx, undefined, len << size_log2);
+        if (JS_IsException(buffer))
+            return JS_EXCEPTION;
+        offset = 0;
+    }
+    else {
+        const p = arg0;
+        if (Q.JS_GetClassID(p) === 19 /* JSClassID.ARRAY_BUFFER */ || Q.JS_GetClassID(p) === 20 /* JSClassID.SHARED_ARRAY_BUFFER */) {
+            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)
+                return JS_ThrowRangeError(ctx, 'invalid offset');
+            if (JS_IsUndefined(argv[2])) {
+                if (array_buffer_is_resizable(abuf)) {
+                    track_rab = true;
+                    len = (abuf.data.length - offset) >> size_log2;
+                }
+                else {
+                    if ((abuf.data.length & ((1 << size_log2) - 1)) !== 0)
+                        return JS_ThrowRangeError(ctx, 'invalid length');
+                    len = (abuf.data.length - offset) >> size_log2;
+                }
+            }
+            else {
+                len = JS_ToIndex(ctx, argv[2]);
+                if (len < 0)
+                    return JS_EXCEPTION;
+                if (abuf.detached)
+                    return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+                if ((offset + (len << size_log2)) > abuf.data.length)
+                    return JS_ThrowRangeError(ctx, 'invalid length');
+            }
+            buffer = arg0;
+        }
+        else {
+            if (is_typed_array_class(Q.JS_GetClassID(p))) {
+                return js_typed_array_constructor_ta(ctx, new_target, arg0, classid);
+            }
+            else {
+                return js_typed_array_constructor_obj(ctx, new_target, arg0, 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);
+}
+/* ---------------------------------------------------------------------
+   DataView
+   --------------------------------------------------------------------- */
+function js_dataview_constructor(ctx, new_target, argv) {
+    const buffer = argv[0];
+    const abuf = js_get_array_buffer(ctx, buffer);
+    if (!abuf)
+        return JS_EXCEPTION;
+    let offset = 0;
+    if (argv.length > 1) {
+        offset = JS_ToIndex(ctx, argv[1]);
+        if (offset < 0)
+            return JS_EXCEPTION;
+    }
+    if (abuf.detached)
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    if (offset > abuf.data.length)
+        return JS_ThrowRangeError(ctx, 'invalid byteOffset');
+    let len = abuf.data.length - offset;
+    let track_rab = false;
+    if (argv.length > 2 && !JS_IsUndefined(argv[2])) {
+        const l = JS_ToIndex(ctx, argv[2]);
+        if (l < 0)
+            return JS_EXCEPTION;
+        if (l > len)
+            return JS_ThrowRangeError(ctx, 'invalid byteLength');
+        len = l;
+    }
+    else {
+        track_rab = array_buffer_is_resizable(abuf);
+    }
+    const obj = js_create_from_ctor(ctx, new_target, 32 /* 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);
+    const ta = new JSTypedArray(buffer, offset, len);
+    ta.track_rab = track_rab;
+    let view;
+    try {
+        view = track_rab ? new DataView(abuf.buffer, offset) : new DataView(abuf.buffer, offset, len);
+    }
+    catch (e) {
+        return Q.js_host_exception_to_guest(ctx, e);
+    }
+    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 */);
+    if (!ta)
+        return JS_EXCEPTION;
+    const size = 1 << typed_array_size_log2(class_id);
+    const pos = JS_ToIndex(ctx, argv[0]);
+    if (pos < 0)
+        return JS_EXCEPTION;
+    const littleEndian = argv.length > 1 && JS_ToBoolFree(ctx, argv[1]);
+    const abuf = Q.JS_GetAnyOpaque(ta.buffer);
+    if (abuf.detached)
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    const ta_len = typed_array_get_byte_length(ta, 0);
+    if (ta_len < 0)
+        return JS_ThrowTypeErrorArrayBufferOOB(ctx);
+    if ((pos + size) > ta_len)
+        return JS_ThrowRangeError(ctx, 'out of bound');
+    const dv = array_buffer_get_dv(abuf);
+    const ptr = ta.offset + pos;
+    switch (class_id) {
+        case 22 /* JSClassID.INT8_ARRAY */: return dv.getInt8(ptr);
+        case 23 /* JSClassID.UINT8_ARRAY */: return dv.getUint8(ptr);
+        case 24 /* JSClassID.INT16_ARRAY */: return dv.getInt16(ptr, littleEndian);
+        case 25 /* JSClassID.UINT16_ARRAY */: return dv.getUint16(ptr, littleEndian);
+        case 26 /* JSClassID.INT32_ARRAY */: return dv.getInt32(ptr, littleEndian);
+        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);
+        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 */);
+    if (!ta)
+        return JS_EXCEPTION;
+    const size = 1 << typed_array_size_log2(class_id);
+    const pos = JS_ToIndex(ctx, argv[0]);
+    if (pos < 0)
+        return JS_EXCEPTION;
+    const val = argv[1];
+    let v = 0;
+    let v64 = 0n;
+    if (class_id <= 27 /* JSClassID.UINT32_ARRAY */) {
+        const r = JS_ToUint32Free(ctx, val);
+        if (JS_IsException(r))
+            return JS_EXCEPTION;
+        v = r;
+    }
+    else if (class_id <= 29 /* JSClassID.BIG_UINT64_ARRAY */) {
+        const r = JS_ToBigInt64(ctx, val);
+        if (JS_IsException(r))
+            return JS_EXCEPTION;
+        v64 = r;
+    }
+    else {
+        const r = JS_ToFloat64(ctx, val);
+        if (JS_IsException(r))
+            return JS_EXCEPTION;
+        v = r;
+    }
+    const littleEndian = argv.length > 2 && JS_ToBoolFree(ctx, argv[2]);
+    const abuf = Q.JS_GetAnyOpaque(ta.buffer);
+    if (abuf.detached)
+        return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
+    const ta_len = typed_array_get_byte_length(ta, 0);
+    if (ta_len < 0)
+        return JS_ThrowTypeErrorArrayBufferOOB(ctx);
+    if ((pos + size) > ta_len)
+        return JS_ThrowRangeError(ctx, 'out of bound');
+    const dv = array_buffer_get_dv(abuf);
+    const ptr = ta.offset + pos;
+    switch (class_id) {
+        case 22 /* JSClassID.INT8_ARRAY */:
+        case 23 /* JSClassID.UINT8_ARRAY */:
+            dv.setUint8(ptr, v);
+            break;
+        case 24 /* JSClassID.INT16_ARRAY */:
+        case 25 /* JSClassID.UINT16_ARRAY */:
+            dv.setUint16(ptr, v, littleEndian);
+            break;
+        case 26 /* JSClassID.INT32_ARRAY */:
+        case 27 /* JSClassID.UINT32_ARRAY */:
+            dv.setUint32(ptr, v, littleEndian);
+            break;
+        case 30 /* 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 */:
+            dv.setFloat64(ptr, v, littleEndian);
+            break;
+        default:
+            return JS_ThrowTypeError(ctx, 'invalid DataView type');
+    }
+    return undefined;
+}
+const js_dataview_proto_funcs = [
+    JS_CGETSET_MAGIC_DEF('buffer', js_typed_array_get_buffer, null, 1),
+    JS_CGETSET_MAGIC_DEF('byteLength', js_typed_array_get_byteLength, null, 1),
+    JS_CGETSET_MAGIC_DEF('byteOffset', js_typed_array_get_byteOffset, null, 1),
+    JS_CFUNC_MAGIC_DEF('getInt8', 1, js_dataview_getValue, 22 /* JSClassID.INT8_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('getUint8', 1, js_dataview_getValue, 23 /* JSClassID.UINT8_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('getInt16', 1, js_dataview_getValue, 24 /* JSClassID.INT16_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('getUint16', 1, js_dataview_getValue, 25 /* JSClassID.UINT16_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('getInt32', 1, js_dataview_getValue, 26 /* JSClassID.INT32_ARRAY */),
+    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('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 */),
+    JS_CFUNC_MAGIC_DEF('setUint16', 2, js_dataview_setValue, 25 /* JSClassID.UINT16_ARRAY */),
+    JS_CFUNC_MAGIC_DEF('setInt32', 2, js_dataview_setValue, 26 /* JSClassID.INT32_ARRAY */),
+    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_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'DataView', JS_PROP_CONFIGURABLE),
+];
+/* ---------------------------------------------------------------------
+   Intrinsics
+   --------------------------------------------------------------------- */
+export function JS_AddIntrinsicTypedArrays(ctx) {
+    const ab_proto = JS_NewObject(ctx);
+    ctx.class_proto[19 /* JSClassID.ARRAY_BUFFER */] = ab_proto;
+    JS_SetPropertyFunctionList(ctx, ab_proto, js_array_buffer_proto_funcs);
+    const array_buffer_func = JS_NewGlobalCConstructorOnly(ctx, 'ArrayBuffer', js_array_buffer_constructor, 1, ab_proto);
+    JS_SetPropertyFunctionList(ctx, array_buffer_func, js_array_buffer_funcs);
+    const sab_proto = JS_NewObject(ctx);
+    ctx.class_proto[20 /* JSClassID.SHARED_ARRAY_BUFFER */] = sab_proto;
+    JS_SetPropertyFunctionList(ctx, sab_proto, js_shared_array_buffer_proto_funcs);
+    const shared_array_buffer_func = JS_NewGlobalCConstructorOnly(ctx, 'SharedArrayBuffer', js_shared_array_buffer_constructor, 1, sab_proto);
+    JS_SetPropertyFunctionList(ctx, shared_array_buffer_func, js_shared_array_buffer_funcs);
+    const typed_array_base_proto = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, typed_array_base_proto, js_typed_array_base_proto_funcs);
+    /* TypedArray.prototype.toString must be the same object as Array.prototype.toString */
+    let obj = JS_GetProperty(ctx, ctx.class_proto[2 /* JSClassID.ARRAY */], JS_ATOM_toString);
+    if (JS_IsException(obj) || !JS_IsFunction(ctx, obj)) {
+        obj = JS_NewCFunction3(ctx, js_array_toString, 'toString', 0, 0 /* JSCFunctionEnum.generic */, 0, ctx.function_proto);
+    }
+    JS_DefinePropertyValue(ctx, typed_array_base_proto, JS_ATOM_toString, obj, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    const typed_array_base_func = JS_NewCFunction2(ctx, js_typed_array_base_constructor, 'TypedArray', 0, 4 /* JSCFunctionEnum.constructor_or_func */, 0);
+    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++) {
+        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);
+        const name = JS_AtomToString(ctx, JS_ATOM_Uint8ClampedArray + i - 21 /* JSClassID.UINT8C_ARRAY */);
+        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);
+    }
+    /* DataView */
+    const dv_proto = JS_NewObject(ctx);
+    ctx.class_proto[32 /* JSClassID.DATAVIEW */] = dv_proto;
+    JS_SetPropertyFunctionList(ctx, dv_proto, js_dataview_proto_funcs);
+    JS_NewGlobalCConstructorOnly(ctx, 'DataView', js_dataview_constructor, 1, dv_proto);
+}
+export { typed_array_get_length as js_typed_array_get_length_elements, typed_array_is_detached, validate_typed_array };
+//# sourceMappingURL=typedarray.js.map