@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/runtime/avm2/natives/define.js

@@ -0,0 +1,130 @@
+// What the natives share: how a native is made, and helpers several
+// families of builtins use.
+import { FloatValue } from "../float.js";
+import { Namespace, publicNs, qname } from "../names.js";
+export const AS3 = "http://adobe.com/AS3/2006/builtin";
+/** Host lookups see every API version; this name keeps no property cache. */
+export const LENGTH = qname(publicNs, "length");
+/** `f` as a native, whatever the runtime. */
+export const plain = (f) => (_rt) => f;
+// What every prototype, and every function, has of its own: not natives.
+// A prototype's `name` is a getter a class may well define, as DisplayObject's.
+const PROTOTYPE_OWN = new Set(["constructor"]);
+const FUNCTION_OWN = new Set(["length", "name", "prototype"]);
+/**
+ * Register the members of `Class` as the natives of the AS3 class
+ * `qualified`, by the names the compiler binds them with: its prototype's
+ * own getters, setters and methods as "Class#get:x", "Class#set:x" and
+ * "Class#method", its own static ones as "Class.get:x" and "Class.method".
+ * A computed member name carries a name the convention cannot spell, such
+ * as `[\`${AS3}::push\`]`. The class is only how the natives are written:
+ * nothing makes an instance of it, the AS3 objects' prototypes are not
+ * touched, and each function is registered as plain() registers one, so it
+ * runs with the AS3 object as `this`. Its descriptors are read, never a
+ * getter run. A name registered twice is an error, not a replacement.
+ */
+export function registerNativeClass(natives, qualified, Class) {
+    const sides = [
+        [`${qualified}#`, Class.prototype, PROTOTYPE_OWN],
+        [`${qualified}.`, Class, FUNCTION_OWN],
+    ];
+    for (const [prefix, members, skip] of sides) {
+        // Descriptors, not values: a getter must not run here.
+        for (const name of Object.getOwnPropertyNames(members)) {
+            if (skip.has(name)) {
+                continue;
+            }
+            const d = Object.getOwnPropertyDescriptor(members, name);
+            if (!d) {
+                continue;
+            }
+            if (d.get) {
+                add(natives, `${prefix}get:${name}`, d.get);
+            }
+            if (d.set) {
+                add(natives, `${prefix}set:${name}`, d.set);
+            }
+            if (typeof d.value === "function") {
+                add(natives, `${prefix}${name}`, d.value);
+            }
+        }
+    }
+}
+/** A native under `key`; a second one for the same key is a mistake, not a replacement. */
+function add(natives, key, fn) {
+    if (key in natives) {
+        throw new Error(`native ${key} is registered twice`);
+    }
+    natives[key] = plain(fn);
+}
+/** The elements of an Array value, for natives that take one. */
+export function elements(v) {
+    return v?.$a ?? [];
+}
+/** Whether `v` is an object to avmplus (AvmCore::isObject): not null, a primitive, a float or a Namespace. */
+export const isObject = (v) => v !== null && typeof v === "object" && !(v instanceof FloatValue) && !(v instanceof Namespace);
+/**
+ * As getUintProperty, element i of an Array, a Vector or any other object:
+ * from the elements' own storage when it holds i, else as the property the
+ * index names, so that an Array's hole finds the prototype's.
+ */
+export function getElement(rt, o, i) {
+    // An element in storage first: a Vector's own hook gives the same, or
+    // throws its RangeError for what is not there.
+    const a = o.$a;
+    if (a !== undefined && i in a) {
+        return a[i];
+    }
+    const getIndex = o.$traits?.getIndex;
+    return getIndex ? getIndex(o, i, rt) : rt.getProperty(o, rt.publicName(i));
+}
+/**
+ * As getLengthProperty, the length Array's natives walk to: an Array's or
+ * a Vector's own, which nothing can override, else the length property's,
+ * through the getter an Array subclass may override, as a uint.
+ */
+export function lengthOf(rt, o) {
+    const traits = o.$traits;
+    if (traits === rt.builtinClass("Array").$it || traits.cls?.$convert !== undefined) {
+        const n = o.$a.length;
+        return n;
+    }
+    return rt.toUint(rt.getProperty(o, LENGTH));
+}
+/**
+ * As ArrayClass's every, filter, forEach, map and some: `f` called with
+ * each element, its index and the receiver, up to the length at the start;
+ * `each` sees each result and the element, and a value it returns ends the
+ * walk with that value. What is not an object has no elements. A method
+ * closure takes no other receiver, but where `anyReceiver` (map's, and a
+ * Vector's map and filter, do not check).
+ */
+export function eachElement(rt, o, f, receiver, each, anyReceiver = false) {
+    if (!isObject(o) || f === null || f === undefined) {
+        return undefined;
+    }
+    if (!anyReceiver && f.$closure && receiver !== null && receiver !== undefined) {
+        throw rt.error("TypeError", 1510);
+    }
+    const length = lengthOf(rt, o);
+    for (let i = 0; i < length; i++) {
+        const element = getElement(rt, o, i);
+        const done = each(rt.callValue(f, receiver, [element, i, o], null), element);
+        if (done !== undefined) {
+            return done;
+        }
+    }
+    return undefined;
+}
+/** A conversion of the builtin primitive classes, called or constructed. */
+export const conversion = (convert) => ({
+    call: (rt, _cls, args) => convert(rt, args),
+    construct: (rt, _cls, args) => convert(rt, args),
+});
+/** Array storage for an instance of Array or a Vector, and its subclasses'. */
+export const withStorage = (traits) => {
+    const o = Object.create(traits.proto);
+    o.$a = [];
+    o.$fixed = false;
+    return o;
+};

