proteus-sdk 0.0.0-stage → 0.1.0

package/pkg/proteus_sdk_web_bg.js

@@ -0,0 +1,1671 @@
+/**
+ * A handle to a component.
+ */
+export class Handle {
+    static __wrap(ptr) {
+        const obj = Object.create(Handle.prototype);
+        obj.__wbg_ptr = ptr;
+        HandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_handle_free(ptr, 0);
+    }
+    /**
+     * Returns a handle for an ID from [`Handle::id`] or
+     * `ComponentData.children`. The ID isn't checked: if its component has
+     * been destroyed, methods that change it throw and `get` returns
+     * `undefined`.
+     * @param {number} id
+     * @returns {Handle}
+     */
+    static fromId(id) {
+        const ret = wasm.handle_fromId(id);
+        return Handle.__wrap(ret);
+    }
+    /**
+     * The component's ID: its entity's bits as a number, which is exact for
+     * any realistic app (see the `dto` module). [`Handle::from_id`] turns it
+     * back into a handle.
+     * @returns {number}
+     */
+    id() {
+        const ret = wasm.handle_id(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) Handle.prototype[Symbol.dispose] = Handle.prototype.free;
+
+/**
+ * A [`Proteus`](sdk::Proteus) app, as JavaScript sees it. Cloning shares the
+ * same app.
+ */
+export class ProteusApp {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProteusAppFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_proteusapp_free(ptr, 0);
+    }
+    /**
+     * Calls [`Handle::add_child`](sdk::Handle::add_child).
+     * @param {Handle} parent
+     * @param {Handle} child
+     */
+    addChild(parent, child) {
+        _assertClass(parent, Handle);
+        _assertClass(child, Handle);
+        const ret = wasm.proteusapp_addChild(this.__wbg_ptr, parent.__wbg_ptr, child.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::animate_to`](sdk::Handle::animate_to).
+     * @param {Handle} handle
+     * @param {any} to
+     * @param {any} config
+     */
+    animateTo(handle, to, config) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_animateTo(this.__wbg_ptr, handle.__wbg_ptr, to, config);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Proteus::bake_texture`](sdk::Proteus::bake_texture).
+     * @param {number} width
+     * @param {number} height
+     * @param {Uint8Array} rgba
+     * @param {any} request
+     * @returns {TextureHandle}
+     */
+    bakeTexture(width, height, rgba, request) {
+        const ptr0 = passArray8ToWasm0(rgba, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.proteusapp_bakeTexture(this.__wbg_ptr, width, height, ptr0, len0, request);
+        return TextureHandle.__wrap(ret);
+    }
+    /**
+     * Calls [`Handle::baked_image_size`](sdk::Handle::baked_image_size).
+     * Returns `undefined` if there is no baked image.
+     * @param {Handle} handle
+     * @returns {any}
+     */
+    bakedImageSize(handle) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_bakedImageSize(this.__wbg_ptr, handle.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Calls [`Handle::baked_text_size`](sdk::Handle::baked_text_size).
+     * Returns `undefined` if there is no baked text.
+     * @param {Handle} handle
+     * @returns {any}
+     */
+    bakedTextSize(handle) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_bakedTextSize(this.__wbg_ptr, handle.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Calls [`TransitionChannel::destroy`](sdk::TransitionChannel::destroy). Consumes
+     * `channel`: the JavaScript object can't be used afterwards.
+     * @param {TransitionChannel} channel
+     */
+    channelDestroy(channel) {
+        _assertClass(channel, TransitionChannel);
+        var ptr0 = channel.__destroy_into_raw();
+        wasm.proteusapp_channelDestroy(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * Calls [`TransitionChannel::set`](sdk::TransitionChannel::set).
+     * @param {TransitionChannel} channel
+     * @param {Handle} to
+     * @param {Handle} from
+     * @param {any} config
+     * @param {boolean} interruptible
+     */
+    channelSet(channel, to, from, config, interruptible) {
+        _assertClass(channel, TransitionChannel);
+        _assertClass(to, Handle);
+        _assertClass(from, Handle);
+        const ret = wasm.proteusapp_channelSet(this.__wbg_ptr, channel.__wbg_ptr, to.__wbg_ptr, from.__wbg_ptr, config, interruptible);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Proteus::component`](sdk::Proteus::component). `spec` is a
+     * `ComponentSpec` object; its `children` are handle IDs.
+     * @param {any} spec
+     * @returns {Handle}
+     */
+    component(spec) {
+        const ret = wasm.proteusapp_component(this.__wbg_ptr, spec);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Handle.__wrap(ret[0]);
+    }
+    /**
+     * Calls [`Handle::copy_baked_image_from`](sdk::Handle::copy_baked_image_from).
+     * @param {Handle} handle
+     * @param {Handle} source
+     * @returns {boolean}
+     */
+    copyBakedImageFrom(handle, source) {
+        _assertClass(handle, Handle);
+        _assertClass(source, Handle);
+        const ret = wasm.proteusapp_copyBakedImageFrom(this.__wbg_ptr, handle.__wbg_ptr, source.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Calls [`Proteus::create_video`](sdk::Proteus::create_video).
+     * @returns {VideoHandle}
+     */
+    createVideo() {
+        const ret = wasm.proteusapp_createVideo(this.__wbg_ptr);
+        return VideoHandle.__wrap(ret);
+    }
+    /**
+     * Calls [`Handle::crop_image`](sdk::Handle::crop_image). Throws if
+     * `crop` isn't a valid `ImageCrop`.
+     * @param {Handle} handle
+     * @param {any} crop
+     * @returns {boolean}
+     */
+    cropImage(handle, crop) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_cropImage(this.__wbg_ptr, handle.__wbg_ptr, crop);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Calls [`Handle::destroy`](sdk::Handle::destroy). Consumes `handle`: the
+     * JavaScript object can't be used afterwards.
+     * @param {Handle} handle
+     */
+    destroy(handle) {
+        _assertClass(handle, Handle);
+        var ptr0 = handle.__destroy_into_raw();
+        const ret = wasm.proteusapp_destroy(this.__wbg_ptr, ptr0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::free_resources`](sdk::Handle::free_resources).
+     * @param {Handle} handle
+     */
+    freeResources(handle) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_freeResources(this.__wbg_ptr, handle.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Proteus::get`](sdk::Proteus::get). Returns `undefined` if the
+     * component has been destroyed.
+     * @param {Handle} handle
+     * @returns {any}
+     */
+    get(handle) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_get(this.__wbg_ptr, handle.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Calls [`Handle::hide_video`](sdk::Handle::hide_video).
+     * @param {Handle} handle
+     */
+    hideVideo(handle) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_hideVideo(this.__wbg_ptr, handle.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Proteus::load_texture`](sdk::Proteus::load_texture). Returns
+     * `undefined` if the bytes can't be decoded.
+     * @param {Uint8Array} bytes
+     * @param {any} request
+     * @returns {TextureHandle | undefined}
+     */
+    loadTexture(bytes, request) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.proteusapp_loadTexture(this.__wbg_ptr, ptr0, len0, request);
+        return ret === 0 ? undefined : TextureHandle.__wrap(ret);
+    }
+    /**
+     * Calls [`Handle::merge_from`](sdk::Handle::merge_from). The sources
+     * cross as handle IDs.
+     * @param {Handle} handle
+     * @param {Float64Array} source_ids
+     * @param {any} config
+     * @param {any} layout
+     */
+    mergeFrom(handle, source_ids, config, layout) {
+        _assertClass(handle, Handle);
+        const ptr0 = passArrayF64ToWasm0(source_ids, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.proteusapp_mergeFrom(this.__wbg_ptr, handle.__wbg_ptr, ptr0, len0, config, layout);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::merge_from_with_behavior`](sdk::Handle::merge_from_with_behavior).
+     * `child_behavior` is called once per source, before the merge starts.
+     * @param {Handle} handle
+     * @param {Float64Array} source_ids
+     * @param {any} config
+     * @param {any} layout
+     * @param {Function} child_behavior
+     */
+    mergeFromWithBehavior(handle, source_ids, config, layout, child_behavior) {
+        _assertClass(handle, Handle);
+        const ptr0 = passArrayF64ToWasm0(source_ids, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.proteusapp_mergeFromWithBehavior(this.__wbg_ptr, handle.__wbg_ptr, ptr0, len0, config, layout, child_behavior);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Creates a standalone app, with no host, that draws nothing.
+     */
+    constructor() {
+        const ret = wasm.proteusapp_new();
+        this.__wbg_ptr = ret;
+        ProteusAppFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Calls [`Handle::on_blur`](sdk::Handle::on_blur).
+     * @param {Handle} handle
+     * @param {Function} cb
+     */
+    onBlur(handle, cb) {
+        _assertClass(handle, Handle);
+        wasm.proteusapp_onBlur(this.__wbg_ptr, handle.__wbg_ptr, cb);
+    }
+    /**
+     * Calls [`Handle::on_click`](sdk::Handle::on_click).
+     * @param {Handle} handle
+     * @param {Function} cb
+     */
+    onClick(handle, cb) {
+        _assertClass(handle, Handle);
+        wasm.proteusapp_onClick(this.__wbg_ptr, handle.__wbg_ptr, cb);
+    }
+    /**
+     * Calls [`Handle::on_drag`](sdk::Handle::on_drag). `cb` receives the
+     * movement as two numbers, `x` and `y`.
+     * @param {Handle} handle
+     * @param {Function} cb
+     */
+    onDrag(handle, cb) {
+        _assertClass(handle, Handle);
+        wasm.proteusapp_onDrag(this.__wbg_ptr, handle.__wbg_ptr, cb);
+    }
+    /**
+     * Calls [`TransitionChannel::on_dropped`](sdk::TransitionChannel::on_dropped).
+     * @param {TransitionChannel} channel
+     * @param {Function} cb
+     */
+    onDropped(channel, cb) {
+        _assertClass(channel, TransitionChannel);
+        wasm.proteusapp_onDropped(this.__wbg_ptr, channel.__wbg_ptr, cb);
+    }
+    /**
+     * Calls [`Handle::on_focus`](sdk::Handle::on_focus).
+     * @param {Handle} handle
+     * @param {Function} cb
+     */
+    onFocus(handle, cb) {
+        _assertClass(handle, Handle);
+        wasm.proteusapp_onFocus(this.__wbg_ptr, handle.__wbg_ptr, cb);
+    }
+    /**
+     * Calls [`Handle::on_hover_enter`](sdk::Handle::on_hover_enter).
+     * @param {Handle} handle
+     * @param {Function} cb
+     */
+    onHoverEnter(handle, cb) {
+        _assertClass(handle, Handle);
+        wasm.proteusapp_onHoverEnter(this.__wbg_ptr, handle.__wbg_ptr, cb);
+    }
+    /**
+     * Calls [`Handle::on_hover_exit`](sdk::Handle::on_hover_exit).
+     * @param {Handle} handle
+     * @param {Function} cb
+     */
+    onHoverExit(handle, cb) {
+        _assertClass(handle, Handle);
+        wasm.proteusapp_onHoverExit(this.__wbg_ptr, handle.__wbg_ptr, cb);
+    }
+    /**
+     * Calls [`Handle::on_press`](sdk::Handle::on_press).
+     * @param {Handle} handle
+     * @param {Function} cb
+     */
+    onPress(handle, cb) {
+        _assertClass(handle, Handle);
+        wasm.proteusapp_onPress(this.__wbg_ptr, handle.__wbg_ptr, cb);
+    }
+    /**
+     * Calls [`Handle::on_release`](sdk::Handle::on_release).
+     * @param {Handle} handle
+     * @param {Function} cb
+     */
+    onRelease(handle, cb) {
+        _assertClass(handle, Handle);
+        wasm.proteusapp_onRelease(this.__wbg_ptr, handle.__wbg_ptr, cb);
+    }
+    /**
+     * Calls [`Handle::on_transition_complete`](sdk::Handle::on_transition_complete).
+     * @param {Handle} handle
+     * @param {Function} cb
+     */
+    onTransitionComplete(handle, cb) {
+        _assertClass(handle, Handle);
+        wasm.proteusapp_onTransitionComplete(this.__wbg_ptr, handle.__wbg_ptr, cb);
+    }
+    /**
+     * Records that the pointer left the viewport: `pointer_moved(None)`.
+     */
+    pointerLeft() {
+        wasm.proteusapp_pointerLeft(this.__wbg_ptr);
+    }
+    /**
+     * Calls [`Proteus::pointer_moved`](sdk::Proteus::pointer_moved). `x` and
+     * `y` are world units: origin at the viewport center, y up.
+     * @param {number} x
+     * @param {number} y
+     */
+    pointerMoved(x, y) {
+        wasm.proteusapp_pointerMoved(this.__wbg_ptr, x, y);
+    }
+    /**
+     * Calls [`Proteus::pointer_pressed`](sdk::Proteus::pointer_pressed).
+     */
+    pointerPressed() {
+        wasm.proteusapp_pointerPressed(this.__wbg_ptr);
+    }
+    /**
+     * Calls [`Proteus::pointer_released`](sdk::Proteus::pointer_released).
+     */
+    pointerReleased() {
+        wasm.proteusapp_pointerReleased(this.__wbg_ptr);
+    }
+    /**
+     * Calls [`VideoHandle::release`](sdk::VideoHandle::release).
+     * @param {VideoHandle} video
+     */
+    releaseVideo(video) {
+        _assertClass(video, VideoHandle);
+        wasm.proteusapp_releaseVideo(this.__wbg_ptr, video.__wbg_ptr);
+    }
+    /**
+     * Calls [`Handle::remove_child`](sdk::Handle::remove_child).
+     * @param {Handle} parent
+     * @param {Handle} child
+     */
+    removeChild(parent, child) {
+        _assertClass(parent, Handle);
+        _assertClass(child, Handle);
+        const ret = wasm.proteusapp_removeChild(this.__wbg_ptr, parent.__wbg_ptr, child.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::set_declared_geometry`](sdk::Handle::set_declared_geometry).
+     * @param {Handle} handle
+     * @param {any} state
+     */
+    setDeclaredGeometry(handle, state) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_setDeclaredGeometry(this.__wbg_ptr, handle.__wbg_ptr, state);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::set_disabled`](sdk::Handle::set_disabled).
+     * @param {Handle} handle
+     * @param {boolean} disabled
+     */
+    setDisabled(handle, disabled) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_setDisabled(this.__wbg_ptr, handle.__wbg_ptr, disabled);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::set_image`](sdk::Handle::set_image).
+     * @param {Handle} handle
+     * @param {any} image
+     */
+    setImage(handle, image) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_setImage(this.__wbg_ptr, handle.__wbg_ptr, image);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::set_interactive`](sdk::Handle::set_interactive).
+     * @param {Handle} handle
+     * @param {boolean} interactive
+     */
+    setInteractive(handle, interactive) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_setInteractive(this.__wbg_ptr, handle.__wbg_ptr, interactive);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::set_opacity`](sdk::Handle::set_opacity).
+     * @param {Handle} handle
+     * @param {number} opacity
+     */
+    setOpacity(handle, opacity) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_setOpacity(this.__wbg_ptr, handle.__wbg_ptr, opacity);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::set_text`](sdk::Handle::set_text).
+     * @param {Handle} handle
+     * @param {any} text
+     */
+    setText(handle, text) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_setText(this.__wbg_ptr, handle.__wbg_ptr, text);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::set_texture`](sdk::Handle::set_texture).
+     * @param {Handle} handle
+     * @param {TextureHandle} texture
+     * @returns {boolean}
+     */
+    setTexture(handle, texture) {
+        _assertClass(handle, Handle);
+        _assertClass(texture, TextureHandle);
+        const ret = wasm.proteusapp_setTexture(this.__wbg_ptr, handle.__wbg_ptr, texture.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Calls [`Handle::set_transition_interaction`](sdk::Handle::set_transition_interaction).
+     * `null` or `undefined` restores the default.
+     * @param {Handle} handle
+     * @param {any} config
+     */
+    setTransitionInteraction(handle, config) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_setTransitionInteraction(this.__wbg_ptr, handle.__wbg_ptr, config);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::set_video_crossfade`](sdk::Handle::set_video_crossfade).
+     * @param {Handle} handle
+     * @param {number} video_t
+     * @returns {boolean}
+     */
+    setVideoCrossfade(handle, video_t) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_setVideoCrossfade(this.__wbg_ptr, handle.__wbg_ptr, video_t);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Calls [`Handle::set_visible`](sdk::Handle::set_visible).
+     * @param {Handle} handle
+     * @param {boolean} visible
+     */
+    setVisible(handle, visible) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_setVisible(this.__wbg_ptr, handle.__wbg_ptr, visible);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::show_video`](sdk::Handle::show_video).
+     * @param {Handle} handle
+     * @param {VideoHandle} video
+     * @returns {boolean}
+     */
+    showVideo(handle, video) {
+        _assertClass(handle, Handle);
+        _assertClass(video, VideoHandle);
+        const ret = wasm.proteusapp_showVideo(this.__wbg_ptr, handle.__wbg_ptr, video.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Calls [`Handle::split_to`](sdk::Handle::split_to). The targets cross
+     * as handle IDs.
+     * @param {Handle} handle
+     * @param {Float64Array} target_ids
+     * @param {any} config
+     * @param {any} strategy
+     */
+    splitTo(handle, target_ids, config, strategy) {
+        _assertClass(handle, Handle);
+        const ptr0 = passArrayF64ToWasm0(target_ids, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.proteusapp_splitTo(this.__wbg_ptr, handle.__wbg_ptr, ptr0, len0, config, strategy);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::split_to_with_behavior`](sdk::Handle::split_to_with_behavior).
+     * `child_behavior` is called once per target, before the split starts.
+     * @param {Handle} handle
+     * @param {Float64Array} target_ids
+     * @param {any} config
+     * @param {any} strategy
+     * @param {Function} child_behavior
+     */
+    splitToWithBehavior(handle, target_ids, config, strategy, child_behavior) {
+        _assertClass(handle, Handle);
+        const ptr0 = passArrayF64ToWasm0(target_ids, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.proteusapp_splitToWithBehavior(this.__wbg_ptr, handle.__wbg_ptr, ptr0, len0, config, strategy, child_behavior);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Calls [`Handle::split_to_with_states`](sdk::Handle::split_to_with_states).
+     * `targets` is an array of `{ id, state }` objects.
+     * @param {Handle} handle
+     * @param {any} targets
+     * @param {any} config
+     * @param {any} strategy
+     */
+    splitToWithStates(handle, targets, config, strategy) {
+        _assertClass(handle, Handle);
+        const ret = wasm.proteusapp_splitToWithStates(this.__wbg_ptr, handle.__wbg_ptr, targets, config, strategy);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Returns a texture handle for a texture ID.
+     * @param {number} id
+     * @returns {TextureHandle}
+     */
+    texture(id) {
+        const ret = wasm.proteusapp_texture(this.__wbg_ptr, id);
+        return TextureHandle.__wrap(ret);
+    }
+    /**
+     * Calls [`TextureHandle::state`](sdk::TextureHandle::state). Returns
+     * `undefined` if the texture has been evicted or never existed.
+     * @param {TextureHandle} handle
+     * @returns {any}
+     */
+    textureState(handle) {
+        _assertClass(handle, TextureHandle);
+        const ret = wasm.proteusapp_textureState(this.__wbg_ptr, handle.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Calls [`Proteus::tick`](sdk::Proteus::tick). For a standalone app only:
+     * a host ticks the shared `Proteus` itself.
+     * @param {number} dt
+     */
+    tick(dt) {
+        wasm.proteusapp_tick(this.__wbg_ptr, dt);
+    }
+    /**
+     * Calls [`Proteus::transition_channel`](sdk::Proteus::transition_channel).
+     * `owner` is a handle ID, since `wasm-bindgen` can't take an optional
+     * reference.
+     * @param {number | null} [owner]
+     * @returns {TransitionChannel}
+     */
+    transitionChannel(owner) {
+        const ret = wasm.proteusapp_transitionChannel(this.__wbg_ptr, !isLikeNone(owner), isLikeNone(owner) ? 0 : owner);
+        return TransitionChannel.__wrap(ret);
+    }
+    /**
+     * Calls [`VideoHandle::upload_frame`](sdk::VideoHandle::upload_frame).
+     * @param {VideoHandle} video
+     * @param {number} width
+     * @param {number} height
+     * @param {Uint8Array} rgba
+     * @returns {boolean}
+     */
+    uploadVideoFrame(video, width, height, rgba) {
+        _assertClass(video, VideoHandle);
+        const ptr0 = passArray8ToWasm0(rgba, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.proteusapp_uploadVideoFrame(this.__wbg_ptr, video.__wbg_ptr, width, height, ptr0, len0);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) ProteusApp.prototype[Symbol.dispose] = ProteusApp.prototype.free;
+
+/**
+ * A handle to a texture in the atlas.
+ */
+export class TextureHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(TextureHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        TextureHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TextureHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_texturehandle_free(ptr, 0);
+    }
+    /**
+     * Returns a handle for an ID from [`JsTextureHandle::id`]. To add a
+     * texture, use `loadTexture` or `bakeTexture`.
+     * @param {number} id
+     * @returns {TextureHandle}
+     */
+    static fromId(id) {
+        const ret = wasm.texturehandle_fromId(id);
+        return TextureHandle.__wrap(ret);
+    }
+    /**
+     * The texture's ID, as a number. [`JsTextureHandle::from_id`] turns it
+     * back into a handle.
+     * @returns {number}
+     */
+    id() {
+        const ret = wasm.texturehandle_id(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) TextureHandle.prototype[Symbol.dispose] = TextureHandle.prototype.free;
+
+/**
+ * A handle to a transition channel. It has no methods of its own; it is
+ * passed to `channelSet`, `channelDestroy` and `onDropped`.
+ */
+export class TransitionChannel {
+    static __wrap(ptr) {
+        const obj = Object.create(TransitionChannel.prototype);
+        obj.__wbg_ptr = ptr;
+        TransitionChannelFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TransitionChannelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_transitionchannel_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) TransitionChannel.prototype[Symbol.dispose] = TransitionChannel.prototype.free;
+
+/**
+ * A handle to a video whose frames the app supplies. It has no methods of
+ * its own; it is passed to `uploadVideoFrame`, `releaseVideo` and
+ * `showVideo`.
+ */
+export class VideoHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(VideoHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        VideoHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VideoHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_videohandle_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) VideoHandle.prototype[Symbol.dispose] = VideoHandle.prototype.free;
+export function __wbg_Error_fdd633d4bb5dd76a(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_Number_c4bdf66bb78f7977(arg0) {
+    const ret = Number(arg0);
+    return ret;
+}
+export function __wbg_String_8564e559799eccda(arg0, arg1) {
+    const ret = String(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg___wbindgen_bigint_get_as_i64_d9e915702856f831(arg0, arg1) {
+    const v = arg1;
+    const ret = typeof(v) === 'bigint' ? v : undefined;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
+export function __wbg___wbindgen_boolean_get_edaed31a367ce1bd(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+}
+export function __wbg___wbindgen_debug_string_8a447059637473e2(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg___wbindgen_in_4990f46af709e33c(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+}
+export function __wbg___wbindgen_is_bigint_90b5ccfe67c78460(arg0) {
+    const ret = typeof(arg0) === 'bigint';
+    return ret;
+}
+export function __wbg___wbindgen_is_function_acc5528be2b923f2(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+}
+export function __wbg___wbindgen_is_null_6d937fbfb6478470(arg0) {
+    const ret = arg0 === null;
+    return ret;
+}
+export function __wbg___wbindgen_is_object_0beba4a1980d3eea(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_721f8decd50c87a3(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_jsval_eq_4e8c38722cb8ff51(arg0, arg1) {
+    const ret = arg0 === arg1;
+    return ret;
+}
+export function __wbg___wbindgen_jsval_loose_eq_4b9aba9e5b3c4582(arg0, arg1) {
+    const ret = arg0 == arg1;
+    return ret;
+}
+export function __wbg___wbindgen_number_get_1cc01dd708740256(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
+export function __wbg___wbindgen_string_get_71bb4348194e31f0(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg___wbindgen_throw_ea4887a5f8f9a9db(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg__wbg_cb_unref_33c39e13d73b25f6(arg0) {
+    arg0._wbg_cb_unref();
+}
+export function __wbg_beginRenderPass_10e1d8bb36f2f74e() { return handleError(function (arg0, arg1) {
+    const ret = arg0.beginRenderPass(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_call_0e855b388e315e17() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.call(arg1, arg2, arg3);
+    return ret;
+}, arguments); }
+export function __wbg_call_5575218572ead796() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments); }
+export function __wbg_call_8e98ed2f3c86c4b5() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_copyTextureToTexture_1be188df1e535c0a() { return handleError(function (arg0, arg1, arg2, arg3) {
+    arg0.copyTextureToTexture(arg1, arg2, arg3);
+}, arguments); }
+export function __wbg_createBindGroup_2320df4db188406c(arg0, arg1) {
+    const ret = arg0.createBindGroup(arg1);
+    return ret;
+}
+export function __wbg_createCommandEncoder_cd88faca35d9ed68(arg0, arg1) {
+    const ret = arg0.createCommandEncoder(arg1);
+    return ret;
+}
+export function __wbg_createTexture_9e76b80a2dc0d12e() { return handleError(function (arg0, arg1) {
+    const ret = arg0.createTexture(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_createView_cc96b5bdd3d5bf5e() { return handleError(function (arg0, arg1) {
+    const ret = arg0.createView(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_destroy_b5b39f25f0799295(arg0) {
+    arg0.destroy();
+}
+export function __wbg_done_b62d4a7d2286852a(arg0) {
+    const ret = arg0.done;
+    return ret;
+}
+export function __wbg_drawIndexed_68637ebab6dd8d6e(arg0, arg1, arg2, arg3, arg4, arg5) {
+    arg0.drawIndexed(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
+}
+export function __wbg_end_414453a89205612c(arg0) {
+    arg0.end();
+}
+export function __wbg_entries_c261c3fa1f281256(arg0) {
+    const ret = Object.entries(arg0);
+    return ret;
+}
+export function __wbg_finish_087cb89c65c06eb1(arg0) {
+    const ret = arg0.finish();
+    return ret;
+}
+export function __wbg_finish_cfaeede3baf55be1(arg0, arg1) {
+    const ret = arg0.finish(arg1);
+    return ret;
+}
+export function __wbg_getMappedRange_5ed22727c9679168() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.getMappedRange(arg1, arg2);
+    return ret;
+}, arguments); }
+export function __wbg_get_197a3fe98f169e38(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_get_9a29be2cb383ed9a() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_get_unchecked_54a4374c38e08460(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
+    const ret = arg0[arg1];
+    return ret;
+}
+export function __wbg_instanceof_ArrayBuffer_2a7bb09fee70c2da(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Map_afa18d5840c04c15(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Map;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Uint8Array_f080092dc70f5d58(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_isArray_145a34fd0a38d37b(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+}
+export function __wbg_isSafeInteger_a3389a198582f5f6(arg0) {
+    const ret = Number.isSafeInteger(arg0);
+    return ret;
+}
+export function __wbg_iterator_cc47ba25a2be735a() {
+    const ret = Symbol.iterator;
+    return ret;
+}
+export function __wbg_label_47480289cc2bce71(arg0, arg1) {
+    const ret = arg1.label;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg_length_589238bdcf171f0e(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_length_c6054974c0a6cdb9(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_mapAsync_bb0029907dd91181(arg0, arg1, arg2, arg3) {
+    const ret = arg0.mapAsync(arg1 >>> 0, arg2, arg3);
+    return ret;
+}
+export function __wbg_new_2e117a478906f062() {
+    const ret = new Object();
+    return ret;
+}
+export function __wbg_new_36e147a8ced3c6e0() {
+    const ret = new Array();
+    return ret;
+}
+export function __wbg_new_81880fb5002cb255(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+}
+export function __wbg_new_e66a4b7758dd2e5c(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_with_byte_offset_and_length_f2b65504a914f37a(arg0, arg1, arg2) {
+    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+    return ret;
+}
+export function __wbg_next_0c4066e251d2eff9() { return handleError(function (arg0) {
+    const ret = arg0.next();
+    return ret;
+}, arguments); }
+export function __wbg_next_402fa10b59ab20c3(arg0) {
+    const ret = arg0.next;
+    return ret;
+}
+export function __wbg_onSubmittedWorkDone_1460145eecea40ef(arg0) {
+    const ret = arg0.onSubmittedWorkDone();
+    return ret;
+}
+export function __wbg_prototypesetcall_d721637c7ca66eb8(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_push_f724b5db8acf89d2(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+}
+export function __wbg_queueMicrotask_1c9b3800e321a967(arg0) {
+    const ret = arg0.queueMicrotask;
+    return ret;
+}
+export function __wbg_queueMicrotask_311744e534a929a3(arg0) {
+    queueMicrotask(arg0);
+}
+export function __wbg_resolve_d82363d90af6928a(arg0) {
+    const ret = Promise.resolve(arg0);
+    return ret;
+}
+export function __wbg_setBindGroup_4ba56e1e0d26f244() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+    arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
+}, arguments); }
+export function __wbg_setBindGroup_6124849cc8547086(arg0, arg1, arg2) {
+    arg0.setBindGroup(arg1 >>> 0, arg2);
+}
+export function __wbg_setIndexBuffer_17431786d06c1b7c(arg0, arg1, arg2, arg3, arg4) {
+    arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3, arg4);
+}
+export function __wbg_setIndexBuffer_a16ed5b869c87507(arg0, arg1, arg2, arg3) {
+    arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3);
+}
+export function __wbg_setPipeline_bab24dbce96903b9(arg0, arg1) {
+    arg0.setPipeline(arg1);
+}
+export function __wbg_setVertexBuffer_91c4b602d0289943(arg0, arg1, arg2, arg3) {
+    arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3);
+}
+export function __wbg_setVertexBuffer_b508baf8d0ffe331(arg0, arg1, arg2, arg3, arg4) {
+    arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
+}
+export function __wbg_setViewport_f9d423db4f4b4b58(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+    arg0.setViewport(arg1, arg2, arg3, arg4, arg5, arg6);
+}
+export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+}
+export function __wbg_set_a_5f6e488475272136(arg0, arg1) {
+    arg0.a = arg1;
+}
+export function __wbg_set_array_layer_count_daec613068108a9d(arg0, arg1) {
+    arg0.arrayLayerCount = arg1 >>> 0;
+}
+export function __wbg_set_aspect_77332ac136ee94eb(arg0, arg1) {
+    arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
+}
+export function __wbg_set_aspect_a823a14d00d42d37(arg0, arg1) {
+    arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
+}
+export function __wbg_set_b_688365d692bba214(arg0, arg1) {
+    arg0.b = arg1;
+}
+export function __wbg_set_base_array_layer_cc6c68d233489c4b(arg0, arg1) {
+    arg0.baseArrayLayer = arg1 >>> 0;
+}
+export function __wbg_set_base_mip_level_e07a3efe9006d5ea(arg0, arg1) {
+    arg0.baseMipLevel = arg1 >>> 0;
+}
+export function __wbg_set_beginning_of_pass_write_index_27be5b0b35ec3de0(arg0, arg1) {
+    arg0.beginningOfPassWriteIndex = arg1 >>> 0;
+}
+export function __wbg_set_binding_f3c188a8cd21455b(arg0, arg1) {
+    arg0.binding = arg1 >>> 0;
+}
+export function __wbg_set_buffer_55f096330c8912b4(arg0, arg1) {
+    arg0.buffer = arg1;
+}
+export function __wbg_set_bytes_per_row_91681ca78d744888(arg0, arg1) {
+    arg0.bytesPerRow = arg1 >>> 0;
+}
+export function __wbg_set_clear_value_642701f928a5ccb3(arg0, arg1) {
+    arg0.clearValue = arg1;
+}
+export function __wbg_set_color_attachments_abe67f6631926e28(arg0, arg1) {
+    arg0.colorAttachments = arg1;
+}
+export function __wbg_set_dc601f4a69da0bc2(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+}
+export function __wbg_set_depth_clear_value_442bf492734f63b6(arg0, arg1) {
+    arg0.depthClearValue = arg1;
+}
+export function __wbg_set_depth_load_op_34d430b74bb36d91(arg0, arg1) {
+    arg0.depthLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
+}
+export function __wbg_set_depth_or_array_layers_4bbbeadacb393f02(arg0, arg1) {
+    arg0.depthOrArrayLayers = arg1 >>> 0;
+}
+export function __wbg_set_depth_read_only_138a11b10c731094(arg0, arg1) {
+    arg0.depthReadOnly = arg1 !== 0;
+}
+export function __wbg_set_depth_stencil_attachment_1ee0d93bc3273369(arg0, arg1) {
+    arg0.depthStencilAttachment = arg1;
+}
+export function __wbg_set_depth_store_op_0ea0a215313dbda7(arg0, arg1) {
+    arg0.depthStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
+}
+export function __wbg_set_dimension_174ad7e2fb67fb4e(arg0, arg1) {
+    arg0.dimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
+}
+export function __wbg_set_dimension_36e13ccecae5af4b(arg0, arg1) {
+    arg0.dimension = __wbindgen_enum_GpuTextureDimension[arg1];
+}
+export function __wbg_set_end_of_pass_write_index_e8f52fc08bc0603e(arg0, arg1) {
+    arg0.endOfPassWriteIndex = arg1 >>> 0;
+}
+export function __wbg_set_entries_fc76ca4d7da6a709(arg0, arg1) {
+    arg0.entries = arg1;
+}
+export function __wbg_set_format_90860b0321868db4(arg0, arg1) {
+    arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
+}
+export function __wbg_set_format_e9d4b1475bb3bd3b(arg0, arg1) {
+    arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
+}
+export function __wbg_set_g_d4d1d77cf8fdd362(arg0, arg1) {
+    arg0.g = arg1;
+}
+export function __wbg_set_height_e8b5483b8c117d5e(arg0, arg1) {
+    arg0.height = arg1 >>> 0;
+}
+export function __wbg_set_label_03d2396d4655a3e1(arg0, arg1, arg2) {
+    arg0.label = getStringFromWasm0(arg1, arg2);
+}
+export function __wbg_set_label_0c1bd0e976cf0a9a(arg0, arg1, arg2) {
+    arg0.label = getStringFromWasm0(arg1, arg2);
+}
+export function __wbg_set_label_2d2227f4d5991e50(arg0, arg1, arg2) {
+    arg0.label = getStringFromWasm0(arg1, arg2);
+}
+export function __wbg_set_label_8fd860a36d2c7b74(arg0, arg1, arg2) {
+    arg0.label = getStringFromWasm0(arg1, arg2);
+}
+export function __wbg_set_label_d1c24b5a7a3ac31d(arg0, arg1, arg2) {
+    arg0.label = getStringFromWasm0(arg1, arg2);
+}
+export function __wbg_set_label_f92ae11c77d74198(arg0, arg1, arg2) {
+    arg0.label = getStringFromWasm0(arg1, arg2);
+}
+export function __wbg_set_layout_eeef59714f5bf48b(arg0, arg1) {
+    arg0.layout = arg1;
+}
+export function __wbg_set_load_op_56844f51434037bf(arg0, arg1) {
+    arg0.loadOp = __wbindgen_enum_GpuLoadOp[arg1];
+}
+export function __wbg_set_mip_level_246db61be15bdd69(arg0, arg1) {
+    arg0.mipLevel = arg1 >>> 0;
+}
+export function __wbg_set_mip_level_count_72f8bc1f80f7539b(arg0, arg1) {
+    arg0.mipLevelCount = arg1 >>> 0;
+}
+export function __wbg_set_mip_level_count_b19a0d9192e62d5d(arg0, arg1) {
+    arg0.mipLevelCount = arg1 >>> 0;
+}
+export function __wbg_set_offset_73156b0e0b41d79a(arg0, arg1) {
+    arg0.offset = arg1;
+}
+export function __wbg_set_offset_a097a8050a3a9a33(arg0, arg1) {
+    arg0.offset = arg1;
+}
+export function __wbg_set_origin_9b3b0fbe0a5dc469(arg0, arg1) {
+    arg0.origin = arg1;
+}
+export function __wbg_set_query_set_18679a8580267d5a(arg0, arg1) {
+    arg0.querySet = arg1;
+}
+export function __wbg_set_r_527e5a41c4b1a846(arg0, arg1) {
+    arg0.r = arg1;
+}
+export function __wbg_set_resolve_target_fe76b3f99cf72078(arg0, arg1) {
+    arg0.resolveTarget = arg1;
+}
+export function __wbg_set_resource_fe385d2e3dadaf63(arg0, arg1) {
+    arg0.resource = arg1;
+}
+export function __wbg_set_rows_per_image_d198b7e73a38978b(arg0, arg1) {
+    arg0.rowsPerImage = arg1 >>> 0;
+}
+export function __wbg_set_sample_count_865e1d19b84e27e6(arg0, arg1) {
+    arg0.sampleCount = arg1 >>> 0;
+}
+export function __wbg_set_size_1e6281b07cd39177(arg0, arg1) {
+    arg0.size = arg1;
+}
+export function __wbg_set_size_a61ff22205255d61(arg0, arg1) {
+    arg0.size = arg1;
+}
+export function __wbg_set_stencil_clear_value_10b58f674d0177c2(arg0, arg1) {
+    arg0.stencilClearValue = arg1 >>> 0;
+}
+export function __wbg_set_stencil_load_op_f20a90a66acd3d8c(arg0, arg1) {
+    arg0.stencilLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
+}
+export function __wbg_set_stencil_read_only_fb489d191b6d969b(arg0, arg1) {
+    arg0.stencilReadOnly = arg1 !== 0;
+}
+export function __wbg_set_stencil_store_op_477c4cf6422dfa3f(arg0, arg1) {
+    arg0.stencilStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
+}
+export function __wbg_set_store_op_caeede4654b3d847(arg0, arg1) {
+    arg0.storeOp = __wbindgen_enum_GpuStoreOp[arg1];
+}
+export function __wbg_set_texture_16d2be474ce6ad0c(arg0, arg1) {
+    arg0.texture = arg1;
+}
+export function __wbg_set_timestamp_writes_c552d52fbb417005(arg0, arg1) {
+    arg0.timestampWrites = arg1;
+}
+export function __wbg_set_usage_7f0dda8309469b1c(arg0, arg1) {
+    arg0.usage = arg1 >>> 0;
+}
+export function __wbg_set_usage_7fa9cd18d1104aca(arg0, arg1) {
+    arg0.usage = arg1 >>> 0;
+}
+export function __wbg_set_view_bdeab150b5f0768c(arg0, arg1) {
+    arg0.view = arg1;
+}
+export function __wbg_set_view_dbd0294573f64d05(arg0, arg1) {
+    arg0.view = arg1;
+}
+export function __wbg_set_view_formats_bab284fc81b40e70(arg0, arg1) {
+    arg0.viewFormats = arg1;
+}
+export function __wbg_set_width_1a5e2e86fa5bdcd8(arg0, arg1) {
+    arg0.width = arg1 >>> 0;
+}
+export function __wbg_set_x_56f0c2c08a62725c(arg0, arg1) {
+    arg0.x = arg1 >>> 0;
+}
+export function __wbg_set_y_04fb8ce84735b4e1(arg0, arg1) {
+    arg0.y = arg1 >>> 0;
+}
+export function __wbg_set_z_a51316db27a4941e(arg0, arg1) {
+    arg0.z = arg1 >>> 0;
+}
+export function __wbg_static_accessor_GLOBAL_THIS_2fee5048bcca5938() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_GLOBAL_ce44e66a4935da8c() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_SELF_44f6e0cb5e67cdad() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_WINDOW_168f178805d978fe() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_submit_1290d44bb76ecef4(arg0, arg1) {
+    arg0.submit(arg1);
+}
+export function __wbg_then_05edfc8a4fea5106(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+}
+export function __wbg_then_2a84678a50976959(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+}
+export function __wbg_then_591b6b3a75ee817a(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+}
+export function __wbg_unmap_8f06698a75b8331a(arg0) {
+    arg0.unmap();
+}
+export function __wbg_value_49f783bb59765962(arg0) {
+    const ret = arg0.value;
+    return ret;
+}
+export function __wbg_writeBuffer_b4bdd36178348ca5() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+    arg0.writeBuffer(arg1, arg2, getArrayU8FromWasm0(arg3, arg4), arg5, arg6);
+}, arguments); }
+export function __wbg_writeTexture_b45b69132e46a227() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+    arg0.writeTexture(arg1, getArrayU8FromWasm0(arg2, arg3), arg4, arg5);
+}, arguments); }
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1274, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen_63f5332d1d9a4f22___convert__closures_____invoke___wasm_bindgen_63f5332d1d9a4f22___JsValue______true_);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1723, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen_63f5332d1d9a4f22___convert__closures_____invoke___wasm_bindgen_63f5332d1d9a4f22___JsValue__core_608f92abc48d28da___result__Result_____wasm_bindgen_63f5332d1d9a4f22___JsError___true_);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000003(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000004(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000005(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000006(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+}
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+}
+function wasm_bindgen_63f5332d1d9a4f22___convert__closures_____invoke___wasm_bindgen_63f5332d1d9a4f22___JsValue______true_(arg0, arg1, arg2) {
+    wasm.wasm_bindgen_63f5332d1d9a4f22___convert__closures_____invoke___wasm_bindgen_63f5332d1d9a4f22___JsValue______true_(arg0, arg1, arg2);
+}
+
+function wasm_bindgen_63f5332d1d9a4f22___convert__closures_____invoke___wasm_bindgen_63f5332d1d9a4f22___JsValue__core_608f92abc48d28da___result__Result_____wasm_bindgen_63f5332d1d9a4f22___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_63f5332d1d9a4f22___convert__closures_____invoke___wasm_bindgen_63f5332d1d9a4f22___JsValue__core_608f92abc48d28da___result__Result_____wasm_bindgen_63f5332d1d9a4f22___JsError___true_(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+
+const __wbindgen_enum_GpuIndexFormat = ["uint16", "uint32"];
+
+
+const __wbindgen_enum_GpuLoadOp = ["load", "clear"];
+
+
+const __wbindgen_enum_GpuStoreOp = ["store", "discard"];
+
+
+const __wbindgen_enum_GpuTextureAspect = ["all", "stencil-only", "depth-only"];
+
+
+const __wbindgen_enum_GpuTextureDimension = ["1d", "2d", "3d"];
+
+
+const __wbindgen_enum_GpuTextureFormat = ["r8unorm", "r8snorm", "r8uint", "r8sint", "r16uint", "r16sint", "r16float", "rg8unorm", "rg8snorm", "rg8uint", "rg8sint", "r32uint", "r32sint", "r32float", "rg16uint", "rg16sint", "rg16float", "rgba8unorm", "rgba8unorm-srgb", "rgba8snorm", "rgba8uint", "rgba8sint", "bgra8unorm", "bgra8unorm-srgb", "rgb9e5ufloat", "rgb10a2uint", "rgb10a2unorm", "rg11b10ufloat", "rg32uint", "rg32sint", "rg32float", "rgba16uint", "rgba16sint", "rgba16float", "rgba32uint", "rgba32sint", "rgba32float", "stencil8", "depth16unorm", "depth24plus", "depth24plus-stencil8", "depth32float", "depth32float-stencil8", "bc1-rgba-unorm", "bc1-rgba-unorm-srgb", "bc2-rgba-unorm", "bc2-rgba-unorm-srgb", "bc3-rgba-unorm", "bc3-rgba-unorm-srgb", "bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm", "bc6h-rgb-ufloat", "bc6h-rgb-float", "bc7-rgba-unorm", "bc7-rgba-unorm-srgb", "etc2-rgb8unorm", "etc2-rgb8unorm-srgb", "etc2-rgb8a1unorm", "etc2-rgb8a1unorm-srgb", "etc2-rgba8unorm", "etc2-rgba8unorm-srgb", "eac-r11unorm", "eac-r11snorm", "eac-rg11unorm", "eac-rg11snorm", "astc-4x4-unorm", "astc-4x4-unorm-srgb", "astc-5x4-unorm", "astc-5x4-unorm-srgb", "astc-5x5-unorm", "astc-5x5-unorm-srgb", "astc-6x5-unorm", "astc-6x5-unorm-srgb", "astc-6x6-unorm", "astc-6x6-unorm-srgb", "astc-8x5-unorm", "astc-8x5-unorm-srgb", "astc-8x6-unorm", "astc-8x6-unorm-srgb", "astc-8x8-unorm", "astc-8x8-unorm-srgb", "astc-10x5-unorm", "astc-10x5-unorm-srgb", "astc-10x6-unorm", "astc-10x6-unorm-srgb", "astc-10x8-unorm", "astc-10x8-unorm-srgb", "astc-10x10-unorm", "astc-10x10-unorm-srgb", "astc-12x10-unorm", "astc-12x10-unorm-srgb", "astc-12x12-unorm", "astc-12x12-unorm-srgb"];
+
+
+const __wbindgen_enum_GpuTextureViewDimension = ["1d", "2d", "2d-array", "cube", "cube-array", "3d"];
+const HandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_handle_free(ptr, 1));
+const ProteusAppFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_proteusapp_free(ptr, 1));
+const TextureHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_texturehandle_free(ptr, 1));
+const TransitionChannelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_transitionchannel_free(ptr, 1));
+const VideoHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_videohandle_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_destroy_closure(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}