Class Module

A WASM module.

Module itself is:

an instantiable class (via new Module())
a namespace containing the following members, which themselves are classes (see related documentation):

Each instance of Module:

is a WASM module with module manipulation methods (.emitText(), .validate(), etc.).
is an individual namespace containing mixins, each with its own component manipulation methods (.tags.add(), .globals.get(), etc):
has a property .wasm, a namespace for creating expressions in the module (.wasm.nop(), .wasm.i32.add(), etc.)

Index

Debugging

addDebugInfoFileName

addDebugInfoFileName(filename: string): number
Adds a debug info file name to the module and returns its index.
Parameters
- filename: string
Returns number
- Defined in classes/module/Module.ts:473

getDebugInfoFileName

getDebugInfoFileName(index: number): string
Gets the name of the debug info file at the specified index.
Parameters
- index: number
Returns string
- Defined in classes/module/Module.ts:481

setDebugLocation

setDebugLocation(
    func: number,
    expr: number,
    fileIndex: number,
    lineNumber: number,
    columnNumber: number,
): void
Sets the debug location of the specified ExpressionRef within the specified FunctionRef.
Parameters
- func: number
- expr: number
- fileIndex: number
- lineNumber: number
- columnNumber: number
Returns void
- Defined in classes/module/Module.ts:489

Emission & Execution

dispose

dispose(): void
Releases the resources held by the module once it isn’t needed anymore.

Returns void
- Defined in classes/module/Module.ts:417

emitAsmjs

emitAsmjs(): string
Returns the asm.js representation of the module.

Returns string
- Defined in classes/module/Module.ts:362

emitBinary

emitBinary(): Uint8Array
Returns the module in binary format.

Returns Uint8Array
- Defined in classes/module/Module.ts:377
emitBinary(sourceMapUrl: string): { binary: Uint8Array; sourceMap: string }
Returns the module in binary format with a given source map.
Parameters
- sourceMapUrl: string
Returns { binary: Uint8Array; sourceMap: string }
- Defined in classes/module/Module.ts:382

emitStackIR

emitStackIR(): string
Returns the module in official stack-style text format.

Returns string
- Defined in classes/module/Module.ts:349

emitText

emitText(): string
Returns the module in Binaryen’s s-expression text format (not official stack-style text format).

Returns string
- Defined in classes/module/Module.ts:336

interpret

interpret(): void
Runs the module in the interpreter, calling the start function.

Returns void
- Defined in classes/module/Module.ts:409

Expression Manipulation

`Readonly`wasm

wasm: {
    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;
} = ...

This module’s WASM expression builder.

See ExpressionBuilder for its type signature.

N.B.: For convenience, developers may want to destructure the module to free wasm:

const mod = new Module();
const {wasm} = mod;
wasm.drop(wasm.i32.add(wasm.i32.const(3), wasm.i32.const(5)));

or to free its properties:

const {i32, drop} = mod.wasm;
drop(i32.add(i32.const(3), i32.const(5)));

Type Declaration