package/dist/thread/runtime/avm2/natives/describe.js

@@ -0,0 +1,351 @@
+// avmplus.describeTypeJSON, as avmplus' TypeDescriber (core/TypeDescriber.cpp)
+// builds it: the object describeType and playerglobal's
+// flash.utils.describeType turn into XML. The traits' bindings are walked
+// from the root of the chain down, as addBindings adds them, so a derived
+// class's binding stands over its base's; their order is the hashtable's
+// in avmplus, keyed by string addresses, which nothing reproduces.
+//
+// Translated from avmplus' core/TypeDescriber.cpp, this file is subject to
+// the Mozilla Public License, v. 2.0: http://mozilla.org/MPL/2.0/.
+import { formatClassName, NS_Public } from "../names.js";
+import { BIND_Const, BIND_Get, BIND_GetSet, BIND_Method, BIND_Set, BIND_Var, ClassRef, VectorRef, } from "../traits.js";
+const HIDE_NSURI_METHODS = 0x0001;
+const INCLUDE_BASES = 0x0002;
+const INCLUDE_INTERFACES = 0x0004;
+const INCLUDE_VARIABLES = 0x0008;
+const INCLUDE_ACCESSORS = 0x0010;
+const INCLUDE_METHODS = 0x0020;
+const INCLUDE_METADATA = 0x0040;
+const INCLUDE_CONSTRUCTOR = 0x0080;
+const INCLUDE_TRAITS = 0x0100;
+const USE_ITRAITS = 0x0200;
+const HIDE_OBJECT = 0x0400;
+export const describeNatives = {
+    "avmplus::describeTypeJSON": (rt) => (v, flags) => describeTypeJSON(rt, v, rt.toUint(flags)),
+};
+/**
+ * As TypeDescriber::describeType: the value's traits, or its class's
+ * instance traits with USE_ITRAITS, which a value that is no class has
+ * none of (null then), as { name, isDynamic, isFinal, isStatic, traits }.
+ * undefined and null have traits of their own, void's and null's, with
+ * nothing in them.
+ */
+function describeTypeJSON(rt, v, flags) {
+    // A class object: its own traits are the class's statics, its $it its instances'.
+    const cls = v !== null && typeof v === "object" && v.$it ? v : null;
+    const traits = cls ? rt.traitsOf(cls) : chooseTraits(rt, v);
+    if (typeof traits === "string") {
+        // void or null: no traits object to walk, and no instance traits.
+        if (flags & USE_ITRAITS) {
+            return null;
+        }
+        return rt.newObject([
+            "name",
+            traits,
+            "isDynamic",
+            false,
+            "isFinal",
+            true,
+            "isStatic",
+            false,
+            "traits",
+            flags & INCLUDE_TRAITS ? emptyTraits(rt, flags) : null,
+        ]);
+    }
+    let t = traits;
+    let name = cls ? className(cls.$it) : className(t);
+    if (flags & USE_ITRAITS) {
+        if (!cls) {
+            return null;
+        }
+        t = cls.$it;
+        name = className(t);
+    }
+    return rt.newObject([
+        "name",
+        name,
+        "isDynamic",
+        t.dynamic,
+        "isFinal",
+        t.final,
+        "isStatic",
+        cls !== null && !(flags & USE_ITRAITS),
+        "traits",
+        flags & INCLUDE_TRAITS ? describeTraits(rt, t, flags) : null,
+    ]);
+}
+/**
+ * As TypeDescriber::chooseTraits: undefined is void, null is null, a
+ * number that is an int in avmplus' 29 bits is an int, and anything else
+ * is what it is; a class object's traits are its own, the class's.
+ */
+function chooseTraits(rt, v) {
+    if (v === undefined) {
+        return "void";
+    }
+    if (v === null) {
+        return "null";
+    }
+    if (typeof v === "number" && (v | 0) === v && v >= -(1 << 28) && v < 1 << 28) {
+        return rt.traitsOfType("int");
+    }
+    return rt.traitsOf(v);
+}
+/** As Traits::formatClassName: the qualified name, a class's statics' without their trailing $. */
+function className(t) {
+    return formatClassName(t.name);
+}
+/** A type's name as describeClassName gives it: * for none, else the class's qualified name. */
+function typeName(rt, type) {
+    if (type === null) {
+        return "*";
+    }
+    if (typeof type === "string") {
+        return type;
+    }
+    if (type instanceof VectorRef) {
+        return `__AS3__.vec::Vector.<${typeName(rt, type.param)}>`;
+    }
+    if (type instanceof ClassRef) {
+        try {
+            return rt.traitsOfType(type).name;
+        }
+        catch {
+            return type.ns.uri ? `${type.ns.uri}::${type.name}` : type.name;
+        }
+    }
+    return "*";
+}
+/** The traits object of void and null: every array asked for empty, nothing else. */
+function emptyTraits(rt, flags) {
+    return rt.newObject([
+        "bases",
+        flags & INCLUDE_BASES ? rt.array([]) : null,
+        "interfaces",
+        flags & INCLUDE_INTERFACES ? rt.array([]) : null,
+        "metadata",
+        flags & INCLUDE_METADATA ? rt.array([]) : null,
+        "accessors",
+        null,
+        "methods",
+        null,
+        "variables",
+        null,
+        "constructor",
+        null,
+    ]);
+}
+/** As TypeDescriber::describeTraits. */
+function describeTraits(rt, t, flags) {
+    let bases = null;
+    if (flags & INCLUDE_BASES) {
+        const names = [];
+        for (let b = t.base; b; b = b.base) {
+            names.push(className(b));
+        }
+        bases = rt.array(names);
+    }
+    let interfaces = null;
+    if (flags & INCLUDE_INTERFACES) {
+        t.settleInterfaces();
+        interfaces = rt.array([...t.interfaces].map((i) => className(i)));
+    }
+    let ctor = null;
+    if (flags & INCLUDE_CONSTRUCTOR && t.ctor && t.ctor[0].length > 0) {
+        ctor = describeParams(rt, t.ctor[0], t.ctor[1]);
+    }
+    let metadata = null;
+    if (flags & INCLUDE_METADATA) {
+        metadata = rt.array(t.metadata ? t.metadata.map((m) => describeMetadata(rt, m)) : []);
+    }
+    const variables = [];
+    const accessors = [];
+    const methods = [];
+    if (flags & (INCLUDE_ACCESSORS | INCLUDE_METHODS | INCLUDE_VARIABLES)) {
+        const hidden = flags & HIDE_NSURI_METHODS ? uriNamespacesOfBases(t) : null;
+        for (const member of members(t, flags, rt.apiVersion)) {
+            if (member.ns.kind !== NS_Public || hidden?.has(namespaceKey(member.ns, member.version))) {
+                continue;
+            }
+            const kind = member.value & 7;
+            const id = member.value >> 3;
+            let v;
+            let own;
+            let other;
+            if (kind === BIND_Var || kind === BIND_Const) {
+                if (!(flags & INCLUDE_VARIABLES)) {
+                    continue;
+                }
+                v = rt.newObject([
+                    "access",
+                    kind === BIND_Const ? "readonly" : "readwrite",
+                    "type",
+                    typeName(rt, member.owner.slotType(id)),
+                ]);
+                variables.push(v);
+                own = slotMetadataOf(member.owner, id);
+            }
+            else if (kind === BIND_Method) {
+                if (!(flags & INCLUDE_METHODS)) {
+                    continue;
+                }
+                const [declaredBy, signature] = signatureOf(member.owner, id);
+                v = rt.newObject([
+                    "declaredBy",
+                    className(declaredBy),
+                    "returnType",
+                    typeName(rt, signature[0]),
+                    "parameters",
+                    describeParams(rt, signature[1], signature[2]),
+                ]);
+                methods.push(v);
+                own = methodMetadataOf(member.owner, id);
+            }
+            else {
+                if (!(flags & INCLUDE_ACCESSORS)) {
+                    continue;
+                }
+                const getter = kind === BIND_Get || kind === BIND_GetSet;
+                const [declaredBy, signature] = signatureOf(member.owner, getter ? id : id + 1);
+                const type = getter ? signature[0] : signature[1].length ? signature[1][0] : null;
+                v = rt.newObject([
+                    "declaredBy",
+                    className(declaredBy),
+                    "access",
+                    kind === BIND_Get ? "readonly" : kind === BIND_Set ? "writeonly" : "readwrite",
+                    "type",
+                    typeName(rt, type),
+                ]);
+                accessors.push(v);
+                if (getter) {
+                    own = methodMetadataOf(member.owner, id);
+                }
+                if (kind === BIND_Set || kind === BIND_GetSet) {
+                    other = methodMetadataOf(member.owner, id + 1);
+                }
+            }
+            let md = null;
+            if (flags & INCLUDE_METADATA && (own || other)) {
+                md = rt.array([...(own ?? []), ...(other ?? [])].map((m) => describeMetadata(rt, m)));
+            }
+            v.$d.set("name", member.name);
+            v.$d.set("uri", member.ns.uri === "" ? null : member.ns.uri);
+            v.$d.set("metadata", md);
+        }
+    }
+    return rt.newObject([
+        "bases",
+        bases,
+        "interfaces",
+        interfaces,
+        "metadata",
+        metadata,
+        "accessors",
+        accessors.length ? rt.array(accessors) : null,
+        "methods",
+        methods.length ? rt.array(methods) : null,
+        "variables",
+        variables.length ? rt.array(variables) : null,
+        "constructor",
+        ctor,
+    ]);
+}
+/**
+ * The bindings of t and its bases, as addBindings gathers them: the
+ * root's first, each derived traits' over its base's for the same name
+ * and namespace, Object's own left out with HIDE_OBJECT unless t is an
+ * interface. The bindings a class gets in its interfaces' namespaces are
+ * no members of its own and do not show, as they do not in avmplus.
+ */
+function members(t, flags, apiVersion) {
+    const chain = [];
+    for (let c = t; c; c = c.base) {
+        if (flags & HIDE_OBJECT && !c.base && !c.isInterface) {
+            break;
+        }
+        chain.unshift(c);
+    }
+    const found = new Map();
+    for (const owner of chain) {
+        owner.settleInterfaces();
+        // An interface's namespace has its qualified name as URI, pkg:Name where the traits say pkg::Name.
+        const interfaceNames = owner.isInterface
+            ? null
+            : new Set([...owner.interfaces].flatMap((i) => [i.name, i.name.replace("::", ":")]));
+        for (const [name, list] of owner.bindings) {
+            for (const b of list) {
+                if (b.version > apiVersion ||
+                    (interfaceNames && b.ns.uri && interfaceNames.has(b.ns.uri))) {
+                    continue;
+                }
+                const key = `${b.ns.kind}\u0000${b.ns.uri}\u0000${name}`;
+                found.set(key, { name, ns: b.ns, version: b.version, value: b.value, owner });
+            }
+        }
+    }
+    return [...found.values()];
+}
+/**
+ * The namespaces with a URI that t's bases bind names in, which
+ * HIDE_NSURI_METHODS hides: by identity in avmplus, where the builtins'
+ * AS3 namespace, versioned, is another than a script's of the same URI,
+ * so Object's AS3 methods hide under a class and a script's own AS3
+ * methods do not, until a class derives from it.
+ */
+function uriNamespacesOfBases(t) {
+    const set = new Set();
+    for (let c = t.base; c; c = c.base) {
+        for (const list of c.bindings.values()) {
+            for (const b of list) {
+                if (b.ns.uri) {
+                    set.add(namespaceKey(b.ns, b.version));
+                }
+            }
+        }
+    }
+    return set;
+}
+function namespaceKey(ns, version) {
+    return `${ns.kind}\u0000${ns.uri}\u0000${version}`;
+}
+/** The nearest traits from `owner` up that has the signature of dispatch id `d`, which declares the method, and the signature. */
+function signatureOf(owner, d) {
+    for (let c = owner; c; c = c.base) {
+        const signature = c.signatures.get(d);
+        if (signature) {
+            return [c, signature];
+        }
+    }
+    return [owner, [null, [], 0]];
+}
+/** Slot `id`'s metadata, from the traits that declare it; undefined for none. */
+function slotMetadataOf(owner, id) {
+    for (let c = owner; c; c = c.base) {
+        if (id in c.slotTypes) {
+            return c.slotMetadata?.get(id);
+        }
+    }
+    return undefined;
+}
+/** Dispatch id `d`'s metadata, the nearest traits' that has any, as getMethodMetadataPos finds it. */
+function methodMetadataOf(owner, d) {
+    for (let c = owner; c; c = c.base) {
+        const entries = c.methodMetadata?.get(d);
+        if (entries) {
+            return entries;
+        }
+    }
+    return undefined;
+}
+/** As TypeDescriber::describeParams: each parameter's type, and whether it is optional. */
+function describeParams(rt, params, required) {
+    return rt.array(params.map((type, i) => rt.newObject(["type", typeName(rt, type), "optional", i >= required])));
+}
+/** As describeMetadataInfo: { name, value: [{ key, value }] }. */
+function describeMetadata(rt, [name, items]) {
+    const pairs = [];
+    for (let i = 0; i < items.length; i += 2) {
+        pairs.push(rt.newObject(["key", items[i], "value", items[i + 1]]));
+    }
+    return rt.newObject(["name", name, "value", rt.array(pairs)]);
+}

