API

compile(funs::Tuple...; filepath = "foo.wasm", jspath = filepath * ".js", names = nothing, validate = true, optimize = false, experimental = true)

Compile the methods defined by funs. Each function definition to be compiled is a tuple with the first entry as the function followed by argument types. Keyword arguments include:

• filepath–File path for the WebAssembly binary. The path will be created if it doesn't exist.
• jspath–File path for the extra JavaScript file that defines jsexports which are the JS functions imported into WebAssembly (those normally defined by @jscall).
• names–A vector or other indexable object with names of functions that are compiled. It's length must equal the length of funs.
• validate–Apply Binaryen's validation tests.
• optimize–Apply Binaryen's default optimization passes (still shaky).
• experimental–Use experimental WebAssembly features.

compile also writes a WebAssembly text tile to the same path as filepath with an added ".wat" extension.

Examples:

compile((exp, Float64), filepath = "exp.wasm", optimize = true)   
compile((acos, Float64), (asin, Float64), filepath = "trigs.wasm", optimize = true)

@jscall(fun, rettype, tt, args...)

Call a JavaScript function fun. fun is a string and normally includes the JavaScript function definition. Under the hood, these use Base.llvmcall. All @jscall definitions are imported from JavaScript.

rettype, tt, ang args... all follow the Base.llvmcall format. tt is a Tuple type (not a regular Tuple).

Arguments are converted to the types specified in tt. The following types can be included: String, Int64, Int32, UInt64, UInt32, Float64, Float32, Char, Bool, UInt8, and Int8. For all other types, specify Externref. Externref types are converted with JS.object.

Examples: @jscall("x => alert(x)", Nothing, Tuple{String}, x) d = @jscall("() => getElementById('someid')", Externref, Tuple{}) @jscall("d => d.innerHTML = 'hello world'", Nothing, Tuple{Externref}, d)

@jscall is used extensively in quirks.jl and javascript-interop.jl.

Externref()

A type representing an external object in the host system (JavaScript). This object can be passed around, but no direct operations are supported. The object can be passed back to JavaScript methods. To convert a Julia object to an Externref, use JS.object.

Applies JavaScript's console.log to show x in the browser log. Returns nothing.

escape(x)

Replaces HTML-specific characters in the string x with encoded versions. It converts '&', '"', ''', '<', and '>'.

Evaluate the JavaScript string x. Returns an Externref.

Returns a DOM object based on document.getElementById(x).

h(tag, children...; kw...)
h.tag(children...; kw...)
h.tag."classes"(children...; kw...)

Create an html node with the given tag, children, and kw attributes.

Examples

h.div("child", class="myclass", id="myid")
# <div class="myclass" id="myid">child</div>

h.div."myclass"("content")
# <div class="myclass">content</div>

Adapted from Cobweb. h uses the same API as Cobweb.h, except for getindex with symbols. For WebAssemblyCompiler.h, the following are equivalent:

h.div."myclass"("content")
h.div.myclass("content")

Note that strings are not encoded, so be sure not to include problematic HTML characters like <. Use escape or esc"..." to fix strings with problematic characters.

object(x)

Return an Externref (JavaScript object) representing the Julia object x. This is useful for transfering arrays, named tuples, and other objects to JavaScript.

The types Int32, Float32, Float64, Bool, and Externref are passed straight through.

Sets the innerHTML of the DOM object ref to str.

esc"..."

Uses escape to fix up an HTML string.

Example

esc"An HTML string with problematic characters, including ', >, and &"

Node(tag::String, attrs::NamedTuple, children::Tuple)

Should not often be used directly. See h.

abstract type CompilationContext end

Parametrize the Mixtape pipeline by inheriting from CompilationContext. Similar to the context objects in Cassette.jl. By using the interface methods transform – the user can control different parts of the compilation pipeline.

allow(f::CompilationContext, args...)::Bool

Determines whether the user-defined transform is allowed to look at a lowered Core.CodeInfo or Core.Compiler.IRCode instance.

The user is allowed to greenlight modules:

allow(::MyCtx, m::Module) == m == SomeModule

or even specific signatures

allow(::MyCtx, fn::typeof(rand), args...) = true

transform(ctx::CompilationContext, b::Core.CodeInfo)::Core.CodeInfo
transform(ctx::CompilationContext, b::Core.CodeInfo, sig::Tuple)::Core.CodeInfo

User-defined transform which operates on lowered Core.CodeInfo. There's two versions: (1) ignores the signature of the current method body under consideration and (2) provides the signature as sig.

Transforms might typically follow a simple "swap" format using CodeInfoTools.Builder:

function transform(::MyCtx, src)
    b = CodeInfoTools.Builder(b)
    for (k, st) in b
        b[k] = swap(st))
    end
    return CodeInfoTools.finish(b)
end

but more advanced formats are possible. For further utilities, please see CodeInfoTools.jl.