Readonlyarray: {
    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;
}
- 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.
Readonlyatomic: { fence: () => number }
Readonlyblock: (
    name: string | null,
    children: readonly number[],
    resultType?: number,
) => number
Creates a (block).
Readonlybr: (label: string, condition?: number, value?: number) => number
Creates an unconditional branch (br) to a label.
Readonlybr_if: (label: string, condition: number, value?: number) => number
Creates a conditional branch (br_if) to a label.
Readonlybr_on_cast: (label: string, value: number, castType: number) => number
Branches if the reference operand is successfully downcast to the given type.
Readonlybr_on_cast_fail: (label: string, value: number, castType: number) => number
Branches if the reference operand fails to downcast to the given type.
Readonlybr_on_non_null: (label: string, value: number) => number
Branches if the reference operand is not null.
Readonlybr_on_null: (label: string, value: number) => number
Branches if the reference operand is null.
Readonlybr_table: (
    labels: readonly string[],
    defaultLabel: string,
    condition: number,
    value?: number,
) => number
Creates a switch.
Readonlycall: (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.
Readonlycall_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.
Readonlycall_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.
Readonlydata: { drop: (segment: string) => number }
- Readonlydrop: (segment: string) => number
  Prevents further use of a passive data segment.
Readonlydrop: (value: number) => number
Creates a (drop) of a value.
Readonlyf32: {
    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;
}
- 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
Readonlyf32x4: {
    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;
}
Readonlyf64: {
    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;
}
- 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
Readonlyf64x2: {
    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;
}
Readonlyglobal: {
get: (name: string, typ: number) => number;
set: (name: string, value: number) => number;
}
- 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.
Readonlyi16x8: {
    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;
}
- 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
Readonlyi31: { get_s: (value: number) => number; get_u: (value: number) => number }
- 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.
Readonlyi32: {
    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;
}
- 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
Readonlyi32x4: {
    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;
}
Readonlyi64: {
    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;
}
- 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
Readonlyi64x2: {
    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;
}
Readonlyi8x16: {
    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;
}
- 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
Readonlyif: (ifTrue: number, ifFalse: number) => number
Creates an ‘if’ or ‘if/else’ combination.
Readonlylocal: {
    get: (index: number, typ: number) => number;
    set: (index: number, value: number) => number;
    tee: (index: number, value: number, typ: number) => number;
}
- 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.
Readonlyloop: (name: string, body: number) => number
Creates a (loop).
Readonlymemory: {
    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;
}
- 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.
Readonlynop: () => number
Creates a no-operation (nop) instruction.
Readonlyref: {
    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;
}
- 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.
Readonlyreturn: (value: number) => number
Unconditional branch to the body of the current function.
Readonlyreturn_call: (name: string, operands: readonly number[], resultsType: number) => number
Tail-call variant of call.
Readonlyreturn_call_indirect: (
    table: string,
    target: number,
    operands: readonly number[],
    paramsType: number,
    resultsType: number,
) => number
Tail-call variant of call_indirect.
Readonlyreturn_call_ref: (target: number, operands: readonly number[], resultsType: number) => number
Tail-call variant of call_ref.
Readonlyselect: (ifTrue: number, ifFalse: number) => number
Creates a (select) of one of two values.
Readonlystruct: {
    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;
}
- 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.
Readonlytable: {
    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;
}
- 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.
Readonlythrow: (tag: string, operands: readonly number[]) => number
Raise an exception.
Readonlythrow_ref: (target: string) => number
Reraise an exception.
Readonlytry_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.
Readonlytuple: {
extract: (tupl: number, index: number) => number;
make: (elements: readonly number[]) => number;
}
- 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.
Readonlyunreachable: () => number
Creates an unreachable instruction that will always trap.
Readonlyv128: {
    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;
}
- 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
break: function
- break(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#br instead.
  - Defined in services/expression-builder/generic.ts:131
callIndirect: function
- callIndirect(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#call_indirect instead.
  - Defined in services/expression-builder/generic.ts:181
rethrow: function
- rethrow(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#throw_ref instead.
  - Defined in services/expression-builder/generic.ts:228
returnCall: function
- returnCall(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#return_call instead.
  - Defined in services/expression-builder/generic.ts:183
returnCallIndirect: function
- returnCallIndirect(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#return_call_indirect instead.
  - Defined in services/expression-builder/generic.ts:185
switch: function
- switch(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#br_table instead.
  - Defined in services/expression-builder/generic.ts:133
try: function
- try(...args: any[]): number
  Parameters
  - ...args: any[]
  Returns number
  Deprecated
  Use ExpressionBuilder#try_table instead.
  - Defined in services/expression-builder/generic.ts:230

copyExpression

copyExpression(expr: number): number
Creates a deep copy of an expression.
Parameters
- expr: number
Returns number
- Defined in classes/module/Module.ts:231

getSideEffects

getSideEffects(expr: number): SideEffect
Gets the side effects of the specified expression.
Parameters
- expr: number
Returns SideEffect
- Defined in classes/module/Module.ts:223

pop

pop(typ: number): number
Pseudo-instruction enabling Binaryen to reason about multiple values on the stack.
Parameters
- typ: number
Returns number
- Defined in classes/module/Module.ts:197

Module Component Operations

`Readonly`dataSegments

dataSegments: {
    count(): number;
    get(name: string): number;
    getByIndex(index: number): number;
} = ...

Type Declaration

count: function
- count(): number
  Gets the number of data segments within the module.
  
  Returns number
  - Defined in classes/module/DataSegment.ts:70
get: function
- get(name: string): number
  Gets a data segment by name.
  Parameters
  - name: string
  Returns number
  - Defined in classes/module/DataSegment.ts:60
getByIndex: function
- getByIndex(index: number): number
  Gets a data segment by index.
  Parameters
  - index: number
  Returns number
  - Defined in classes/module/DataSegment.ts:65

`Readonly`elementSegments

elementSegments: {
    addActive(
        table: string,
        name: string,
        funcNames: readonly string[],
        offset?: number,
    ): number;
    addPassive(name: string, funcNames: readonly string[]): number;
    count(): number;
    get(name: string): number;
    getByIndex(index: number): number;
    remove(name: string): void;
} = ...

Type Declaration

addActive: function
- addActive(
      table: string,
      name: string,
      funcNames: readonly string[],
      offset?: number,
  ): number
  Adds an active element segment.
  Parameters
  - table: string
  - name: string
  - funcNames: readonly string[]
  - offset: number = ...
  Returns number
  - Defined in classes/module/ElementSegment.ts:56
addPassive: function
- addPassive(name: string, funcNames: readonly string[]): number
  Adds a passive element segment.
  Parameters
  - name: string
  - funcNames: readonly string[]
  Returns number
  - Defined in classes/module/ElementSegment.ts:68
count: function
- count(): number
  Gets the number of element segments within the module.
  
  Returns number
  - Defined in classes/module/ElementSegment.ts:88
get: function
- get(name: string): number
  Gets an element segment by name.
  Parameters
  - name: string
  Returns number
  - Defined in classes/module/ElementSegment.ts:78
getByIndex: function
- getByIndex(index: number): number
  Gets an element segment by index.
  Parameters
  - index: number
  Returns number
  - Defined in classes/module/ElementSegment.ts:83
remove: function
- remove(name: string): void
  Removes an element segment by name.
  Parameters
  - name: string
  Returns void
  - Defined in classes/module/ElementSegment.ts:93

`Readonly`exports

exports: {
    addFunction(internalName: string, externalName: string): number;
    addGlobal(internalName: string, externalName: string): number;
    addMemory(internalName: string, externalName: string): number;
    addTable(internalName: string, externalName: string): number;
    addTag(internalName: string, externalName: string): number;
    count(): number;
    get(externalName: string): number;
    getByIndex(index: number): number;
    remove(externalName: string): void;
} = ...

Type Declaration

addFunction: function
- addFunction(internalName: string, externalName: string): number
  Adds a function export.
  Parameters
  - internalName: string
  - externalName: string
  Returns number
  - Defined in classes/module/Export.ts:86
addGlobal: function
- addGlobal(internalName: string, externalName: string): number
  Adds a global variable export. Exported globals must be immutable.
  Parameters
  - internalName: string
  - externalName: string
  Returns number
  - Defined in classes/module/Export.ts:71
addMemory: function
- addMemory(internalName: string, externalName: string): number
  Adds a memory export. There’s just one memory for now, using name "0".
  Parameters
  - internalName: string
  - externalName: string
  Returns number
  - Defined in classes/module/Export.ts:76
addTable: function
- addTable(internalName: string, externalName: string): number
  Adds a table export. There’s just one table for now, using name "0".
  Parameters
  - internalName: string
  - externalName: string
  Returns number
  - Defined in classes/module/Export.ts:81
addTag: function
- addTag(internalName: string, externalName: string): number
  Adds a tag export.
  Parameters
  - internalName: string
  - externalName: string
  Returns number
  - Defined in classes/module/Export.ts:66
count: function
- count(): number
  Gets the number of exports witin the module.
  
  Returns number
  - Defined in classes/module/Export.ts:56
get: function
- get(externalName: string): number
  Gets an export by name.
  Parameters
  - externalName: string
  Returns number
  - Defined in classes/module/Export.ts:46
getByIndex: function
- getByIndex(index: number): number
  Gets an export by index.
  Parameters
  - index: number
  Returns number
  - Defined in classes/module/Export.ts:51
remove: function
- remove(externalName: string): void
  Removes an export, by external name.
  Parameters
  - externalName: string
  Returns void
  - Defined in classes/module/Export.ts:61

`Readonly`functions

functions: {
    add(
        name: string,
        params: number,
        results: number,
        varTypes: readonly number[],
        body: number,
    ): number;
    count(): number;
    get(name: string): number;
    getByIndex(index: number): number;
    remove(name: string): void;
} = ...

Type Declaration

add: function
- add(
      name: string,
      params: number,
      results: number,
      varTypes: readonly number[],
      body: number,
  ): number
  Adds a function. varTypes indicate additional locals, in the given order.
  Parameters
  - name: string
  - params: number
  - results: number
  - varTypes: readonly number[]
  - body: number
  Returns number
  - Defined in classes/module/Function.ts:98
count: function
- count(): number
  Gets the number of functions within the module.
  
  Returns number
  - Defined in classes/module/Function.ts:121
get: function
- get(name: string): number
  Gets a function by name.
  Parameters
  - name: string
  Returns number
  - Defined in classes/module/Function.ts:111
getByIndex: function
- getByIndex(index: number): number
  Gets a function by index.
  Parameters
  - index: number
  Returns number
  - Defined in classes/module/Function.ts:116
remove: function
- remove(name: string): void
  Removes a function by name.
  Parameters
  - name: string
  Returns void
  - Defined in classes/module/Function.ts:126

`Readonly`globals

globals: {
    add(name: string, type: number, mutable: boolean, init: number): number;
    count(): number;
    get(name: string): number;
    getByIndex(index: number): number;
    remove(name: string): void;
} = ...

Type Declaration

add: function
- add(name: string, type: number, mutable: boolean, init: number): number
  Adds a global instance variable.
  Parameters
  - name: string
  - type: number
  - mutable: boolean
  - init: number
  Returns number
  - Defined in classes/module/Global.ts:53
count: function
- count(): number
  Gets the number of globals within the module.
  
  Returns number
  - Defined in classes/module/Global.ts:68
get: function
- get(name: string): number
  Gets a global by name.
  Parameters
  - name: string
  Returns number
  - Defined in classes/module/Global.ts:58
getByIndex: function
- getByIndex(index: number): number
  Gets a global by index.
  Parameters
  - index: number
  Returns number
  - Defined in classes/module/Global.ts:63
remove: function
- remove(name: string): void
  Removes a global by name.
  Parameters
  - name: string
  Returns void
  - Defined in classes/module/Global.ts:73

`Readonly`imports

imports: {
    addFunction(
        internalName: string,
        externalModuleName: string,
        externalBaseName: string,
        params: number,
        results: number,
    ): void;
    addGlobal(
        internalName: string,
        externalModuleName: string,
        externalBaseName: string,
        globalType: number,
        mutable: boolean,
    ): void;
    addMemory(
        internalName: string,
        externalModuleName: string,
        externalBaseName: string,
        shared: boolean,
    ): void;
    addTable(
        internalName: string,
        externalModuleName: string,
        externalBaseName: string,
    ): void;
    addTag(
        internalName: string,
        externalModuleName: string,
        externalBaseName: string,
        params: number,
        results: number,
    ): void;
} = ...

Type Declaration

addFunction: function
- addFunction(
      internalName: string,
      externalModuleName: string,
      externalBaseName: string,
      params: number,
      results: number,
  ): void
  Adds a function import.
  Parameters
  - internalName: string
  - externalModuleName: string
  - externalBaseName: string
  - params: number
  - results: number
  Returns void
  - Defined in classes/module/Import.ts:55
addGlobal: function
- addGlobal(
      internalName: string,
      externalModuleName: string,
      externalBaseName: string,
      globalType: number,
      mutable: boolean,
  ): void
  Adds a global variable import. Imported globals must be immutable.
  Parameters
  - internalName: string
  - externalModuleName: string
  - externalBaseName: string
  - globalType: number
  - mutable: boolean
  Returns void
  - Defined in classes/module/Import.ts:40
addMemory: function
- addMemory(
      internalName: string,
      externalModuleName: string,
      externalBaseName: string,
      shared: boolean,
  ): void
  Adds a memory import. There’s just one memory for now, using name "0".
  Parameters
  - internalName: string
  - externalModuleName: string
  - externalBaseName: string
  - shared: boolean
  Returns void
  - Defined in classes/module/Import.ts:45
addTable: function
- addTable(
      internalName: string,
      externalModuleName: string,
      externalBaseName: string,
  ): void
  Adds a table import. There’s just one table for now, using name "0".
  Parameters
  - internalName: string
  - externalModuleName: string
  - externalBaseName: string
  Returns void
  - Defined in classes/module/Import.ts:50
addTag: function
- addTag(
      internalName: string,
      externalModuleName: string,
      externalBaseName: string,
      params: number,
      results: number,
  ): void
  Adds a tag import.
  Parameters
  - internalName: string
  - externalModuleName: string
  - externalBaseName: string
  - params: number
  - results: number
  Returns void
  - Defined in classes/module/Import.ts:35

`Readonly`memories

memories: {
    has(): boolean;
    set(
        initial: number,
        maximum: number,
        exportName: string,
        segments?: readonly {
            data: Uint8Array;
            name?: string;
            offset: number;
            passive: boolean;
        }[],
        shared?: boolean,
        memory64?: boolean,
        internalName?: string,
    ): void;
} = ...

Type Declaration

has: function
- has(): boolean
  Returns whether the module has a memory.
  
  Returns boolean
  - Defined in classes/module/Memory.ts:116
set: function
- set(
      initial: number,
      maximum: number,
      exportName: string,
      segments?: readonly {
          data: Uint8Array;
          name?: string;
          offset: number;
          passive: boolean;
      }[],
      shared?: boolean,
      memory64?: boolean,
      internalName?: string,
  ): void
  Sets the memory. There’s just one memory for now, using name "0". Providing exportName also creates a memory export.
  Parameters
  - initial: number
  - maximum: number
  - exportName: string
  - segments: readonly { data: Uint8Array; name?: string; offset: number; passive: boolean }[] = []
  - shared: boolean = false
  - memory64: boolean = false
  - OptionalinternalName: string
  Returns void
  - Defined in classes/module/Memory.ts:70

`Readonly`tables

tables: {
    add(
        name: string,
        initial: number,
        maximum: number,
        type?: number,
        init?: number,
    ): number;
    count(): number;
    get(name: string): number;
    getByIndex(index: number): number;
    getSegments(table: number): number[];
    remove(name: string): void;
} = ...

Type Declaration

add: function
- add(
      name: string,
      initial: number,
      maximum: number,
      type?: number,
      init?: number,
  ): number
  Adds a table.
  Parameters
  - name: string
  - initial: number
  - maximum: number
  - type: number = funcref
  - Optionalinit: number
  Returns number
  - Defined in classes/module/Table.ts:79
count: function
- count(): number
  Gets the number of tables within the module.
  
  Returns number
  - Defined in classes/module/Table.ts:109
get: function
- get(name: string): number
  Gets a table by name.
  Parameters
  - name: string
  Returns number
  - Defined in classes/module/Table.ts:84
getByIndex: function
- getByIndex(index: number): number
  Gets a table by index.
  Parameters
  - index: number
  Returns number
  - Defined in classes/module/Table.ts:89
getSegments: function
- getSegments(table: number): number[]
  Gets the number of table segments within the module.
  Parameters
  - table: number
  Returns number[]
  - Defined in classes/module/Table.ts:94
remove: function
- remove(name: string): void
  Removes a table by name.
  Parameters
  - name: string
  Returns void
  - Defined in classes/module/Table.ts:114

`Readonly`tags

tags: {
    add(name: string, params: number, results: number): number;
    get(name: string): number;
    remove(name: string): void;
} = ...

Type Declaration

add: function
- add(name: string, params: number, results: number): number
  Adds a tag.
  Parameters
  - name: string
  - params: number
  - results: number
  Returns number
  - Defined in classes/module/Tag.ts:50
get: function
- get(name: string): number
  Gets a tag by name.
  Parameters
  - name: string
  Returns number
  - Defined in classes/module/Tag.ts:55
remove: function
- remove(name: string): void
  Removes a tag by name.
  Parameters
  - name: string
  Returns void
  - Defined in classes/module/Tag.ts:60

features

get features(): Feature
The WebAssembly features enabled for this module. Features are a bitmask of Feature enum members.

Returns Feature
- Defined in classes/module/Module.ts:264
set features(features: Feature): void
Parameters
- features: Feature
Returns void
- Defined in classes/module/Module.ts:265

start

get start(): number
The start function.

Returns number
- Defined in classes/module/Module.ts:256
set start(start: number): void
Parameters
- start: number
Returns void
- Defined in classes/module/Module.ts:257

getDataSegmentInfo

getDataSegmentInfo(segment: number): DataSegment
Parameters
- segment: number
Returns DataSegment
- Defined in classes/module/Module.ts:326

getMemoryInfo

getMemoryInfo(name: string): Memory
Parameters
- name: string
Returns Memory
- Defined in classes/module/Module.ts:321

Other

constructor

new Module(): Module
Returns Module

addActiveElementSegment

addActiveElementSegment(
    table: string,
    name: string,
    funcNames: readonly string[],
    offset: number,
): number
Parameters
- table: string
- name: string
- funcNames: readonly string[]
- offset: number
Returns number
Deprecated
Use this.elementSegments.addActive instead.
- Defined in classes/module/Module.ts:297

addCustomSection

addCustomSection(name: string, contents: Uint8Array): void
Adds a custom section to the binary.
Parameters
- name: string
- contents: Uint8Array
Returns void
- Defined in classes/module/Module.ts:505

addFunction

addFunction(
    name: string,
    params: number,
    results: number,
    varTypes: readonly number[],
    body: number,
): number
Parameters
- name: string
- params: number
- results: number
- varTypes: readonly number[]
- body: number
Returns number
Deprecated
Use this.functions.add instead.
- Defined in classes/module/Module.ts:287

addFunctionExport

addFunctionExport(internalName: string, externalName: string): number
Parameters
- internalName: string
- externalName: string
Returns number
Deprecated
Use this.exports.addFunction instead.
- Defined in classes/module/Module.ts:318

addFunctionImport

addFunctionImport(
    internalName: string,
    externalModuleName: string,
    externalBaseName: string,
    params: number,
    results: number,
): void
Parameters
- internalName: string
- externalModuleName: string
- externalBaseName: string
- params: number
- results: number
Returns void
Deprecated
Use this.imports.addFunction instead.
- Defined in classes/module/Module.ts:308

addGlobal

addGlobal(name: string, type: number, mutable: boolean, init: number): number
Parameters
- name: string
- type: number
- mutable: boolean
- init: number
Returns number
Deprecated
Use this.globals.add instead.
- Defined in classes/module/Module.ts:271

addGlobalExport

addGlobalExport(internalName: string, externalName: string): number
Parameters
- internalName: string
- externalName: string
Returns number
Deprecated
Use this.exports.addGlobal instead.
- Defined in classes/module/Module.ts:315

addGlobalImport

addGlobalImport(
    internalName: string,
    externalModuleName: string,
    externalBaseName: string,
    globalType: number,
    mutable: boolean,
): void
Parameters
- internalName: string
- externalModuleName: string
- externalBaseName: string
- globalType: number
- mutable: boolean
Returns void
Deprecated
Use this.imports.addGlobal instead.
- Defined in classes/module/Module.ts:305

addMemoryExport

addMemoryExport(internalName: string, externalName: string): number
Parameters
- internalName: string
- externalName: string
Returns number
Deprecated
Use this.exports.addMemory instead.
- Defined in classes/module/Module.ts:316

addMemoryImport

addMemoryImport(
    internalName: string,
    externalModuleName: string,
    externalBaseName: string,
    shared: boolean,
): void
Parameters
- internalName: string
- externalModuleName: string
- externalBaseName: string
- shared: boolean
Returns void
Deprecated
Use this.imports.addMemory instead.
- Defined in classes/module/Module.ts:306

addPassiveElementSegment

addPassiveElementSegment(name: string, funcNames: readonly string[]): number
Parameters
- name: string
- funcNames: readonly string[]
Returns number
Deprecated
Use this.elementSegments.addPassive instead.
- Defined in classes/module/Module.ts:298

addTable

addTable(
    name: string,
    initial: number,
    maximum: number,
    type?: number,
    init?: number,
): number
Parameters
- name: string
- initial: number
- maximum: number
- type: number = funcref
- Optionalinit: number
Returns number
Deprecated
Use this.tables.add instead.
- Defined in classes/module/Module.ts:280

addTableExport

addTableExport(internalName: string, externalName: string): number
Parameters
- internalName: string
- externalName: string
Returns number
Deprecated
Use this.exports.addTable instead.
- Defined in classes/module/Module.ts:317

addTableImport

addTableImport(
    internalName: string,
    externalModuleName: string,
    externalBaseName: string,
): void
Parameters
- internalName: string
- externalModuleName: string
- externalBaseName: string
Returns void
Deprecated
Use this.imports.addTable instead.
- Defined in classes/module/Module.ts:307

addTag

addTag(name: string, params: number, results: number): number
Parameters
- name: string
- params: number
- results: number
Returns number
Deprecated
Use this.tags.add instead.
- Defined in classes/module/Module.ts:267

addTagExport

addTagExport(internalName: string, externalName: string): number
Parameters
- internalName: string
- externalName: string
Returns number
Deprecated
Use this.exports.addTag instead.
- Defined in classes/module/Module.ts:314

addTagImport

addTagImport(
    internalName: string,
    externalModuleName: string,
    externalBaseName: string,
    params: number,
    results: number,
): void
Parameters
- internalName: string
- externalModuleName: string
- externalBaseName: string
- params: number
- results: number
Returns void
Deprecated
Use this.imports.addTag instead.
- Defined in classes/module/Module.ts:304

getDataSegment

getDataSegment(name: string): number
Parameters
- name: string
Returns number
Deprecated
Use this.dataSegments.get instead.
- Defined in classes/module/Module.ts:293

getDataSegmentByIndex

getDataSegmentByIndex(index: number): number
Parameters
- index: number
Returns number
Deprecated
Use this.dataSegments.getByIndex instead.
- Defined in classes/module/Module.ts:294

getElementSegment

getElementSegment(name: string): number
Parameters
- name: string
Returns number
Deprecated
Use this.elementSegments.get instead.
- Defined in classes/module/Module.ts:299

getElementSegmentByIndex

getElementSegmentByIndex(index: number): number
Parameters
- index: number
Returns number
Deprecated
Use this.elementSegments.getByIndex instead.
- Defined in classes/module/Module.ts:300

getExport

getExport(externalName: string): number
Parameters
- externalName: string
Returns number
Deprecated
Use this.exports.get instead.
- Defined in classes/module/Module.ts:310

getExportByIndex

getExportByIndex(index: number): number
Parameters
- index: number
Returns number
Deprecated
Use this.exports.getByIndex instead.
- Defined in classes/module/Module.ts:311

getFeatures

getFeatures(): Feature
Returns Feature
Deprecated
Use this.features instead.
- Defined in classes/module/Module.ts:249

getFunction

getFunction(name: string): number
Parameters
- name: string
Returns number
Deprecated
Use this.functions.get instead.
- Defined in classes/module/Module.ts:288

getFunctionByIndex

getFunctionByIndex(index: number): number
Parameters
- index: number
Returns number
Deprecated
Use this.functions.getByIndex instead.
- Defined in classes/module/Module.ts:289

getGlobal

getGlobal(name: string): number
Parameters
- name: string
Returns number
Deprecated
Use this.globals.get instead.
- Defined in classes/module/Module.ts:272

getGlobalByIndex

getGlobalByIndex(index: number): number
Parameters
- index: number
Returns number
Deprecated
Use this.globals.getByIndex instead.
- Defined in classes/module/Module.ts:273

getNumDataSegments

getNumDataSegments(): number
Returns number
Deprecated
Use this.dataSegments.count instead.
- Defined in classes/module/Module.ts:295

getNumElementSegments

getNumElementSegments(): number
Returns number
Deprecated
Use this.elementSegments.count instead.
- Defined in classes/module/Module.ts:301

getNumExports

getNumExports(): number
Returns number
Deprecated
Use this.exports.count instead.
- Defined in classes/module/Module.ts:312

getNumFunctions

getNumFunctions(): number
Returns number
Deprecated
Use this.functions.count instead.
- Defined in classes/module/Module.ts:290

getNumGlobals

getNumGlobals(): number
Returns number
Deprecated
Use this.globals.count instead.
- Defined in classes/module/Module.ts:274

getNumTables

getNumTables(): number
Returns number
Deprecated
Use this.tables.count instead.
- Defined in classes/module/Module.ts:284

getStart

getStart(): number
Returns number
Deprecated
Use this.start instead.
- Defined in classes/module/Module.ts:247

getTable

getTable(name: string): number
Parameters
- name: string
Returns number
Deprecated
Use this.tables.get instead.
- Defined in classes/module/Module.ts:281

getTableByIndex

getTableByIndex(index: number): number
Parameters
- index: number
Returns number
Deprecated
Use this.tables.getByIndex instead.
- Defined in classes/module/Module.ts:282

getTableSegments

getTableSegments(table: number): number[]
Parameters
- table: number
Returns number[]
Deprecated
Use this.tables.getSegments instead.
- Defined in classes/module/Module.ts:283

getTag

getTag(name: string): number
Parameters
- name: string
Returns number
Deprecated
Use this.tags.get instead.
- Defined in classes/module/Module.ts:268

hasMemory

hasMemory(): boolean
Returns boolean
Deprecated
Use this.memories.has instead.
- Defined in classes/module/Module.ts:278

removeElementSegment

removeElementSegment(name: string): void
Parameters
- name: string
Returns void
Deprecated
Use this.elementSegments.remove instead.
- Defined in classes/module/Module.ts:302

removeExport

removeExport(externalName: string): void
Parameters
- externalName: string
Returns void
Deprecated
Use this.exports.remove instead.
- Defined in classes/module/Module.ts:313

removeFunction

removeFunction(name: string): void
Parameters
- name: string
Returns void
Deprecated
Use this.functions.remove instead.
- Defined in classes/module/Module.ts:291

removeGlobal

removeGlobal(name: string): void
Parameters
- name: string
Returns void
Deprecated
Use this.globals.remove instead.
- Defined in classes/module/Module.ts:275

removeTable

removeTable(name: string): void
Parameters
- name: string
Returns void
Deprecated
Use this.tables.remove instead.
- Defined in classes/module/Module.ts:285

removeTag

removeTag(name: string): void
Parameters
- name: string
Returns void
Deprecated
Use this.tags.remove instead.
- Defined in classes/module/Module.ts:269

setFeatures

setFeatures(features: Feature): Feature
Parameters
- features: Feature
Returns Feature
Deprecated
Use this.features instead.
- Defined in classes/module/Module.ts:250

setFieldName

setFieldName(heapType: number, index: number, name: string): void
[description]
Parameters
- heapType: number
- index: number
- name: string
Returns void
- Defined in classes/module/Module.ts:500

setMemory

setMemory(
    initial: number,
    maximum: number,
    exportName: string,
    segments?: readonly any[],
    shared?: boolean,
    memory64?: boolean,
    internalName?: string,
): void
Parameters
- initial: number
- maximum: number
- exportName: string
- Optionalsegments: readonly any[]
- Optionalshared: boolean
- Optionalmemory64: boolean
- OptionalinternalName: string
Returns void
Deprecated
Use this.memories.set instead.
- Defined in classes/module/Module.ts:277

setStart

setStart(start: number): void
Parameters
- start: number
Returns void
Deprecated
Use this.start instead.
- Defined in classes/module/Module.ts:248

setTypeName

setTypeName(heapType: number, name: string): void
[description]
Parameters
- heapType: number
- name: string
Returns void
- Defined in classes/module/Module.ts:495

updateMaps

updateMaps(): void
Updates the internal name mapping logic in a module. This must be called after renaming module elements.

Returns void
- Defined in classes/module/Module.ts:513

Validation & Optimization

optimize

optimize(): void
Optimizes the module using the default optimization passes.

Returns void
- Defined in classes/module/Module.ts:434

optimizeFunction

optimizeFunction(func: string | number): void
Optimizes a single function using the default optimization passes.
Parameters
- func: string | number
Returns void
- Defined in classes/module/Module.ts:442

runPasses

runPasses(passes: readonly string[]): void
Runs the specified passes on the module.
Parameters
- passes: readonly string[]
Returns void
- Defined in classes/module/Module.ts:453

runPassesOnFunction

runPassesOnFunction(func: string | number, passes: readonly string[]): void
Runs the specified passes on a single function.
Parameters
- func: string | number
- passes: readonly string[]
Returns void
- Defined in classes/module/Module.ts:461

validate

validate(): number
Validates the module. Returns true if valid, otherwise prints validation errors and returns false.

Returns number
- Defined in classes/module/Module.ts:426

Class Module

Index

Debugging

Emission & Execution

Expression Manipulation

Module Component Operations

Other

Validation & Optimization

Debugging

addDebugInfoFileName

Parameters

Returns number

getDebugInfoFileName

Parameters

Returns string

setDebugLocation

Parameters

Returns void

Emission & Execution

dispose

Returns void

emitAsmjs

Returns string

emitBinary

Returns Uint8Array

Parameters

Returns { binary: Uint8Array; sourceMap: string }

emitStackIR

Returns string

emitText

Returns string

interpret

Returns void

Expression Manipulation

Readonlywasm

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: { fence: () => number }

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

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

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

Readonlybr_on_cast: (label: string, value: number, castType: number) => number

Readonlybr_on_cast_fail: (label: string, value: number, castType: number) => number

Readonlybr_on_non_null: (label: string, value: number) => number

Readonlybr_on_null: (label: string, value: number) => number

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

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

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

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

Readonlydata: { drop: (segment: string) => number }

Readonlydrop: (segment: string) => number

Readonlydrop: (value: number) => number

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

`Readonly`wasm

`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: { fence: () => number }

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

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

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

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

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

`Readonly`br_on_non_null: (label: string, value: number) => number

`Readonly`br_on_null: (label: string, value: number) => number

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

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

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

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

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

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

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

`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`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

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

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

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