package/dist/thread/runtime/avm2/natives/dictionary.js

@@ -0,0 +1,12 @@
+import { DictionaryKeys } from "../dictionary-keys.js";
+import { plain } from "./define.js";
+export const dictionaryNatives = {
+    // As DictionaryObject: keyed by an object itself, in a Map of its own that
+    // property access looks in first, and by any other key as a name. Weak keys
+    // keep no key alive, as Flash's do not (dictionary-keys.ts): a registry
+    // of objects keyed weakly kept every one it had seen.
+    "flash.utils::Dictionary#flash.utils:Dictionary::init": plain(function (weakKeys) {
+        this.$keys = new DictionaryKeys(!!weakKeys);
+        this.$weakKeys = !!weakKeys;
+    }),
+};

package/dist/thread/runtime/avm2/natives/float-vector.js

@@ -0,0 +1,81 @@
+/** Float identity belongs to the vector; only values leaving it need a tag. */
+export class FloatVector {
+    data;
+    count;
+    constructor(length = 0) {
+        this.data = new Float32Array(length);
+        this.count = length;
+    }
+    get length() {
+        return this.count;
+    }
+    set length(length) {
+        if (length === 0) {
+            this.data = new Float32Array(0);
+        }
+        else if (length > this.count) {
+            this.reserve(length);
+            this.data.fill(0, this.count, length);
+        }
+        this.count = length;
+    }
+    reserve(length) {
+        if (length <= this.data.length) {
+            return;
+        }
+        const data = new Float32Array(Math.max(length, this.data.length + Math.max(this.data.length >>> 1, 8)));
+        data.set(this.data.subarray(0, this.count));
+        this.data = data;
+    }
+    push(value) {
+        this.reserve(this.count + 1);
+        this.data[this.count++] = value;
+        return this.count;
+    }
+    pop() {
+        return this.count ? this.data[--this.count] : undefined;
+    }
+    shift() {
+        if (!this.count) {
+            return undefined;
+        }
+        const value = this.data[0];
+        this.data.copyWithin(0, 1, this.count--);
+        return value;
+    }
+    unshift(...items) {
+        const count = items.length;
+        this.reserve(this.count + count);
+        this.data.copyWithin(count, 0, this.count);
+        this.data.set(items);
+        this.count += count;
+        return this.count;
+    }
+    splice(start, remove, ...items) {
+        const at = start < 0 ? Math.max(0, this.count + start) : Math.min(start, this.count);
+        const deleted = Math.min(Math.max(remove, 0), this.count - at);
+        const result = Array.from(this.data.subarray(at, at + deleted));
+        const length = this.count - deleted + items.length;
+        this.reserve(length);
+        this.data.copyWithin(at + items.length, at + deleted, this.count);
+        this.data.set(items, at);
+        this.count = length;
+        return result;
+    }
+    reverse() {
+        this.data.subarray(0, this.count).reverse();
+    }
+}
+/** Conversion precedes this check: valueOf may change the vector's size or fixedness. */
+export function setFloatElement(rt, o, i, value) {
+    const a = o.$a;
+    if (i >>> 0 !== i || i > a.length || (i === a.length && o.$fixed)) {
+        throw rt.error("RangeError", 1125, i, a.length);
+    }
+    if (i === a.length) {
+        a.push(value);
+    }
+    else {
+        a.data[i] = value;
+    }
+}

