Type Alias ExpressionBuilder

An namespace of functions for building WASM expressions.

See

https://webassembly.github.io/spec/core/syntax/instructions.html

type ExpressionBuilder = {
    array: {
        copy: (
            destRef: number,
            destIndex: number,
            srcRef: number,
            srcIndex: number,
            length: number,
        ) => number;
        fill: (ref: number, index: number, value: number, size: number) => number;
        get: (
            ref: number,
            index: number,
            type: number,
            deprecated_isSigned?: boolean,
        ) => number;
        get_s: (ref: number, index: number, type: number) => number;
        get_u: (ref: number, index: number, type: number) => number;
        init_data: (
            name: string,
            ref: number,
            index: number,
            offset: number,
            size: number,
        ) => number;
        init_elem: (
            name: string,
            ref: number,
            index: number,
            offset: number,
            size: number,
        ) => number;
        len: (ref: number) => number;
        new: (heapType: number, size: number, operand: number) => number;
        new_data: (
            heapType: number,
            name: string,
            offset: number,
            size: number,
        ) => number;
        new_default: (heapType: number, size: number) => number;
        new_elem: (
            heapType: number,
            name: string,
            offset: number,
            size: number,
        ) => number;
        new_fixed: (heapType: number, operands: readonly number[]) => number;
        set: (ref: number, index: number, value: number) => number;
    };
    atomic: { fence: () => number };
    block: (
        name: string | null,
        children: readonly number[],
        resultType?: number,
    ) => number;
    br: (label: string, condition?: number, value?: number) => number;
    br_if: (label: string, condition: number, value?: number) => number;
    br_on_cast: (label: string, value: number, castType: number) => number;
    br_on_cast_fail: (label: string, value: number, castType: number) => number;
    br_on_non_null: (label: string, value: number) => number;
    br_on_null: (label: string, value: number) => number;
    br_table: (
        labels: readonly string[],
        defaultLabel: string,
        condition: number,
        value?: number,
    ) => number;
    call: (
        name: string,
        operands: readonly number[],
        resultsType: number,
    ) => number;
    call_indirect: (
        table: string,
        target: number,
        operands: readonly number[],
        paramsType: number,
        resultsType: number,
    ) => number;
    call_ref: (
        target: number,
        operands: readonly number[],
        resultsType: number,
    ) => number;
    data: { drop: (segment: string) => number };
    drop: (value: number) => number;
    f32: {
        abs: (value: number) => number;
        add: (left: number, right: number) => number;
        ceil: (value: number) => number;
        const: (value: number) => number;
        const_bits: (value: number) => number;
        convert_i32_s: (value: number) => number;
        convert_i32_u: (value: number) => number;
        convert_i64_s: (value: number) => number;
        convert_i64_u: (value: number) => number;
        convert_s: {
            i32: (...args: any[]) => number;
            i64: (...args: any[]) => number;
        };
        convert_u: {
            i32: (...args: any[]) => number;
            i64: (...args: any[]) => number;
        };
        copysign: (left: number, right: number) => number;
        demote_f64: (value: number) => number;
        div: (left: number, right: number) => number;
        eq: (left: number, right: number) => number;
        floor: (value: number) => number;
        ge: (left: number, right: number) => number;
        gt: (left: number, right: number) => number;
        le: (left: number, right: number) => number;
        load: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        lt: (left: number, right: number) => number;
        max: (left: number, right: number) => number;
        min: (left: number, right: number) => number;
        mul: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        nearest: (value: number) => number;
        neg: (value: number) => number;
        reinterpret_i32: (value: number) => number;
        sqrt: (value: number) => number;
        store: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        sub: (left: number, right: number) => number;
        trunc: (value: number) => number;
        demote(...args: any[]): number;
        reinterpret(...args: any[]): number;
    };
    f32x4: {
        abs: (value: number) => number;
        add: (left: number, right: number) => number;
        ceil: (value: number) => number;
        convert_i32x4_s: (value: number) => number;
        convert_i32x4_u: (value: number) => number;
        demote_f64x2_zero: (value: number) => number;
        div: (left: number, right: number) => number;
        eq: (left: number, right: number) => number;
        extract_lane: (vec: number, index: number) => number;
        floor: (value: number) => number;
        ge: (left: number, right: number) => number;
        gt: (left: number, right: number) => number;
        le: (left: number, right: number) => number;
        lt: (left: number, right: number) => number;
        max: (left: number, right: number) => number;
        min: (left: number, right: number) => number;
        mul: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        nearest: (value: number) => number;
        neg: (value: number) => number;
        pmax: (left: number, right: number) => number;
        pmin: (left: number, right: number) => number;
        replace_lane: (vec: number, index: number, value: number) => number;
        splat: (value: number) => number;
        sqrt: (value: number) => number;
        sub: (left: number, right: number) => number;
        trunc: (value: number) => number;
    };
    f64: {
        abs: (value: number) => number;
        add: (left: number, right: number) => number;
        ceil: (value: number) => number;
        const: (value: number) => number;
        const_bits: (value: number | bigint) => number;
        convert_i32_s: (value: number) => number;
        convert_i32_u: (value: number) => number;
        convert_i64_s: (value: number) => number;
        convert_i64_u: (value: number) => number;
        convert_s: {
            i32: (...args: any[]) => number;
            i64: (...args: any[]) => number;
        };
        convert_u: {
            i32: (...args: any[]) => number;
            i64: (...args: any[]) => number;
        };
        copysign: (left: number, right: number) => number;
        div: (left: number, right: number) => number;
        eq: (left: number, right: number) => number;
        floor: (value: number) => number;
        ge: (left: number, right: number) => number;
        gt: (left: number, right: number) => number;
        le: (left: number, right: number) => number;
        load: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        lt: (left: number, right: number) => number;
        max: (left: number, right: number) => number;
        min: (left: number, right: number) => number;
        mul: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        nearest: (value: number) => number;
        neg: (value: number) => number;
        promote_f32: (value: number) => number;
        reinterpret_f64: (value: number) => number;
        sqrt: (value: number) => number;
        store: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        sub: (left: number, right: number) => number;
        trunc: (value: number) => number;
        promote(...args: any[]): number;
        reinterpret(...args: any[]): any;
    };
    f64x2: {
        abs: (value: number) => number;
        add: (left: number, right: number) => number;
        ceil: (value: number) => number;
        convert_low_i32x4_s: (value: number) => number;
        convert_low_i32x4_u: (value: number) => number;
        div: (left: number, right: number) => number;
        eq: (left: number, right: number) => number;
        extract_lane: (vec: number, index: number) => number;
        floor: (value: number) => number;
        ge: (left: number, right: number) => number;
        gt: (left: number, right: number) => number;
        le: (left: number, right: number) => number;
        lt: (left: number, right: number) => number;
        max: (left: number, right: number) => number;
        min: (left: number, right: number) => number;
        mul: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        nearest: (value: number) => number;
        neg: (value: number) => number;
        pmax: (left: number, right: number) => number;
        pmin: (left: number, right: number) => number;
        promote_low_f32x4: (value: number) => number;
        replace_lane: (vec: number, index: number, value: number) => number;
        splat: (value: number) => number;
        sqrt: (value: number) => number;
        sub: (left: number, right: number) => number;
        trunc: (value: number) => number;
    };
    global: {
        get: (name: string, typ: number) => number;
        set: (name: string, value: number) => number;
    };
    i16x8: {
        abs: (value: number) => number;
        add: (left: number, right: number) => number;
        add_sat_s: (left: number, right: number) => number;
        add_sat_u: (left: number, right: number) => number;
        all_true: (value: number) => number;
        avgr_u: (left: number, right: number) => number;
        bitmask: (value: number) => number;
        eq: (left: number, right: number) => number;
        extadd_pairwise_i8x16_s: (value: number) => number;
        extadd_pairwise_i8x16_u: (value: number) => number;
        extend_high_i8x16_s: (value: number) => number;
        extend_high_i8x16_u: (value: number) => number;
        extend_low_i8x16_s: (value: number) => number;
        extend_low_i8x16_u: (value: number) => number;
        extmul_high_i8x16_s: (left: number, right: number) => number;
        extmul_high_i8x16_u: (left: number, right: number) => number;
        extmul_low_i8x16_s: (left: number, right: number) => number;
        extmul_low_i8x16_u: (left: number, right: number) => number;
        extract_lane_s: (vec: number, index: number) => number;
        extract_lane_u: (vec: number, index: number) => number;
        ge_s: (left: number, right: number) => number;
        ge_u: (left: number, right: number) => number;
        gt_s: (left: number, right: number) => number;
        gt_u: (left: number, right: number) => number;
        le_s: (left: number, right: number) => number;
        le_u: (left: number, right: number) => number;
        lt_s: (left: number, right: number) => number;
        lt_u: (left: number, right: number) => number;
        max_s: (left: number, right: number) => number;
        max_u: (left: number, right: number) => number;
        min_s: (left: number, right: number) => number;
        min_u: (left: number, right: number) => number;
        mul: (left: number, right: number) => number;
        narrow_i32x4_s: (left: number, right: number) => number;
        narrow_i32x4_u: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        neg: (value: number) => number;
        q15mulr_sat_s: (left: number, right: number) => number;
        replace_lane: (vec: number, index: number, value: number) => number;
        shl: (vec: number, shift: number) => number;
        shr_s: (vec: number, shift: number) => number;
        shr_u: (vec: number, shift: number) => number;
        splat: (value: number) => number;
        sub: (left: number, right: number) => number;
        sub_sat_s: (left: number, right: number) => number;
        sub_sat_u: (left: number, right: number) => number;
        add_saturate_s(...args: any[]): number;
        add_saturate_u(...args: any[]): number;
        sub_saturate_s(...args: any[]): number;
        sub_saturate_u(...args: any[]): number;
    };
    i31: { get_s: (value: number) => number; get_u: (value: number) => number };
    i32: {
        add: (left: number, right: number) => number;
        and: (left: number, right: number) => number;
        atomic: {
            load: (
                offset: number,
                ptr: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            load16_u: (
                offset: number,
                ptr: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            load8_u: (
                offset: number,
                ptr: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            rmw: {
                add: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                and: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                cmpxchg: (
                    offset: number,
                    ptr: number,
                    expected: number,
                    replacement: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                or: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                sub: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xchg: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xor: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
            };
            rmw16_u: {
                add: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                and: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                cmpxchg: (
                    offset: number,
                    ptr: number,
                    expected: number,
                    replacement: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                or: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                sub: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xchg: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xor: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
            };
            rmw8_u: {
                add: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                and: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                cmpxchg: (
                    offset: number,
                    ptr: number,
                    expected: number,
                    replacement: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                or: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                sub: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xchg: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xor: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
            };
            store: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            store16: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            store8: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
        };
        clz: (value: number) => number;
        const: (value: number) => number;
        ctz: (value: number) => number;
        div_s: (left: number, right: number) => number;
        div_u: (left: number, right: number) => number;
        eq: (left: number, right: number) => number;
        eqz: (value: number) => number;
        extend16_s: (value: number) => number;
        extend8_s: (value: number) => number;
        ge_s: (left: number, right: number) => number;
        ge_u: (left: number, right: number) => number;
        gt_s: (left: number, right: number) => number;
        gt_u: (left: number, right: number) => number;
        le_s: (left: number, right: number) => number;
        le_u: (left: number, right: number) => number;
        load: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load16_s: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load16_u: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load8_s: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load8_u: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        lt_s: (left: number, right: number) => number;
        lt_u: (left: number, right: number) => number;
        mul: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        or: (left: number, right: number) => number;
        popcnt: (value: number) => number;
        reinterpret_f32: (value: number) => number;
        rem_s: (left: number, right: number) => number;
        rem_u: (left: number, right: number) => number;
        rotl: (left: number, right: number) => number;
        rotr: (left: number, right: number) => number;
        shl: (left: number, right: number) => number;
        shr_s: (left: number, right: number) => number;
        shr_u: (left: number, right: number) => number;
        store: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        store16: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        store8: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        sub: (left: number, right: number) => number;
        trunc_f32_s: (value: number) => number;
        trunc_f32_u: (value: number) => number;
        trunc_f64_s: (value: number) => number;
        trunc_f64_u: (value: number) => number;
        trunc_s: {
            f32: (...args: any[]) => number;
            f64: (...args: any[]) => number;
        };
        trunc_s_sat: {
            f32: (...args: any[]) => number;
            f64: (...args: any[]) => number;
        };
        trunc_sat_f32_s: (value: number) => number;
        trunc_sat_f32_u: (value: number) => number;
        trunc_sat_f64_s: (value: number) => number;
        trunc_sat_f64_u: (value: number) => number;
        trunc_u: {
            f32: (...args: any[]) => number;
            f64: (...args: any[]) => number;
        };
        trunc_u_sat: {
            f32: (...args: any[]) => number;
            f64: (...args: any[]) => number;
        };
        wrap_i64: (value: number) => number;
        xor: (left: number, right: number) => number;
        reinterpret(...args: any[]): number;
        wrap(...args: any[]): number;
    };
    i32x4: {
        abs: (value: number) => number;
        add: (left: number, right: number) => number;
        all_true: (value: number) => number;
        bitmask: (value: number) => number;
        dot_i16x8_s: (left: number, right: number) => number;
        eq: (left: number, right: number) => number;
        extadd_pairwise_i16x8_s: (value: number) => number;
        extadd_pairwise_i16x8_u: (value: number) => number;
        extend_high_i16x8_s: (value: number) => number;
        extend_high_i16x8_u: (value: number) => number;
        extend_low_i16x8_s: (value: number) => number;
        extend_low_i16x8_u: (value: number) => number;
        extmul_high_i16x8_s: (left: number, right: number) => number;
        extmul_high_i16x8_u: (left: number, right: number) => number;
        extmul_low_i16x8_s: (left: number, right: number) => number;
        extmul_low_i16x8_u: (left: number, right: number) => number;
        extract_lane: (vec: number, index: number) => number;
        ge_s: (left: number, right: number) => number;
        ge_u: (left: number, right: number) => number;
        gt_s: (left: number, right: number) => number;
        gt_u: (left: number, right: number) => number;
        le_s: (left: number, right: number) => number;
        le_u: (left: number, right: number) => number;
        lt_s: (left: number, right: number) => number;
        lt_u: (left: number, right: number) => number;
        max_s: (left: number, right: number) => number;
        max_u: (left: number, right: number) => number;
        min_s: (left: number, right: number) => number;
        min_u: (left: number, right: number) => number;
        mul: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        neg: (value: number) => number;
        replace_lane: (vec: number, index: number, value: number) => number;
        shl: (vec: number, shift: number) => number;
        shr_s: (vec: number, shift: number) => number;
        shr_u: (vec: number, shift: number) => number;
        splat: (value: number) => number;
        sub: (left: number, right: number) => number;
        trunc_sat_f32x4_s: (value: number) => number;
        trunc_sat_f32x4_u: (value: number) => number;
        trunc_sat_f64x2_s_zero: (value: number) => number;
        trunc_sat_f64x2_u_zero: (value: number) => number;
    };
    i64: {
        add: (left: number, right: number) => number;
        add128: (
            leftLow: number,
            leftHigh: number,
            rightLow: number,
            rightHigh: number,
        ) => number;
        and: (left: number, right: number) => number;
        atomic: {
            load: (
                offset: number,
                ptr: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            load16_u: (
                offset: number,
                ptr: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            load32_u: (
                offset: number,
                ptr: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            load8_u: (
                offset: number,
                ptr: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            rmw: {
                add: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                and: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                cmpxchg: (
                    offset: number,
                    ptr: number,
                    expected: number,
                    replacement: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                or: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                sub: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xchg: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xor: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
            };
            rmw16_u: {
                add: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                and: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                cmpxchg: (
                    offset: number,
                    ptr: number,
                    expected: number,
                    replacement: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                or: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                sub: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xchg: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xor: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
            };
            rmw32_u: {
                add: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                and: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                cmpxchg: (
                    offset: number,
                    ptr: number,
                    expected: number,
                    replacement: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                or: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                sub: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xchg: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xor: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
            };
            rmw8_u: {
                add: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                and: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                cmpxchg: (
                    offset: number,
                    ptr: number,
                    expected: number,
                    replacement: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                or: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                sub: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xchg: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
                xor: (
                    offset: number,
                    ptr: number,
                    value: number,
                    name?: string,
                    order?: MemoryOrder,
                ) => number;
            };
            store: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            store16: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            store32: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            store8: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
        };
        clz: (value: number) => number;
        const: (value: number | bigint) => number;
        ctz: (value: number) => number;
        div_s: (left: number, right: number) => number;
        div_u: (left: number, right: number) => number;
        eq: (left: number, right: number) => number;
        eqz: (value: number) => number;
        extend_i32_s: (value: number) => number;
        extend_i32_u: (value: number) => number;
        extend16_s: (value: number) => number;
        extend32_s: (value: number) => number;
        extend8_s: (value: number) => number;
        ge_s: (left: number, right: number) => number;
        ge_u: (left: number, right: number) => number;
        gt_s: (left: number, right: number) => number;
        gt_u: (left: number, right: number) => number;
        le_s: (left: number, right: number) => number;
        le_u: (left: number, right: number) => number;
        load: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load16_s: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load16_u: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load32_s: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load32_u: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load8_s: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load8_u: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        lt_s: (left: number, right: number) => number;
        lt_u: (left: number, right: number) => number;
        mul: (left: number, right: number) => number;
        mul_wide_s: (left: number, right: number) => number;
        mul_wide_u: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        or: (left: number, right: number) => number;
        popcnt: (value: number) => number;
        reinterpret_f64: (value: number) => number;
        rem_s: (left: number, right: number) => number;
        rem_u: (left: number, right: number) => number;
        rotl: (left: number, right: number) => number;
        rotr: (left: number, right: number) => number;
        shl: (left: number, right: number) => number;
        shr_s: (left: number, right: number) => number;
        shr_u: (left: number, right: number) => number;
        store: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        store16: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        store32: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        store8: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        sub: (left: number, right: number) => number;
        sub128: (
            leftLow: number,
            leftHigh: number,
            rightLow: number,
            rightHigh: number,
        ) => number;
        trunc_f32_s: (value: number) => number;
        trunc_f32_u: (value: number) => number;
        trunc_f64_s: (value: number) => number;
        trunc_f64_u: (value: number) => number;
        trunc_s: {
            f32: (...args: any[]) => number;
            f64: (...args: any[]) => number;
        };
        trunc_s_sat: {
            f32: (...args: any[]) => number;
            f64: (...args: any[]) => number;
        };
        trunc_sat_f32_s: (value: number) => number;
        trunc_sat_f32_u: (value: number) => number;
        trunc_sat_f64_s: (value: number) => number;
        trunc_sat_f64_u: (value: number) => number;
        trunc_u: {
            f32: (...args: any[]) => number;
            f64: (...args: any[]) => number;
        };
        trunc_u_sat: {
            f32: (...args: any[]) => number;
            f64: (...args: any[]) => number;
        };
        xor: (left: number, right: number) => number;
        extend_s(...args: any[]): number;
        extend_u(...args: any[]): number;
        reinterpret(...args: any[]): number;
    };
    i64x2: {
        abs: (value: number) => number;
        add: (left: number, right: number) => number;
        all_true: (value: number) => number;
        bitmask: (value: number) => number;
        eq: (left: number, right: number) => number;
        extend_high_i32x4_s: (value: number) => number;
        extend_high_i32x4_u: (value: number) => number;
        extend_low_i32x4_s: (value: number) => number;
        extend_low_i32x4_u: (value: number) => number;
        extmul_high_i32x4_s: (left: number, right: number) => number;
        extmul_high_i32x4_u: (left: number, right: number) => number;
        extmul_low_i32x4_s: (left: number, right: number) => number;
        extmul_low_i32x4_u: (left: number, right: number) => number;
        extract_lane: (vec: number, index: number) => number;
        ge_s: (left: number, right: number) => number;
        gt_s: (left: number, right: number) => number;
        le_s: (left: number, right: number) => number;
        lt_s: (left: number, right: number) => number;
        mul: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        neg: (value: number) => number;
        replace_lane: (vec: number, index: number, value: number) => number;
        shl: (vec: number, shift: number) => number;
        shr_s: (vec: number, shift: number) => number;
        shr_u: (vec: number, shift: number) => number;
        splat: (value: number) => number;
        sub: (left: number, right: number) => number;
    };
    i8x16: {
        abs: (value: number) => number;
        add: (left: number, right: number) => number;
        add_sat_s: (left: number, right: number) => number;
        add_sat_u: (left: number, right: number) => number;
        all_true: (value: number) => number;
        avgr_u: (left: number, right: number) => number;
        bitmask: (value: number) => number;
        eq: (left: number, right: number) => number;
        extract_lane_s: (vec: number, index: number) => number;
        extract_lane_u: (vec: number, index: number) => number;
        ge_s: (left: number, right: number) => number;
        ge_u: (left: number, right: number) => number;
        gt_s: (left: number, right: number) => number;
        gt_u: (left: number, right: number) => number;
        le_s: (left: number, right: number) => number;
        le_u: (left: number, right: number) => number;
        lt_s: (left: number, right: number) => number;
        lt_u: (left: number, right: number) => number;
        max_s: (left: number, right: number) => number;
        max_u: (left: number, right: number) => number;
        min_s: (left: number, right: number) => number;
        min_u: (left: number, right: number) => number;
        narrow_i16x8_s: (left: number, right: number) => number;
        narrow_i16x8_u: (left: number, right: number) => number;
        ne: (left: number, right: number) => number;
        neg: (value: number) => number;
        popcnt: (value: number) => number;
        replace_lane: (vec: number, index: number, value: number) => number;
        shl: (vec: number, shift: number) => number;
        shr_s: (vec: number, shift: number) => number;
        shr_u: (vec: number, shift: number) => number;
        shuffle: (left: number, right: number, mask: readonly number[]) => number;
        splat: (value: number) => number;
        sub: (left: number, right: number) => number;
        sub_sat_s: (left: number, right: number) => number;
        sub_sat_u: (left: number, right: number) => number;
        swizzle: (left: number, right: number) => number;
        add_saturate_s(...args: any[]): number;
        add_saturate_u(...args: any[]): number;
        sub_saturate_s(...args: any[]): number;
        sub_saturate_u(...args: any[]): number;
    };
    if: (ifTrue: number, ifFalse: number) => number;
    local: {
        get: (index: number, typ: number) => number;
        set: (index: number, value: number) => number;
        tee: (index: number, value: number, typ: number) => number;
    };
    loop: (name: string, body: number) => number;
    memory: {
        atomic: {
            notify: (ptr: number, notifyCount: number, name: string) => number;
            wait32: (
                ptr: number,
                expected: number,
                timeout: number,
                name: string,
            ) => number;
            wait64: (
                ptr: number,
                expected: number,
                timeout: number,
                name: string,
            ) => number;
        };
        copy: (
            dest: number,
            source: number,
            size: number,
            destMemory: string,
            sourceMemory: string,
        ) => number;
        fill: (dest: number, value: number, size: number, name: string) => number;
        grow: (delta: number, name: string, memory64?: boolean) => number;
        init: (
            segment: string,
            dest: number,
            offset: number,
            size: number,
            name: string,
        ) => number;
        size: (name: string, memory64?: boolean) => number;
    };
    nop: () => number;
    ref: {
        as_non_null: (value: number) => number;
        cast: (value: number, castType: number) => number;
        eq: (left: number, right: number) => number;
        func: (name: string, type: number) => number;
        i31: (value: number) => number;
        is_null: (value: number) => number;
        null: (typ: number) => number;
        test: (value: number, castType: number) => number;
    };
    return: (value: number) => number;
    return_call: (
        name: string,
        operands: readonly number[],
        resultsType: number,
    ) => number;
    return_call_indirect: (
        table: string,
        target: number,
        operands: readonly number[],
        paramsType: number,
        resultsType: number,
    ) => number;
    return_call_ref: (
        target: number,
        operands: readonly number[],
        resultsType: number,
    ) => number;
    select: (ifTrue: number, ifFalse: number) => number;
    struct: {
        get: (
            index: number,
            ref: number,
            type: number,
            deprecated_isSigned?: boolean,
        ) => number;
        get_s: (index: number, ref: number, type: number) => number;
        get_u: (index: number, ref: number, type: number) => number;
        new: (operands: readonly number[], heapType: number) => number;
        new_default: (heapType: number) => number;
        set: (index: number, ref: number, value: number) => number;
    };
    table: {
        get: (name: string, index: number, typ: number) => number;
        grow: (name: string, value: number, delta: number) => number;
        set: (name: string, index: number, value: number) => number;
        size: (name: string) => number;
    };
    throw: (tag: string, operands: readonly number[]) => number;
    throw_ref: (target: string) => number;
    try_table: (
        name: string,
        body: number,
        catchTags: readonly string[],
        catchBodies: readonly number[],
        delegateTarget: string,
    ) => number;
    tuple: {
        extract: (tupl: number, index: number) => number;
        make: (elements: readonly number[]) => number;
    };
    unreachable: () => number;
    v128: {
        and: (left: number, right: number) => number;
        andnot: (left: number, right: number) => number;
        anytrue: (value: number) => number;
        bitselect: (left: number, right: number, cond: number) => number;
        const: (i8s: readonly number[]) => number;
        load: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load16_lane: (
            offset: number,
            align: number,
            index: number,
            ptr: number,
            vec: number,
            name?: string,
        ) => number;
        load16_splat: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load16x4_s: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load16x4_u: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load32_lane: (
            offset: number,
            align: number,
            index: number,
            ptr: number,
            vec: number,
            name?: string,
        ) => number;
        load32_splat: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load32_zero: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load32x2_s: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load32x2_u: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load64_lane: (
            offset: number,
            align: number,
            index: number,
            ptr: number,
            vec: number,
            name?: string,
        ) => number;
        load64_splat: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load64_zero: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load8_lane: (
            offset: number,
            align: number,
            index: number,
            ptr: number,
            vec: number,
            name?: string,
        ) => number;
        load8_splat: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load8x8_s: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        load8x8_u: (
            offset: number,
            align: number,
            ptr: number,
            name?: string,
        ) => number;
        not: (value: number) => number;
        or: (left: number, right: number) => number;
        store: (
            offset: number,
            align: number,
            ptr: number,
            value: number,
            name?: string,
        ) => number;
        store16_lane: (
            offset: number,
            align: number,
            index: number,
            ptr: number,
            vec: number,
            name?: string,
        ) => number;
        store32_lane: (
            offset: number,
            align: number,
            index: number,
            ptr: number,
            vec: number,
            name?: string,
        ) => number;
        store64_lane: (
            offset: number,
            align: number,
            index: number,
            ptr: number,
            vec: number,
            name?: string,
        ) => number;
        store8_lane: (
            offset: number,
            align: number,
            index: number,
            ptr: number,
            vec: number,
            name?: string,
        ) => number;
        xor: (left: number, right: number) => number;
    };
    break(...args: any[]): number;
    callIndirect(...args: any[]): number;
    rethrow(...args: any[]): number;
    returnCall(...args: any[]): number;
    returnCallIndirect(...args: any[]): number;
    switch(...args: any[]): number;
    try(...args: any[]): number;
}

Properties

`Readonly`array

array: {
    copy: (
        destRef: number,
        destIndex: number,
        srcRef: number,
        srcIndex: number,
        length: number,
    ) => number;
    fill: (ref: number, index: number, value: number, size: number) => number;
    get: (
        ref: number,
        index: number,
        type: number,
        deprecated_isSigned?: boolean,
    ) => number;
    get_s: (ref: number, index: number, type: number) => number;
    get_u: (ref: number, index: number, type: number) => number;
    init_data: (
        name: string,
        ref: number,
        index: number,
        offset: number,
        size: number,
    ) => number;
    init_elem: (
        name: string,
        ref: number,
        index: number,
        offset: number,
        size: number,
    ) => number;
    len: (ref: number) => number;
    new: (heapType: number, size: number, operand: number) => number;
    new_data: (
        heapType: number,
        name: string,
        offset: number,
        size: number,
    ) => number;
    new_default: (heapType: number, size: number) => number;
    new_elem: (
        heapType: number,
        name: string,
        offset: number,
        size: number,
    ) => number;
    new_fixed: (heapType: number, operands: readonly number[]) => number;
    set: (ref: number, index: number, value: number) => number;
} = ...

Type Declaration

Readonlycopy: (
    destRef: number,
    destIndex: number,
    srcRef: number,
    srcIndex: number,
    length: number,
) => number
Copies elements to a specified slice of an array from a given array.
Readonlyfill: (ref: number, index: number, value: number, size: number) => number
Fills a specified slice of an array with the given value.
Readonlyget: (
    ref: number,
    index: number,
    type: number,
    deprecated_isSigned?: boolean,
) => number
Gets an array entry with an unpacked type at an index.

Warning: .get() no longer takes the boolean isSigned argument, and assumes an unpacked type. For packed types, use .get_s() for signed and .get_u() for unsigned.
Readonlyget_s: (ref: number, index: number, type: number) => number
Gets an array entry with a signed packed type at an index.
Readonlyget_u: (ref: number, index: number, type: number) => number
Gets an array entry with an unsigned packed type at an index.
Readonlyinit_data: (
    name: string,
    ref: number,
    index: number,
    offset: number,
    size: number,
) => number
Copies elements to a specified slice of an array from a given data segment.
Readonlyinit_elem: (
    name: string,
    ref: number,
    index: number,
    offset: number,
    size: number,
) => number
Copies elements to a specified slice of an array from a given element segment.
Readonlylen: (ref: number) => number
Produces the length of an array.
Readonlynew: (heapType: number, size: number, operand: number) => number
Allocates a new array and initializes it with the given operand (repeated).
Readonlynew_data: (heapType: number, name: string, offset: number, size: number) => number
Allocates a new array and initializes it from a data segment.
Readonlynew_default: (heapType: number, size: number) => number
Allocates a new array and initializes it with a default value (repeated).
Readonlynew_elem: (heapType: number, name: string, offset: number, size: number) => number
Allocates a new array and initializes it from an element segment.
Readonlynew_fixed: (heapType: number, operands: readonly number[]) => number
Allocates a new array with the given operands and a statically fixed size.
Readonlyset: (ref: number, index: number, value: number) => number
Sets an array entry at an index.

`Readonly`atomic

atomic: { fence: () => number } = ...

`Readonly`block

block: (
    name: string | null,
    children: readonly number[],
    resultType?: number,
) => number = ...

Creates a (block).

`Readonly`br

br: (label: string, condition?: number, value?: number) => number = ...

Creates an unconditional branch (br) to a label.

`Readonly`br_if

br_if: (label: string, condition: number, value?: number) => number = ...

Creates a conditional branch (br_if) to a label.

`Readonly`br_on_cast

br_on_cast: (label: string, value: number, castType: number) => number = ...

Branches if the reference operand is successfully downcast to the given type.

`Readonly`br_on_cast_fail

br_on_cast_fail: (label: string, value: number, castType: number) => number = ...

Branches if the reference operand fails to downcast to the given type.

`Readonly`br_on_non_null

br_on_non_null: (label: string, value: number) => number = ...

Branches if the reference operand is not null.

`Readonly`br_on_null

br_on_null: (label: string, value: number) => number = ...

Branches if the reference operand is null.

`Readonly`br_table

br_table: (
    labels: readonly string[],
    defaultLabel: string,
    condition: number,
    value?: number,
) => number = ...

Creates a switch.

`Readonly`call

call: (name: string, operands: readonly number[], resultsType: number) => number = ...

Creates a call to a function. Note that we must specify the return type here as we may not have created the function being called yet.

`Readonly`call_indirect

call_indirect: (
    table: string,
    target: number,
    operands: readonly number[],
    paramsType: number,
    resultsType: number,
) => number = ...

Similar to call_ref, but indexes into a table to find the function to call.

`Readonly`call_ref

call_ref: (
    target: number,
    operands: readonly number[],
    resultsType: number,
) => number = ...

Similar to call, but takes a function reference operand instead of a name as the called value.

`Readonly`data

data: { drop: (segment: string) => number } = ...

Type Declaration

Readonlydrop: (segment: string) => number
Prevents further use of a passive data segment.

`Readonly`drop

drop: (value: number) => number = ...

Creates a (drop) of a value.

`Readonly`f32

f32: {
    abs: (value: number) => number;
    add: (left: number, right: number) => number;
    ceil: (value: number) => number;
    const: (value: number) => number;
    const_bits: (value: number) => number;
    convert_i32_s: (value: number) => number;
    convert_i32_u: (value: number) => number;
    convert_i64_s: (value: number) => number;
    convert_i64_u: (value: number) => number;
    convert_s: {
        i32: (...args: any[]) => number;
        i64: (...args: any[]) => number;
    };
    convert_u: {
        i32: (...args: any[]) => number;
        i64: (...args: any[]) => number;
    };
    copysign: (left: number, right: number) => number;
    demote_f64: (value: number) => number;
    div: (left: number, right: number) => number;
    eq: (left: number, right: number) => number;
    floor: (value: number) => number;
    ge: (left: number, right: number) => number;
    gt: (left: number, right: number) => number;
    le: (left: number, right: number) => number;
    load: (offset: number, align: number, ptr: number, name?: string) => number;
    lt: (left: number, right: number) => number;
    max: (left: number, right: number) => number;
    min: (left: number, right: number) => number;
    mul: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    nearest: (value: number) => number;
    neg: (value: number) => number;
    reinterpret_i32: (value: number) => number;
    sqrt: (value: number) => number;
    store: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    sub: (left: number, right: number) => number;
    trunc: (value: number) => number;
    demote(...args: any[]): number;
    reinterpret(...args: any[]): number;
} = ...

Type Declaration

Readonlyabs: (value: number) => number
Readonlyadd: (left: number, right: number) => number
Readonlyceil: (value: number) => number
Readonlyconst: (value: number) => number
Return a static constant f32.
Readonlyconst_bits: (value: number) => number
Readonlyconvert_i32_s: (value: number) => number
Readonlyconvert_i32_u: (value: number) => number
Readonlyconvert_i64_s: (value: number) => number
Readonlyconvert_i64_u: (value: number) => number
Readonlyconvert_s: { i32: (...args: any[]) => number; i64: (...args: any[]) => number }
Deprecated
- Readonlyi32: (...args: any[]) => number
  Deprecated
  Use .convert_i32_s() instead.
- Readonlyi64: (...args: any[]) => number
  Deprecated
  Use .convert_i64_s() instead.
Readonlyconvert_u: { i32: (...args: any[]) => number; i64: (...args: any[]) => number }
Deprecated
- Readonlyi32: (...args: any[]) => number
  Deprecated
  Use .convert_i32_u() instead.
- Readonlyi64: (...args: any[]) => number
  Deprecated
  Use .convert_i64_u() instead.
Readonlycopysign: (left: number, right: number) => number
Readonlydemote_f64: (value: number) => number
Readonlydiv: (left: number, right: number) => number
Readonlyeq: (left: number, right: number) => number
Readonlyfloor: (value: number) => number
Readonlyge: (left: number, right: number) => number
Readonlygt: (left: number, right: number) => number
Readonlyle: (left: number, right: number) => number
Readonlyload: (offset: number, align: number, ptr: number, name?: string) => number
Readonlylt: (left: number, right: number) => number
Readonlymax: (left: number, right: number) => number
Readonlymin: (left: number, right: number) => number
Readonlymul: (left: number, right: number) => number
Readonlyne: (left: number, right: number) => number
Readonlynearest: (value: number) => number
Readonlyneg: (value: number) => number
Readonlyreinterpret_i32: (value: number) => number
Readonlysqrt: (value: number) => number
Readonlystore: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlysub: (left: number, right: number) => number
Readonlytrunc: (value: number) => number
demote: function
- demote(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use .demote_f64() instead.
  - Defined in services/expression-builder/f32.ts:88
reinterpret: function
- reinterpret(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use .reinterpret_i32() instead.
  - Defined in services/expression-builder/f32.ts:86

`Readonly`f32x4

f32x4: {
    abs: (value: number) => number;
    add: (left: number, right: number) => number;
    ceil: (value: number) => number;
    convert_i32x4_s: (value: number) => number;
    convert_i32x4_u: (value: number) => number;
    demote_f64x2_zero: (value: number) => number;
    div: (left: number, right: number) => number;
    eq: (left: number, right: number) => number;
    extract_lane: (vec: number, index: number) => number;
    floor: (value: number) => number;
    ge: (left: number, right: number) => number;
    gt: (left: number, right: number) => number;
    le: (left: number, right: number) => number;
    lt: (left: number, right: number) => number;
    max: (left: number, right: number) => number;
    min: (left: number, right: number) => number;
    mul: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    nearest: (value: number) => number;
    neg: (value: number) => number;
    pmax: (left: number, right: number) => number;
    pmin: (left: number, right: number) => number;
    replace_lane: (vec: number, index: number, value: number) => number;
    splat: (value: number) => number;
    sqrt: (value: number) => number;
    sub: (left: number, right: number) => number;
    trunc: (value: number) => number;
} = ...

`Readonly`f64

f64: {
    abs: (value: number) => number;
    add: (left: number, right: number) => number;
    ceil: (value: number) => number;
    const: (value: number) => number;
    const_bits: (value: number | bigint) => number;
    convert_i32_s: (value: number) => number;
    convert_i32_u: (value: number) => number;
    convert_i64_s: (value: number) => number;
    convert_i64_u: (value: number) => number;
    convert_s: {
        i32: (...args: any[]) => number;
        i64: (...args: any[]) => number;
    };
    convert_u: {
        i32: (...args: any[]) => number;
        i64: (...args: any[]) => number;
    };
    copysign: (left: number, right: number) => number;
    div: (left: number, right: number) => number;
    eq: (left: number, right: number) => number;
    floor: (value: number) => number;
    ge: (left: number, right: number) => number;
    gt: (left: number, right: number) => number;
    le: (left: number, right: number) => number;
    load: (offset: number, align: number, ptr: number, name?: string) => number;
    lt: (left: number, right: number) => number;
    max: (left: number, right: number) => number;
    min: (left: number, right: number) => number;
    mul: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    nearest: (value: number) => number;
    neg: (value: number) => number;
    promote_f32: (value: number) => number;
    reinterpret_f64: (value: number) => number;
    sqrt: (value: number) => number;
    store: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    sub: (left: number, right: number) => number;
    trunc: (value: number) => number;
    promote(...args: any[]): number;
    reinterpret(...args: any[]): any;
} = ...

Type Declaration

Readonlyabs: (value: number) => number
Readonlyadd: (left: number, right: number) => number
Readonlyceil: (value: number) => number
Readonlyconst: (value: number) => number
Return a static constant f64.
Readonlyconst_bits: (value: number | bigint) => number
Readonlyconvert_i32_s: (value: number) => number
Readonlyconvert_i32_u: (value: number) => number
Readonlyconvert_i64_s: (value: number) => number
Readonlyconvert_i64_u: (value: number) => number
Readonlyconvert_s: { i32: (...args: any[]) => number; i64: (...args: any[]) => number }
Deprecated
- Readonlyi32: (...args: any[]) => number
  Deprecated
  Use .convert_i32_s() instead.
- Readonlyi64: (...args: any[]) => number
  Deprecated
  Use .convert_i64_s() instead.
Readonlyconvert_u: { i32: (...args: any[]) => number; i64: (...args: any[]) => number }
Deprecated
- Readonlyi32: (...args: any[]) => number
  Deprecated
  Use .convert_i32_u() instead.
- Readonlyi64: (...args: any[]) => number
  Deprecated
  Use .convert_i64_u() instead.
Readonlycopysign: (left: number, right: number) => number
Readonlydiv: (left: number, right: number) => number
Readonlyeq: (left: number, right: number) => number
Readonlyfloor: (value: number) => number
Readonlyge: (left: number, right: number) => number
Readonlygt: (left: number, right: number) => number
Readonlyle: (left: number, right: number) => number
Readonlyload: (offset: number, align: number, ptr: number, name?: string) => number
Readonlylt: (left: number, right: number) => number
Readonlymax: (left: number, right: number) => number
Readonlymin: (left: number, right: number) => number
Readonlymul: (left: number, right: number) => number
Readonlyne: (left: number, right: number) => number
Readonlynearest: (value: number) => number
Readonlyneg: (value: number) => number
Readonlypromote_f32: (value: number) => number
Readonlyreinterpret_f64: (value: number) => number
Readonlysqrt: (value: number) => number
Readonlystore: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlysub: (left: number, right: number) => number
Readonlytrunc: (value: number) => number
promote: function
- promote(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use .promote_f32() instead.
  - Defined in services/expression-builder/f64.ts:88
reinterpret: function
- reinterpret(...args: any[]): any
  Parameters
  - ...args: any[]
  Returns any
  Deprecated
  Use .reinterpret_i64() instead.
  - Defined in services/expression-builder/f64.ts:86

`Readonly`f64x2

f64x2: {
    abs: (value: number) => number;
    add: (left: number, right: number) => number;
    ceil: (value: number) => number;
    convert_low_i32x4_s: (value: number) => number;
    convert_low_i32x4_u: (value: number) => number;
    div: (left: number, right: number) => number;
    eq: (left: number, right: number) => number;
    extract_lane: (vec: number, index: number) => number;
    floor: (value: number) => number;
    ge: (left: number, right: number) => number;
    gt: (left: number, right: number) => number;
    le: (left: number, right: number) => number;
    lt: (left: number, right: number) => number;
    max: (left: number, right: number) => number;
    min: (left: number, right: number) => number;
    mul: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    nearest: (value: number) => number;
    neg: (value: number) => number;
    pmax: (left: number, right: number) => number;
    pmin: (left: number, right: number) => number;
    promote_low_f32x4: (value: number) => number;
    replace_lane: (vec: number, index: number, value: number) => number;
    splat: (value: number) => number;
    sqrt: (value: number) => number;
    sub: (left: number, right: number) => number;
    trunc: (value: number) => number;
} = ...

`Readonly`global

global: {
get: (name: string, typ: number) => number;
set: (name: string, value: number) => number;
} = ...

Type Declaration

Readonlyget: (name: string, typ: number) => number
Creates a (global.get) for the global with the specified name. Note that we must specify the type here as we may not have created the global being accessed yet.
Readonlyset: (name: string, value: number) => number
Creates a (global.set) for the global with the specified name.

`Readonly`i16x8

i16x8: {
    abs: (value: number) => number;
    add: (left: number, right: number) => number;
    add_sat_s: (left: number, right: number) => number;
    add_sat_u: (left: number, right: number) => number;
    all_true: (value: number) => number;
    avgr_u: (left: number, right: number) => number;
    bitmask: (value: number) => number;
    eq: (left: number, right: number) => number;
    extadd_pairwise_i8x16_s: (value: number) => number;
    extadd_pairwise_i8x16_u: (value: number) => number;
    extend_high_i8x16_s: (value: number) => number;
    extend_high_i8x16_u: (value: number) => number;
    extend_low_i8x16_s: (value: number) => number;
    extend_low_i8x16_u: (value: number) => number;
    extmul_high_i8x16_s: (left: number, right: number) => number;
    extmul_high_i8x16_u: (left: number, right: number) => number;
    extmul_low_i8x16_s: (left: number, right: number) => number;
    extmul_low_i8x16_u: (left: number, right: number) => number;
    extract_lane_s: (vec: number, index: number) => number;
    extract_lane_u: (vec: number, index: number) => number;
    ge_s: (left: number, right: number) => number;
    ge_u: (left: number, right: number) => number;
    gt_s: (left: number, right: number) => number;
    gt_u: (left: number, right: number) => number;
    le_s: (left: number, right: number) => number;
    le_u: (left: number, right: number) => number;
    lt_s: (left: number, right: number) => number;
    lt_u: (left: number, right: number) => number;
    max_s: (left: number, right: number) => number;
    max_u: (left: number, right: number) => number;
    min_s: (left: number, right: number) => number;
    min_u: (left: number, right: number) => number;
    mul: (left: number, right: number) => number;
    narrow_i32x4_s: (left: number, right: number) => number;
    narrow_i32x4_u: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    neg: (value: number) => number;
    q15mulr_sat_s: (left: number, right: number) => number;
    replace_lane: (vec: number, index: number, value: number) => number;
    shl: (vec: number, shift: number) => number;
    shr_s: (vec: number, shift: number) => number;
    shr_u: (vec: number, shift: number) => number;
    splat: (value: number) => number;
    sub: (left: number, right: number) => number;
    sub_sat_s: (left: number, right: number) => number;
    sub_sat_u: (left: number, right: number) => number;
    add_saturate_s(...args: any[]): number;
    add_saturate_u(...args: any[]): number;
    sub_saturate_s(...args: any[]): number;
    sub_saturate_u(...args: any[]): number;
} = ...

Type Declaration

Readonlyabs: (value: number) => number
Readonlyadd: (left: number, right: number) => number
Readonlyadd_sat_s: (left: number, right: number) => number
Readonlyadd_sat_u: (left: number, right: number) => number
Readonlyall_true: (value: number) => number
Readonlyavgr_u: (left: number, right: number) => number
Readonlybitmask: (value: number) => number
Readonlyeq: (left: number, right: number) => number
Readonlyextadd_pairwise_i8x16_s: (value: number) => number
Readonlyextadd_pairwise_i8x16_u: (value: number) => number
Readonlyextend_high_i8x16_s: (value: number) => number
Readonlyextend_high_i8x16_u: (value: number) => number
Readonlyextend_low_i8x16_s: (value: number) => number
Readonlyextend_low_i8x16_u: (value: number) => number
Readonlyextmul_high_i8x16_s: (left: number, right: number) => number
Readonlyextmul_high_i8x16_u: (left: number, right: number) => number
Readonlyextmul_low_i8x16_s: (left: number, right: number) => number
Readonlyextmul_low_i8x16_u: (left: number, right: number) => number
Readonlyextract_lane_s: (vec: number, index: number) => number
Readonlyextract_lane_u: (vec: number, index: number) => number
Readonlyge_s: (left: number, right: number) => number
Readonlyge_u: (left: number, right: number) => number
Readonlygt_s: (left: number, right: number) => number
Readonlygt_u: (left: number, right: number) => number
Readonlyle_s: (left: number, right: number) => number
Readonlyle_u: (left: number, right: number) => number
Readonlylt_s: (left: number, right: number) => number
Readonlylt_u: (left: number, right: number) => number
Readonlymax_s: (left: number, right: number) => number
Readonlymax_u: (left: number, right: number) => number
Readonlymin_s: (left: number, right: number) => number
Readonlymin_u: (left: number, right: number) => number
Readonlymul: (left: number, right: number) => number
Readonlynarrow_i32x4_s: (left: number, right: number) => number
Readonlynarrow_i32x4_u: (left: number, right: number) => number
Readonlyne: (left: number, right: number) => number
Readonlyneg: (value: number) => number
Readonlyq15mulr_sat_s: (left: number, right: number) => number
Readonlyreplace_lane: (vec: number, index: number, value: number) => number
Readonlyshl: (vec: number, shift: number) => number
Readonlyshr_s: (vec: number, shift: number) => number
Readonlyshr_u: (vec: number, shift: number) => number
Readonlysplat: (value: number) => number
Readonlysub: (left: number, right: number) => number
Readonlysub_sat_s: (left: number, right: number) => number
Readonlysub_sat_u: (left: number, right: number) => number
add_saturate_s: function
- add_saturate_s(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#i16x8.add_sat_s instead.
  - Defined in services/expression-builder/i16x8.ts:87
add_saturate_u: function
- add_saturate_u(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#i16x8.add_sat_u instead.
  - Defined in services/expression-builder/i16x8.ts:89
sub_saturate_s: function
- sub_saturate_s(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#i16x8.sub_sat_s instead.
  - Defined in services/expression-builder/i16x8.ts:91
sub_saturate_u: function
- sub_saturate_u(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#i16x8.sub_sat_u instead.
  - Defined in services/expression-builder/i16x8.ts:93

`Readonly`i31

i31: { get_s: (value: number) => number; get_u: (value: number) => number } = ...

Type Declaration

Readonlyget_s: (value: number) => number
Converts an unboxed scalar to type i32, signed.
Readonlyget_u: (value: number) => number
Converts an unboxed scalar to type i32, unsigned.

`Readonly`i32

i32: {
    add: (left: number, right: number) => number;
    and: (left: number, right: number) => number;
    atomic: {
        load: (
            offset: number,
            ptr: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        load16_u: (
            offset: number,
            ptr: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        load8_u: (
            offset: number,
            ptr: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        rmw: {
            add: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            and: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            cmpxchg: (
                offset: number,
                ptr: number,
                expected: number,
                replacement: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            or: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            sub: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xchg: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xor: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
        };
        rmw16_u: {
            add: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            and: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            cmpxchg: (
                offset: number,
                ptr: number,
                expected: number,
                replacement: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            or: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            sub: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xchg: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xor: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
        };
        rmw8_u: {
            add: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            and: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            cmpxchg: (
                offset: number,
                ptr: number,
                expected: number,
                replacement: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            or: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            sub: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xchg: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xor: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
        };
        store: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        store16: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        store8: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
    };
    clz: (value: number) => number;
    const: (value: number) => number;
    ctz: (value: number) => number;
    div_s: (left: number, right: number) => number;
    div_u: (left: number, right: number) => number;
    eq: (left: number, right: number) => number;
    eqz: (value: number) => number;
    extend16_s: (value: number) => number;
    extend8_s: (value: number) => number;
    ge_s: (left: number, right: number) => number;
    ge_u: (left: number, right: number) => number;
    gt_s: (left: number, right: number) => number;
    gt_u: (left: number, right: number) => number;
    le_s: (left: number, right: number) => number;
    le_u: (left: number, right: number) => number;
    load: (offset: number, align: number, ptr: number, name?: string) => number;
    load16_s: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load16_u: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load8_s: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load8_u: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    lt_s: (left: number, right: number) => number;
    lt_u: (left: number, right: number) => number;
    mul: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    or: (left: number, right: number) => number;
    popcnt: (value: number) => number;
    reinterpret_f32: (value: number) => number;
    rem_s: (left: number, right: number) => number;
    rem_u: (left: number, right: number) => number;
    rotl: (left: number, right: number) => number;
    rotr: (left: number, right: number) => number;
    shl: (left: number, right: number) => number;
    shr_s: (left: number, right: number) => number;
    shr_u: (left: number, right: number) => number;
    store: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    store16: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    store8: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    sub: (left: number, right: number) => number;
    trunc_f32_s: (value: number) => number;
    trunc_f32_u: (value: number) => number;
    trunc_f64_s: (value: number) => number;
    trunc_f64_u: (value: number) => number;
    trunc_s: {
        f32: (...args: any[]) => number;
        f64: (...args: any[]) => number;
    };
    trunc_s_sat: {
        f32: (...args: any[]) => number;
        f64: (...args: any[]) => number;
    };
    trunc_sat_f32_s: (value: number) => number;
    trunc_sat_f32_u: (value: number) => number;
    trunc_sat_f64_s: (value: number) => number;
    trunc_sat_f64_u: (value: number) => number;
    trunc_u: {
        f32: (...args: any[]) => number;
        f64: (...args: any[]) => number;
    };
    trunc_u_sat: {
        f32: (...args: any[]) => number;
        f64: (...args: any[]) => number;
    };
    wrap_i64: (value: number) => number;
    xor: (left: number, right: number) => number;
    reinterpret(...args: any[]): number;
    wrap(...args: any[]): number;
} = ...

Type Declaration

Readonlyadd: (left: number, right: number) => number
Readonlyand: (left: number, right: number) => number
Readonly Experimentalatomic: {
    load: (
        offset: number,
        ptr: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    load16_u: (
        offset: number,
        ptr: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    load8_u: (
        offset: number,
        ptr: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    rmw: {
        add: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        and: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        cmpxchg: (
            offset: number,
            ptr: number,
            expected: number,
            replacement: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        or: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        sub: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xchg: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xor: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
    };
    rmw16_u: {
        add: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        and: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        cmpxchg: (
            offset: number,
            ptr: number,
            expected: number,
            replacement: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        or: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        sub: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xchg: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xor: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
    };
    rmw8_u: {
        add: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        and: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        cmpxchg: (
            offset: number,
            ptr: number,
            expected: number,
            replacement: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        or: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        sub: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xchg: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xor: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
    };
    store: (
        offset: number,
        ptr: number,
        value: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    store16: (
        offset: number,
        ptr: number,
        value: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    store8: (
        offset: number,
        ptr: number,
        value: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
}
Readonlyclz: (value: number) => number
Readonlyconst: (value: number) => number
Return a static constant i32.
Readonlyctz: (value: number) => number
Readonlydiv_s: (left: number, right: number) => number
Readonlydiv_u: (left: number, right: number) => number
Readonlyeq: (left: number, right: number) => number
Readonlyeqz: (value: number) => number
Readonlyextend16_s: (value: number) => number
Readonlyextend8_s: (value: number) => number
Readonlyge_s: (left: number, right: number) => number
Readonlyge_u: (left: number, right: number) => number
Readonlygt_s: (left: number, right: number) => number
Readonlygt_u: (left: number, right: number) => number
Readonlyle_s: (left: number, right: number) => number
Readonlyle_u: (left: number, right: number) => number
Readonlyload: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload16_s: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload16_u: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload8_s: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload8_u: (offset: number, align: number, ptr: number, name?: string) => number
Readonlylt_s: (left: number, right: number) => number
Readonlylt_u: (left: number, right: number) => number
Readonlymul: (left: number, right: number) => number
Readonlyne: (left: number, right: number) => number
Readonlyor: (left: number, right: number) => number
Readonlypopcnt: (value: number) => number
Readonlyreinterpret_f32: (value: number) => number
Readonlyrem_s: (left: number, right: number) => number
Readonlyrem_u: (left: number, right: number) => number
Readonlyrotl: (left: number, right: number) => number
Readonlyrotr: (left: number, right: number) => number
Readonlyshl: (left: number, right: number) => number
Readonlyshr_s: (left: number, right: number) => number
Readonlyshr_u: (left: number, right: number) => number
Readonlystore: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlystore16: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlystore8: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlysub: (left: number, right: number) => number
Readonlytrunc_f32_s: (value: number) => number
Readonlytrunc_f32_u: (value: number) => number
Readonlytrunc_f64_s: (value: number) => number
Readonlytrunc_f64_u: (value: number) => number
Readonlytrunc_s: { f32: (...args: any[]) => number; f64: (...args: any[]) => number }
Deprecated
- Readonlyf32: (...args: any[]) => number
  Deprecated
  Use .trunc_f32_s() instead.
- Readonlyf64: (...args: any[]) => number
  Deprecated
  Use .trunc_f64_s() instead.
Readonlytrunc_s_sat: { f32: (...args: any[]) => number; f64: (...args: any[]) => number }
Deprecated
- Readonlyf32: (...args: any[]) => number
  Deprecated
  Use .trunc_sat_f32_s() instead.
- Readonlyf64: (...args: any[]) => number
  Deprecated
  Use .trunc_sat_f64_s() instead.
Readonlytrunc_sat_f32_s: (value: number) => number
Readonlytrunc_sat_f32_u: (value: number) => number
Readonlytrunc_sat_f64_s: (value: number) => number
Readonlytrunc_sat_f64_u: (value: number) => number
Readonlytrunc_u: { f32: (...args: any[]) => number; f64: (...args: any[]) => number }
Deprecated
- Readonlyf32: (...args: any[]) => number
  Deprecated
  Use .trunc_f32_u() instead.
- Readonlyf64: (...args: any[]) => number
  Deprecated
  Use .trunc_f64_u() instead.
Readonlytrunc_u_sat: { f32: (...args: any[]) => number; f64: (...args: any[]) => number }
Deprecated
- Readonlyf32: (...args: any[]) => number
  Deprecated
  Use .trunc_sat_f32_u() instead.
- Readonlyf64: (...args: any[]) => number
  Deprecated
  Use .trunc_sat_f64_u() instead.
Readonlywrap_i64: (value: number) => number
Readonlyxor: (left: number, right: number) => number
reinterpret: function
- reinterpret(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use .reinterpret_f32() instead.
  - Defined in services/expression-builder/i32.ts:146
wrap: function
- wrap(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use .wrap_i64() instead.
  - Defined in services/expression-builder/i32.ts:116

`Readonly`i32x4

i32x4: {
    abs: (value: number) => number;
    add: (left: number, right: number) => number;
    all_true: (value: number) => number;
    bitmask: (value: number) => number;
    dot_i16x8_s: (left: number, right: number) => number;
    eq: (left: number, right: number) => number;
    extadd_pairwise_i16x8_s: (value: number) => number;
    extadd_pairwise_i16x8_u: (value: number) => number;
    extend_high_i16x8_s: (value: number) => number;
    extend_high_i16x8_u: (value: number) => number;
    extend_low_i16x8_s: (value: number) => number;
    extend_low_i16x8_u: (value: number) => number;
    extmul_high_i16x8_s: (left: number, right: number) => number;
    extmul_high_i16x8_u: (left: number, right: number) => number;
    extmul_low_i16x8_s: (left: number, right: number) => number;
    extmul_low_i16x8_u: (left: number, right: number) => number;
    extract_lane: (vec: number, index: number) => number;
    ge_s: (left: number, right: number) => number;
    ge_u: (left: number, right: number) => number;
    gt_s: (left: number, right: number) => number;
    gt_u: (left: number, right: number) => number;
    le_s: (left: number, right: number) => number;
    le_u: (left: number, right: number) => number;
    lt_s: (left: number, right: number) => number;
    lt_u: (left: number, right: number) => number;
    max_s: (left: number, right: number) => number;
    max_u: (left: number, right: number) => number;
    min_s: (left: number, right: number) => number;
    min_u: (left: number, right: number) => number;
    mul: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    neg: (value: number) => number;
    replace_lane: (vec: number, index: number, value: number) => number;
    shl: (vec: number, shift: number) => number;
    shr_s: (vec: number, shift: number) => number;
    shr_u: (vec: number, shift: number) => number;
    splat: (value: number) => number;
    sub: (left: number, right: number) => number;
    trunc_sat_f32x4_s: (value: number) => number;
    trunc_sat_f32x4_u: (value: number) => number;
    trunc_sat_f64x2_s_zero: (value: number) => number;
    trunc_sat_f64x2_u_zero: (value: number) => number;
} = ...

`Readonly`i64

i64: {
    add: (left: number, right: number) => number;
    add128: (
        leftLow: number,
        leftHigh: number,
        rightLow: number,
        rightHigh: number,
    ) => number;
    and: (left: number, right: number) => number;
    atomic: {
        load: (
            offset: number,
            ptr: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        load16_u: (
            offset: number,
            ptr: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        load32_u: (
            offset: number,
            ptr: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        load8_u: (
            offset: number,
            ptr: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        rmw: {
            add: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            and: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            cmpxchg: (
                offset: number,
                ptr: number,
                expected: number,
                replacement: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            or: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            sub: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xchg: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xor: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
        };
        rmw16_u: {
            add: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            and: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            cmpxchg: (
                offset: number,
                ptr: number,
                expected: number,
                replacement: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            or: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            sub: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xchg: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xor: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
        };
        rmw32_u: {
            add: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            and: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            cmpxchg: (
                offset: number,
                ptr: number,
                expected: number,
                replacement: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            or: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            sub: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xchg: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xor: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
        };
        rmw8_u: {
            add: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            and: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            cmpxchg: (
                offset: number,
                ptr: number,
                expected: number,
                replacement: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            or: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            sub: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xchg: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
            xor: (
                offset: number,
                ptr: number,
                value: number,
                name?: string,
                order?: MemoryOrder,
            ) => number;
        };
        store: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        store16: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        store32: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        store8: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
    };
    clz: (value: number) => number;
    const: (value: number | bigint) => number;
    ctz: (value: number) => number;
    div_s: (left: number, right: number) => number;
    div_u: (left: number, right: number) => number;
    eq: (left: number, right: number) => number;
    eqz: (value: number) => number;
    extend_i32_s: (value: number) => number;
    extend_i32_u: (value: number) => number;
    extend16_s: (value: number) => number;
    extend32_s: (value: number) => number;
    extend8_s: (value: number) => number;
    ge_s: (left: number, right: number) => number;
    ge_u: (left: number, right: number) => number;
    gt_s: (left: number, right: number) => number;
    gt_u: (left: number, right: number) => number;
    le_s: (left: number, right: number) => number;
    le_u: (left: number, right: number) => number;
    load: (offset: number, align: number, ptr: number, name?: string) => number;
    load16_s: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load16_u: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load32_s: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load32_u: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load8_s: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load8_u: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    lt_s: (left: number, right: number) => number;
    lt_u: (left: number, right: number) => number;
    mul: (left: number, right: number) => number;
    mul_wide_s: (left: number, right: number) => number;
    mul_wide_u: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    or: (left: number, right: number) => number;
    popcnt: (value: number) => number;
    reinterpret_f64: (value: number) => number;
    rem_s: (left: number, right: number) => number;
    rem_u: (left: number, right: number) => number;
    rotl: (left: number, right: number) => number;
    rotr: (left: number, right: number) => number;
    shl: (left: number, right: number) => number;
    shr_s: (left: number, right: number) => number;
    shr_u: (left: number, right: number) => number;
    store: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    store16: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    store32: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    store8: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    sub: (left: number, right: number) => number;
    sub128: (
        leftLow: number,
        leftHigh: number,
        rightLow: number,
        rightHigh: number,
    ) => number;
    trunc_f32_s: (value: number) => number;
    trunc_f32_u: (value: number) => number;
    trunc_f64_s: (value: number) => number;
    trunc_f64_u: (value: number) => number;
    trunc_s: {
        f32: (...args: any[]) => number;
        f64: (...args: any[]) => number;
    };
    trunc_s_sat: {
        f32: (...args: any[]) => number;
        f64: (...args: any[]) => number;
    };
    trunc_sat_f32_s: (value: number) => number;
    trunc_sat_f32_u: (value: number) => number;
    trunc_sat_f64_s: (value: number) => number;
    trunc_sat_f64_u: (value: number) => number;
    trunc_u: {
        f32: (...args: any[]) => number;
        f64: (...args: any[]) => number;
    };
    trunc_u_sat: {
        f32: (...args: any[]) => number;
        f64: (...args: any[]) => number;
    };
    xor: (left: number, right: number) => number;
    extend_s(...args: any[]): number;
    extend_u(...args: any[]): number;
    reinterpret(...args: any[]): number;
} = ...

Type Declaration

Readonlyadd: (left: number, right: number) => number
Readonlyadd128: (
    leftLow: number,
    leftHigh: number,
    rightLow: number,
    rightHigh: number,
) => number
Readonlyand: (left: number, right: number) => number
Readonly Experimentalatomic: {
    load: (
        offset: number,
        ptr: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    load16_u: (
        offset: number,
        ptr: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    load32_u: (
        offset: number,
        ptr: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    load8_u: (
        offset: number,
        ptr: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    rmw: {
        add: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        and: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        cmpxchg: (
            offset: number,
            ptr: number,
            expected: number,
            replacement: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        or: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        sub: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xchg: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xor: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
    };
    rmw16_u: {
        add: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        and: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        cmpxchg: (
            offset: number,
            ptr: number,
            expected: number,
            replacement: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        or: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        sub: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xchg: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xor: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
    };
    rmw32_u: {
        add: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        and: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        cmpxchg: (
            offset: number,
            ptr: number,
            expected: number,
            replacement: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        or: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        sub: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xchg: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xor: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
    };
    rmw8_u: {
        add: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        and: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        cmpxchg: (
            offset: number,
            ptr: number,
            expected: number,
            replacement: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        or: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        sub: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xchg: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
        xor: (
            offset: number,
            ptr: number,
            value: number,
            name?: string,
            order?: MemoryOrder,
        ) => number;
    };
    store: (
        offset: number,
        ptr: number,
        value: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    store16: (
        offset: number,
        ptr: number,
        value: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    store32: (
        offset: number,
        ptr: number,
        value: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
    store8: (
        offset: number,
        ptr: number,
        value: number,
        name?: string,
        order?: MemoryOrder,
    ) => number;
}
Readonlyclz: (value: number) => number
Readonlyconst: (value: number | bigint) => number
Return a static constant i64.
Readonlyctz: (value: number) => number
Readonlydiv_s: (left: number, right: number) => number
Readonlydiv_u: (left: number, right: number) => number
Readonlyeq: (left: number, right: number) => number
Readonlyeqz: (value: number) => number
Readonlyextend_i32_s: (value: number) => number
Readonlyextend_i32_u: (value: number) => number
Readonlyextend16_s: (value: number) => number
Readonlyextend32_s: (value: number) => number
Readonlyextend8_s: (value: number) => number
Readonlyge_s: (left: number, right: number) => number
Readonlyge_u: (left: number, right: number) => number
Readonlygt_s: (left: number, right: number) => number
Readonlygt_u: (left: number, right: number) => number
Readonlyle_s: (left: number, right: number) => number
Readonlyle_u: (left: number, right: number) => number
Readonlyload: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload16_s: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload16_u: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload32_s: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload32_u: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload8_s: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload8_u: (offset: number, align: number, ptr: number, name?: string) => number
Readonlylt_s: (left: number, right: number) => number
Readonlylt_u: (left: number, right: number) => number
Readonlymul: (left: number, right: number) => number
Readonlymul_wide_s: (left: number, right: number) => number
Readonlymul_wide_u: (left: number, right: number) => number
Readonlyne: (left: number, right: number) => number
Readonlyor: (left: number, right: number) => number
Readonlypopcnt: (value: number) => number
Readonlyreinterpret_f64: (value: number) => number
Readonlyrem_s: (left: number, right: number) => number
Readonlyrem_u: (left: number, right: number) => number
Readonlyrotl: (left: number, right: number) => number
Readonlyrotr: (left: number, right: number) => number
Readonlyshl: (left: number, right: number) => number
Readonlyshr_s: (left: number, right: number) => number
Readonlyshr_u: (left: number, right: number) => number
Readonlystore: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlystore16: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlystore32: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlystore8: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlysub: (left: number, right: number) => number
Readonlysub128: (
    leftLow: number,
    leftHigh: number,
    rightLow: number,
    rightHigh: number,
) => number
Readonlytrunc_f32_s: (value: number) => number
Readonlytrunc_f32_u: (value: number) => number
Readonlytrunc_f64_s: (value: number) => number
Readonlytrunc_f64_u: (value: number) => number
Readonlytrunc_s: { f32: (...args: any[]) => number; f64: (...args: any[]) => number }
Deprecated
- Readonlyf32: (...args: any[]) => number
  Deprecated
  Use .trunc_f32_s() instead.
- Readonlyf64: (...args: any[]) => number
  Deprecated
  Use .trunc_f64_s() instead.
Readonlytrunc_s_sat: { f32: (...args: any[]) => number; f64: (...args: any[]) => number }
Deprecated
- Readonlyf32: (...args: any[]) => number
  Deprecated
  Use .trunc_sat_f32_s() instead.
- Readonlyf64: (...args: any[]) => number
  Deprecated
  Use .trunc_sat_f64_s() instead.
Readonlytrunc_sat_f32_s: (value: number) => number
Readonlytrunc_sat_f32_u: (value: number) => number
Readonlytrunc_sat_f64_s: (value: number) => number
Readonlytrunc_sat_f64_u: (value: number) => number
Readonlytrunc_u: { f32: (...args: any[]) => number; f64: (...args: any[]) => number }
Deprecated
- Readonlyf32: (...args: any[]) => number
  Deprecated
  Use .trunc_f32_u() instead.
- Readonlyf64: (...args: any[]) => number
  Deprecated
  Use .trunc_f64_u() instead.
Readonlytrunc_u_sat: { f32: (...args: any[]) => number; f64: (...args: any[]) => number }
Deprecated
- Readonlyf32: (...args: any[]) => number
  Deprecated
  Use .trunc_sat_f32_u() instead.
- Readonlyf64: (...args: any[]) => number
  Deprecated
  Use .trunc_sat_f64_u() instead.
Readonlyxor: (left: number, right: number) => number
extend_s: function
- extend_s(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use .extend_i32_s() instead.
  - Defined in services/expression-builder/i64.ts:146
extend_u: function
- extend_u(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use .extend_i32_u() instead.
  - Defined in services/expression-builder/i64.ts:148
reinterpret: function
- reinterpret(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use .reinterpret_f64() instead.
  - Defined in services/expression-builder/i64.ts:178

`Readonly`i64x2

i64x2: {
    abs: (value: number) => number;
    add: (left: number, right: number) => number;
    all_true: (value: number) => number;
    bitmask: (value: number) => number;
    eq: (left: number, right: number) => number;
    extend_high_i32x4_s: (value: number) => number;
    extend_high_i32x4_u: (value: number) => number;
    extend_low_i32x4_s: (value: number) => number;
    extend_low_i32x4_u: (value: number) => number;
    extmul_high_i32x4_s: (left: number, right: number) => number;
    extmul_high_i32x4_u: (left: number, right: number) => number;
    extmul_low_i32x4_s: (left: number, right: number) => number;
    extmul_low_i32x4_u: (left: number, right: number) => number;
    extract_lane: (vec: number, index: number) => number;
    ge_s: (left: number, right: number) => number;
    gt_s: (left: number, right: number) => number;
    le_s: (left: number, right: number) => number;
    lt_s: (left: number, right: number) => number;
    mul: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    neg: (value: number) => number;
    replace_lane: (vec: number, index: number, value: number) => number;
    shl: (vec: number, shift: number) => number;
    shr_s: (vec: number, shift: number) => number;
    shr_u: (vec: number, shift: number) => number;
    splat: (value: number) => number;
    sub: (left: number, right: number) => number;
} = ...

`Readonly`i8x16

i8x16: {
    abs: (value: number) => number;
    add: (left: number, right: number) => number;
    add_sat_s: (left: number, right: number) => number;
    add_sat_u: (left: number, right: number) => number;
    all_true: (value: number) => number;
    avgr_u: (left: number, right: number) => number;
    bitmask: (value: number) => number;
    eq: (left: number, right: number) => number;
    extract_lane_s: (vec: number, index: number) => number;
    extract_lane_u: (vec: number, index: number) => number;
    ge_s: (left: number, right: number) => number;
    ge_u: (left: number, right: number) => number;
    gt_s: (left: number, right: number) => number;
    gt_u: (left: number, right: number) => number;
    le_s: (left: number, right: number) => number;
    le_u: (left: number, right: number) => number;
    lt_s: (left: number, right: number) => number;
    lt_u: (left: number, right: number) => number;
    max_s: (left: number, right: number) => number;
    max_u: (left: number, right: number) => number;
    min_s: (left: number, right: number) => number;
    min_u: (left: number, right: number) => number;
    narrow_i16x8_s: (left: number, right: number) => number;
    narrow_i16x8_u: (left: number, right: number) => number;
    ne: (left: number, right: number) => number;
    neg: (value: number) => number;
    popcnt: (value: number) => number;
    replace_lane: (vec: number, index: number, value: number) => number;
    shl: (vec: number, shift: number) => number;
    shr_s: (vec: number, shift: number) => number;
    shr_u: (vec: number, shift: number) => number;
    shuffle: (left: number, right: number, mask: readonly number[]) => number;
    splat: (value: number) => number;
    sub: (left: number, right: number) => number;
    sub_sat_s: (left: number, right: number) => number;
    sub_sat_u: (left: number, right: number) => number;
    swizzle: (left: number, right: number) => number;
    add_saturate_s(...args: any[]): number;
    add_saturate_u(...args: any[]): number;
    sub_saturate_s(...args: any[]): number;
    sub_saturate_u(...args: any[]): number;
} = ...

Type Declaration

Readonlyabs: (value: number) => number
Readonlyadd: (left: number, right: number) => number
Readonlyadd_sat_s: (left: number, right: number) => number
Readonlyadd_sat_u: (left: number, right: number) => number
Readonlyall_true: (value: number) => number
Readonlyavgr_u: (left: number, right: number) => number
Readonlybitmask: (value: number) => number
Readonlyeq: (left: number, right: number) => number
Readonlyextract_lane_s: (vec: number, index: number) => number
Readonlyextract_lane_u: (vec: number, index: number) => number
Readonlyge_s: (left: number, right: number) => number
Readonlyge_u: (left: number, right: number) => number
Readonlygt_s: (left: number, right: number) => number
Readonlygt_u: (left: number, right: number) => number
Readonlyle_s: (left: number, right: number) => number
Readonlyle_u: (left: number, right: number) => number
Readonlylt_s: (left: number, right: number) => number
Readonlylt_u: (left: number, right: number) => number
Readonlymax_s: (left: number, right: number) => number
Readonlymax_u: (left: number, right: number) => number
Readonlymin_s: (left: number, right: number) => number
Readonlymin_u: (left: number, right: number) => number
Readonlynarrow_i16x8_s: (left: number, right: number) => number
Readonlynarrow_i16x8_u: (left: number, right: number) => number
Readonlyne: (left: number, right: number) => number
Readonlyneg: (value: number) => number
Readonlypopcnt: (value: number) => number
Readonlyreplace_lane: (vec: number, index: number, value: number) => number
Readonlyshl: (vec: number, shift: number) => number
Readonlyshr_s: (vec: number, shift: number) => number
Readonlyshr_u: (vec: number, shift: number) => number
Readonlyshuffle: (left: number, right: number, mask: readonly number[]) => number
Readonlysplat: (value: number) => number
Readonlysub: (left: number, right: number) => number
Readonlysub_sat_s: (left: number, right: number) => number
Readonlysub_sat_u: (left: number, right: number) => number
Readonlyswizzle: (left: number, right: number) => number
add_saturate_s: function
- add_saturate_s(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#i8x16.add_sat_s instead.
  - Defined in services/expression-builder/i8x16.ts:85
add_saturate_u: function
- add_saturate_u(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#i8x16.add_sat_u instead.
  - Defined in services/expression-builder/i8x16.ts:87
sub_saturate_s: function
- sub_saturate_s(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#i8x16.sub_sat_s instead.
  - Defined in services/expression-builder/i8x16.ts:89
sub_saturate_u: function
- sub_saturate_u(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#i8x16.sub_sat_u instead.
  - Defined in services/expression-builder/i8x16.ts:91

`Readonly`if

if: (ifTrue: number, ifFalse: number) => number = ...

Creates an ‘if’ or ‘if/else’ combination.

`Readonly`local

local: {
    get: (index: number, typ: number) => number;
    set: (index: number, value: number) => number;
    tee: (index: number, value: number, typ: number) => number;
} = ...

Type Declaration

Readonlyget: (index: number, typ: number) => number
Creates a (local.get) for the local at the specified index. Note that we must specify the type here as we may not have created the local being accessed yet.
Readonlyset: (index: number, value: number) => number
Creates a (local.set) for the local at the specified index.
Readonlytee: (index: number, value: number, typ: number) => number
Creates a (local.tee) for the local at the specified index. Note that we must specify the type here as we may not have created the local being accessed yet.

`Readonly`loop

loop: (name: string, body: number) => number = ...

Creates a (loop).

`Readonly`memory

memory: {
    atomic: {
        notify: (ptr: number, notifyCount: number, name: string) => number;
        wait32: (
            ptr: number,
            expected: number,
            timeout: number,
            name: string,
        ) => number;
        wait64: (
            ptr: number,
            expected: number,
            timeout: number,
            name: string,
        ) => number;
    };
    copy: (
        dest: number,
        source: number,
        size: number,
        destMemory: string,
        sourceMemory: string,
    ) => number;
    fill: (dest: number, value: number, size: number, name: string) => number;
    grow: (delta: number, name: string, memory64?: boolean) => number;
    init: (
        segment: string,
        dest: number,
        offset: number,
        size: number,
        name: string,
    ) => number;
    size: (name: string, memory64?: boolean) => number;
} = ...

Type Declaration

Readonly Experimentalatomic: {
    notify: (ptr: number, notifyCount: number, name: string) => number;
    wait32: (
        ptr: number,
        expected: number,
        timeout: number,
        name: string,
    ) => number;
    wait64: (
        ptr: number,
        expected: number,
        timeout: number,
        name: string,
    ) => number;
}
Readonlycopy: (
    dest: number,
    source: number,
    size: number,
    destMemory: string,
    sourceMemory: string,
) => number
Copies data from a source memory region to a possibly overlapping destination region in another or the same memory. The first index denotes the destination.
Readonlyfill: (dest: number, value: number, size: number, name: string) => number
Sets all values in a region of memory to a given byte.
Readonlygrow: (delta: number, name: string, memory64?: boolean) => number
Grows memory by a given delta and returns the previous size, or -1 if not enough space can be allocated.
Readonlyinit: (
    segment: string,
    dest: number,
    offset: number,
    size: number,
    name: string,
) => number
Copies data from a passive data segment into a memory.
Readonlysize: (name: string, memory64?: boolean) => number
Returns the current size of a memory.

`Readonly`nop

nop: () => number = ...

Creates a no-operation (nop) instruction.

`Readonly`ref

ref: {
    as_non_null: (value: number) => number;
    cast: (value: number, castType: number) => number;
    eq: (left: number, right: number) => number;
    func: (name: string, type: number) => number;
    i31: (value: number) => number;
    is_null: (value: number) => number;
    null: (typ: number) => number;
    test: (value: number, castType: number) => number;
} = ...

Type Declaration

Readonlyas_non_null: (value: number) => number
Converts a nullible reference to a non-null one, or traps.
Readonlycast: (value: number, castType: number) => number
Tests the dynamic type of a reference, and performs a downcast or traps.
Readonlyeq: (left: number, right: number) => number
Compares two references.
Readonlyfunc: (name: string, type: number) => number
Produces a reference to a given function.
Readonlyi31: (value: number) => number
Converts type i32 to an unboxed scalar.
Readonlyis_null: (value: number) => number
Checks for null.
Readonlynull: (typ: number) => number
Produces a null reference.
Readonlytest: (value: number, castType: number) => number
Tests the dynamic type of a reference, and returns boolean.

`Readonly`return

return: (value: number) => number = ...

Unconditional branch to the body of the current function.

`Readonly`return_call

return_call: (
    name: string,
    operands: readonly number[],
    resultsType: number,
) => number = ...

Tail-call variant of call.

`Readonly`return_call_indirect

return_call_indirect: (
    table: string,
    target: number,
    operands: readonly number[],
    paramsType: number,
    resultsType: number,
) => number = ...

Tail-call variant of call_indirect.

`Readonly`return_call_ref

return_call_ref: (
    target: number,
    operands: readonly number[],
    resultsType: number,
) => number = ...

Tail-call variant of call_ref.

`Readonly`select

select: (ifTrue: number, ifFalse: number) => number = ...

Creates a (select) of one of two values.

`Readonly`struct

struct: {
    get: (
        index: number,
        ref: number,
        type: number,
        deprecated_isSigned?: boolean,
    ) => number;
    get_s: (index: number, ref: number, type: number) => number;
    get_u: (index: number, ref: number, type: number) => number;
    new: (operands: readonly number[], heapType: number) => number;
    new_default: (heapType: number) => number;
    set: (index: number, ref: number, value: number) => number;
} = ...

Type Declaration

Readonlyget: (
    index: number,
    ref: number,
    type: number,
    deprecated_isSigned?: boolean,
) => number
Gets a struct entry with an unpacked type at an index.

Warning: .get() no longer takes the boolean isSigned argument, and assumes an unpacked type. For packed types, use .get_s() for signed and .get_u() for unsigned.
Readonlyget_s: (index: number, ref: number, type: number) => number
Gets a struct entry with a signed packed type at an index.
Readonlyget_u: (index: number, ref: number, type: number) => number
Gets a struct entry with an unsigned packed type at an index.
Readonlynew: (operands: readonly number[], heapType: number) => number
Allocates a new struct and initializes it with the given operands. Passing in an empty array for operands returns (struct.new_default).
Readonlynew_default: (heapType: number) => number
Allocate a new struct and initializes it with default values.
Readonlyset: (index: number, ref: number, value: number) => number
Sets a struct entry at an index.

`Readonly`table

table: {
    get: (name: string, index: number, typ: number) => number;
    grow: (name: string, value: number, delta: number) => number;
    set: (name: string, index: number, value: number) => number;
    size: (name: string) => number;
} = ...

Type Declaration

Readonlyget: (name: string, index: number, typ: number) => number
Load an element in a table.
Readonlygrow: (name: string, value: number, delta: number) => number
Grows table by a given delta and returns the previous size, or -1 if not enough space can be allocated.
Readonlyset: (name: string, index: number, value: number) => number
Store an element in a table.
Readonlysize: (name: string) => number
Returns the current size of a table.

`Readonly`throw

throw: (tag: string, operands: readonly number[]) => number = ...

Raise an exception.

`Readonly`throw_ref

throw_ref: (target: string) => number = ...

Reraise an exception.

`Readonly`try_table

try_table: (
    name: string,
    body: number,
    catchTags: readonly string[],
    catchBodies: readonly number[],
    delegateTarget: string,
) => number = ...

Installs an exception handler that handles exceptions as specified by its catch clauses.

`Readonly`tuple

tuple: {
extract: (tupl: number, index: number) => number;
make: (elements: readonly number[]) => number;
} = ...

Type Declaration

Readonlyextract: (tupl: number, index: number) => number
Extracts a value from a Binaryen virtual tuple.
Readonlymake: (elements: readonly number[]) => number
A Binaryen-specific operation that combines values into a virtual tuple. A virtual tuple is simply a set of locals treated together as one unit, not an actual object stored in the heap.

`Readonly`unreachable

unreachable: () => number = ...

Creates an unreachable instruction that will always trap.

`Readonly`v128

v128: {
    and: (left: number, right: number) => number;
    andnot: (left: number, right: number) => number;
    anytrue: (value: number) => number;
    bitselect: (left: number, right: number, cond: number) => number;
    const: (i8s: readonly number[]) => number;
    load: (offset: number, align: number, ptr: number, name?: string) => number;
    load16_lane: (
        offset: number,
        align: number,
        index: number,
        ptr: number,
        vec: number,
        name?: string,
    ) => number;
    load16_splat: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load16x4_s: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load16x4_u: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load32_lane: (
        offset: number,
        align: number,
        index: number,
        ptr: number,
        vec: number,
        name?: string,
    ) => number;
    load32_splat: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load32_zero: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load32x2_s: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load32x2_u: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load64_lane: (
        offset: number,
        align: number,
        index: number,
        ptr: number,
        vec: number,
        name?: string,
    ) => number;
    load64_splat: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load64_zero: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load8_lane: (
        offset: number,
        align: number,
        index: number,
        ptr: number,
        vec: number,
        name?: string,
    ) => number;
    load8_splat: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load8x8_s: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    load8x8_u: (
        offset: number,
        align: number,
        ptr: number,
        name?: string,
    ) => number;
    not: (value: number) => number;
    or: (left: number, right: number) => number;
    store: (
        offset: number,
        align: number,
        ptr: number,
        value: number,
        name?: string,
    ) => number;
    store16_lane: (
        offset: number,
        align: number,
        index: number,
        ptr: number,
        vec: number,
        name?: string,
    ) => number;
    store32_lane: (
        offset: number,
        align: number,
        index: number,
        ptr: number,
        vec: number,
        name?: string,
    ) => number;
    store64_lane: (
        offset: number,
        align: number,
        index: number,
        ptr: number,
        vec: number,
        name?: string,
    ) => number;
    store8_lane: (
        offset: number,
        align: number,
        index: number,
        ptr: number,
        vec: number,
        name?: string,
    ) => number;
    xor: (left: number, right: number) => number;
} = ...

Type Declaration

Readonlyand: (left: number, right: number) => number
Readonlyandnot: (left: number, right: number) => number
Readonlyanytrue: (value: number) => number
Readonlybitselect: (left: number, right: number, cond: number) => number
Readonlyconst: (i8s: readonly number[]) => number
Return a static constant v128.
Readonlyload: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload16_lane: (
    offset: number,
    align: number,
    index: number,
    ptr: number,
    vec: number,
    name?: string,
) => number
Readonlyload16_splat: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload16x4_s: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload16x4_u: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload32_lane: (
    offset: number,
    align: number,
    index: number,
    ptr: number,
    vec: number,
    name?: string,
) => number
Readonlyload32_splat: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload32_zero: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload32x2_s: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload32x2_u: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload64_lane: (
    offset: number,
    align: number,
    index: number,
    ptr: number,
    vec: number,
    name?: string,
) => number
Readonlyload64_splat: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload64_zero: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload8_lane: (
    offset: number,
    align: number,
    index: number,
    ptr: number,
    vec: number,
    name?: string,
) => number
Readonlyload8_splat: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload8x8_s: (offset: number, align: number, ptr: number, name?: string) => number
Readonlyload8x8_u: (offset: number, align: number, ptr: number, name?: string) => number
Readonlynot: (value: number) => number
Readonlyor: (left: number, right: number) => number
Readonlystore: (
    offset: number,
    align: number,
    ptr: number,
    value: number,
    name?: string,
) => number
Readonlystore16_lane: (
    offset: number,
    align: number,
    index: number,
    ptr: number,
    vec: number,
    name?: string,
) => number
Readonlystore32_lane: (
    offset: number,
    align: number,
    index: number,
    ptr: number,
    vec: number,
    name?: string,
) => number
Readonlystore64_lane: (
    offset: number,
    align: number,
    index: number,
    ptr: number,
    vec: number,
    name?: string,
) => number
Readonlystore8_lane: (
    offset: number,
    align: number,
    index: number,
    ptr: number,
    vec: number,
    name?: string,
) => number
Readonlyxor: (left: number, right: number) => number

Methods

`Readonly`break

break(...args: any[]): number
Parameters
- ...args: any[]
Returns number
Deprecated
Use ExpressionBuilder#br instead.
- Defined in services/expression-builder/generic.ts:131

`Readonly`callIndirect

callIndirect(...args: any[]): number
Parameters
- ...args: any[]
Returns number
Deprecated
Use ExpressionBuilder#call_indirect instead.
- Defined in services/expression-builder/generic.ts:181

`Readonly`rethrow

rethrow(...args: any[]): number
Parameters
- ...args: any[]
Returns number
Deprecated
Use ExpressionBuilder#throw_ref instead.
- Defined in services/expression-builder/generic.ts:228

`Readonly`returnCall

returnCall(...args: any[]): number
Parameters
- ...args: any[]
Returns number
Deprecated
Use ExpressionBuilder#return_call instead.
- Defined in services/expression-builder/generic.ts:183

`Readonly`returnCallIndirect

returnCallIndirect(...args: any[]): number
Parameters
- ...args: any[]
Returns number
Deprecated
Use ExpressionBuilder#return_call_indirect instead.
- Defined in services/expression-builder/generic.ts:185

`Readonly`switch

switch(...args: any[]): number
Parameters
- ...args: any[]
Returns number
Deprecated
Use ExpressionBuilder#br_table instead.
- Defined in services/expression-builder/generic.ts:133

`Readonly`try

try(...args: any[]): number
Parameters
- ...args: any[]
Returns number
Deprecated
Use ExpressionBuilder#try_table instead.
- Defined in services/expression-builder/generic.ts:230

Type Alias ExpressionBuilder

See

Index

Properties

Methods

Properties

Readonlyarray

Type Declaration

Readonlycopy: ( destRef: number, destIndex: number, srcRef: number, srcIndex: number, length: number,) => number

Readonlyfill: (ref: number, index: number, value: number, size: number) => number

Readonlyget: ( ref: number, index: number, type: number, deprecated_isSigned?: boolean,) => number

Readonlyget_s: (ref: number, index: number, type: number) => number

Readonlyget_u: (ref: number, index: number, type: number) => number

Readonlyinit_data: ( name: string, ref: number, index: number, offset: number, size: number,) => number

Readonlyinit_elem: ( name: string, ref: number, index: number, offset: number, size: number,) => number

Readonlylen: (ref: number) => number

Readonlynew: (heapType: number, size: number, operand: number) => number

Readonlynew_data: (heapType: number, name: string, offset: number, size: number) => number

Readonlynew_default: (heapType: number, size: number) => number

Readonlynew_elem: (heapType: number, name: string, offset: number, size: number) => number

Readonlynew_fixed: (heapType: number, operands: readonly number[]) => number

Readonlyset: (ref: number, index: number, value: number) => number

Readonlyatomic

Readonlyblock

Readonlybr

Readonlybr_if

Readonlybr_on_cast

Readonlybr_on_cast_fail

Readonlybr_on_non_null

Readonlybr_on_null

Readonlybr_table

Readonlycall

Readonlycall_indirect

Readonlycall_ref

Readonlydata

Type Declaration

Readonlydrop: (segment: string) => number

Readonlydrop

Readonlyf32

Type Declaration

Readonlyabs: (value: number) => number

Readonlyadd: (left: number, right: number) => number

Readonlyceil: (value: number) => number

Readonlyconst: (value: number) => number

Readonlyconst_bits: (value: number) => number

Readonlyconvert_i32_s: (value: number) => number

Readonlyconvert_i32_u: (value: number) => number

Readonlyconvert_i64_s: (value: number) => number

Readonlyconvert_i64_u: (value: number) => number

Readonlyconvert_s: { i32: (...args: any[]) => number; i64: (...args: any[]) => number }

Deprecated

Readonlyi32: (...args: any[]) => number

Deprecated

Readonlyi64: (...args: any[]) => number

Deprecated

Readonlyconvert_u: { i32: (...args: any[]) => number; i64: (...args: any[]) => number }

Deprecated

Readonlyi32: (...args: any[]) => number

Deprecated

Readonlyi64: (...args: any[]) => number

Deprecated

Readonlycopysign: (left: number, right: number) => number

Readonlydemote_f64: (value: number) => number

Readonlydiv: (left: number, right: number) => number

Readonlyeq: (left: number, right: number) => number

Readonlyfloor: (value: number) => number

Readonlyge: (left: number, right: number) => number

Readonlygt: (left: number, right: number) => number

Readonlyle: (left: number, right: number) => number

Readonlyload: (offset: number, align: number, ptr: number, name?: string) => number

Readonlylt: (left: number, right: number) => number

Readonlymax: (left: number, right: number) => number

Readonlymin: (left: number, right: number) => number

Readonlymul: (left: number, right: number) => number

Readonlyne: (left: number, right: number) => number

Readonlynearest: (value: number) => number

Readonlyneg: (value: number) => number

Readonlyreinterpret_i32: (value: number) => number

Readonlysqrt: (value: number) => number

Readonlystore: ( offset: number, align: number, ptr: number, value: number, name?: string,) => number

`Readonly`array

`Readonly`copy: (
destRef: number,
destIndex: number,
srcRef: number,
srcIndex: number,
length: number,
) => number

`Readonly`fill: (ref: number, index: number, value: number, size: number) => number

`Readonly`get: (
ref: number,
index: number,
type: number,
deprecated_isSigned?: boolean,
) => number

`Readonly`get_s: (ref: number, index: number, type: number) => number

`Readonly`get_u: (ref: number, index: number, type: number) => number

`Readonly`init_data: (
name: string,
ref: number,
index: number,
offset: number,
size: number,
) => number

`Readonly`init_elem: (
name: string,
ref: number,
index: number,
offset: number,
size: number,
) => number

`Readonly`len: (ref: number) => number

`Readonly`new: (heapType: number, size: number, operand: number) => number

`Readonly`new_data: (heapType: number, name: string, offset: number, size: number) => number

`Readonly`new_default: (heapType: number, size: number) => number

`Readonly`new_elem: (heapType: number, name: string, offset: number, size: number) => number

`Readonly`new_fixed: (heapType: number, operands: readonly number[]) => number

`Readonly`set: (ref: number, index: number, value: number) => number

`Readonly`atomic

`Readonly`block

`Readonly`br

`Readonly`br_if

`Readonly`br_on_cast

`Readonly`br_on_cast_fail

`Readonly`br_on_non_null

`Readonly`br_on_null

`Readonly`br_table

`Readonly`call

`Readonly`call_indirect

`Readonly`call_ref

`Readonly`data

`Readonly`drop: (segment: string) => number

`Readonly`drop

`Readonly`f32

`Readonly`abs: (value: number) => number

`Readonly`add: (left: number, right: number) => number

`Readonly`ceil: (value: number) => number

`Readonly`const: (value: number) => number

`Readonly`const_bits: (value: number) => number

`Readonly`convert_i32_s: (value: number) => number

`Readonly`convert_i32_u: (value: number) => number

`Readonly`convert_i64_s: (value: number) => number

`Readonly`convert_i64_u: (value: number) => number

`Readonly`convert_s: { i32: (...args: any[]) => number; i64: (...args: any[]) => number }

`Readonly`i32: (...args: any[]) => number

`Readonly`i64: (...args: any[]) => number

`Readonly`convert_u: { i32: (...args: any[]) => number; i64: (...args: any[]) => number }

`Readonly`i32: (...args: any[]) => number

`Readonly`i64: (...args: any[]) => number

`Readonly`copysign: (left: number, right: number) => number

`Readonly`demote_f64: (value: number) => number

`Readonly`div: (left: number, right: number) => number

`Readonly`eq: (left: number, right: number) => number

`Readonly`floor: (value: number) => number

`Readonly`ge: (left: number, right: number) => number

`Readonly`gt: (left: number, right: number) => number

`Readonly`le: (left: number, right: number) => number

`Readonly`load: (offset: number, align: number, ptr: number, name?: string) => number

`Readonly`lt: (left: number, right: number) => number

`Readonly`max: (left: number, right: number) => number

`Readonly`min: (left: number, right: number) => number

`Readonly`mul: (left: number, right: number) => number

`Readonly`ne: (left: number, right: number) => number

`Readonly`nearest: (value: number) => number

`Readonly`neg: (value: number) => number

`Readonly`reinterpret_i32: (value: number) => number

`Readonly`sqrt: (value: number) => number

`Readonly`store: (
offset: number,
align: number,
ptr: number,
value: number,
name?: string,
) => number

`Readonly`sub: (left: number, right: number) => number

`Readonly`trunc: (value: number) => number

`Readonly`f32x4

`Readonly`f64

`Readonly`abs: (value: number) => number

`Readonly`add: (left: number, right: number) => number

`Readonly`ceil: (value: number) => number

`Readonly`const: (value: number) => number

`Readonly`const_bits: (value: number | bigint) => number

`Readonly`convert_i32_s: (value: number) => number

`Readonly`convert_i32_u: (value: number) => number

`Readonly`convert_i64_s: (value: number) => number

`Readonly`convert_i64_u: (value: number) => number

`Readonly`convert_s: { i32: (...args: any[]) => number; i64: (...args: any[]) => number }

`Readonly`i32: (...args: any[]) => number