package/dist/thread/runtime/avm2/natives/float.js

@@ -0,0 +1,96 @@
+import { numberToString } from "../number-strings.js";
+import { convertDoubleToStringRadix } from "../numbers.js";
+import { conversion } from "./define.js";
+import { numberToExponential, numberToFixed, numberToPrecision } from "./number.js";
+export const floatHooks = {
+    float: {
+        ...conversion((rt, args) => rt.float(args.length ? args[0] : 0)),
+        created: (rt, cls) => {
+            const constants = {
+                MAX_VALUE: 3.4028234663852886e38,
+                MIN_VALUE: 1.401298464324817e-45,
+                NaN,
+                POSITIVE_INFINITY: Infinity,
+                NEGATIVE_INFINITY: -Infinity,
+                E: Math.E,
+                LN10: Math.LN10,
+                LN2: Math.LN2,
+                LOG2E: Math.LOG2E,
+                PI: Math.PI,
+                SQRT1_2: Math.SQRT1_2,
+                SQRT2: Math.SQRT2,
+            };
+            for (const [, , name, binding] of cls.$desc.static.bindings) {
+                if (name in constants) {
+                    cls[`$${binding >> 3}`] = rt.float(constants[name]);
+                }
+            }
+        },
+    },
+};
+export const floatNatives = {};
+floatNatives["float.float::_toString"] = (rt) => (value, radix) => {
+    const n = rt.toNumber(value);
+    const base = rt.toInt(radix);
+    if (base === 10 || !Number.isFinite(n)) {
+        return numberToString(n);
+    }
+    if (base < 2 || base > 36) {
+        throw rt.error("RangeError", 1003, base);
+    }
+    return convertDoubleToStringRadix(n, base);
+};
+for (const [name, convert] of [
+    ["toFixed", numberToFixed],
+    ["toExponential", numberToExponential],
+    ["toPrecision", numberToPrecision],
+]) {
+    floatNatives[`float.float::_${name}`] = (rt) => (value, digits) => {
+        const n = rt.toInt(digits);
+        const min = name === "toPrecision" ? 1 : 0;
+        const max = name === "toPrecision" ? 21 : 20;
+        if (n < min || n > max) {
+            throw rt.error("RangeError", 1002, n, min, max);
+        }
+        return convert(rt.toNumber(value), n);
+    };
+}
+for (const name of [
+    "abs",
+    "acos",
+    "asin",
+    "atan",
+    "ceil",
+    "cos",
+    "exp",
+    "floor",
+    "log",
+    "sin",
+    "sqrt",
+    "tan",
+]) {
+    const fn = Math[name];
+    floatNatives[`float.${name}`] = (rt) => (value) => rt.float(fn(Math.fround(rt.toNumber(value))));
+}
+for (const name of ["atan2", "pow"]) {
+    const fn = Math[name];
+    floatNatives[`float.${name}`] = (rt) => (a, b) => rt.float(fn(Math.fround(rt.toNumber(a)), Math.fround(rt.toNumber(b))));
+}
+for (const name of ["max", "min"]) {
+    const fn = Math[name];
+    floatNatives[`float.${name}`] =
+        (rt) => (...args) => {
+            let result = name === "max" ? -Infinity : Infinity;
+            for (const arg of args) {
+                result = fn(result, Math.fround(rt.toNumber(arg)));
+            }
+            return rt.float(result);
+        };
+}
+floatNatives["float.random"] = (rt) => () => rt.float(Math.random());
+floatNatives["float.round"] = (rt) => (value) => {
+    const rounded = Math.round(Math.fround(rt.toNumber(value)));
+    return rt.float(rounded === 0 ? 0 : rounded);
+};
+floatNatives["float.reciprocal"] = (rt) => (value) => rt.float(1 / Math.fround(rt.toNumber(value)));
+floatNatives["float.rsqrt"] = (rt) => (value) => rt.float(1 / Math.sqrt(Math.fround(rt.toNumber(value))));