Trait script::dom::bindings::reflector::DomObjectWrap

pub trait DomObjectWrap: Sized + DomObject {
    const WRAP: unsafe fn(_: JSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>>;
}

A trait to provide a function pointer to wrap function for DOM objects.

Required Associated Constants

const WRAP: unsafe fn(_: JSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>>

Function pointer to the general wrap function type

Implementors

impl DomObjectWrap for AbstractRange

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AbstractRangeBinding::AbstractRange_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::abstractrange::AbstractRange>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::abstractrange::AbstractRange>>}

impl DomObjectWrap for AnalyserNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AnalyserNodeBinding::AnalyserNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::analysernode::AnalyserNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::analysernode::AnalyserNode>>}

impl DomObjectWrap for AnimationEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AnimationEventBinding::AnimationEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::animationevent::AnimationEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::animationevent::AnimationEvent>>}

impl DomObjectWrap for Attr

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AttrBinding::Attr_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::attr::Attr>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::attr::Attr>>}

impl DomObjectWrap for AudioBuffer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioBufferBinding::AudioBuffer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audiobuffer::AudioBuffer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audiobuffer::AudioBuffer>>}

impl DomObjectWrap for AudioBufferSourceNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioBufferSourceNodeBinding::AudioBufferSourceNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audiobuffersourcenode::AudioBufferSourceNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audiobuffersourcenode::AudioBufferSourceNode>>}

impl DomObjectWrap for AudioContext

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioContextBinding::AudioContext_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audiocontext::AudioContext>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audiocontext::AudioContext>>}

impl DomObjectWrap for AudioDestinationNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioDestinationNodeBinding::AudioDestinationNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audiodestinationnode::AudioDestinationNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audiodestinationnode::AudioDestinationNode>>}

impl DomObjectWrap for AudioListener

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioListenerBinding::AudioListener_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audiolistener::AudioListener>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audiolistener::AudioListener>>}

impl DomObjectWrap for AudioNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioNodeBinding::AudioNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audionode::AudioNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audionode::AudioNode>>}

impl DomObjectWrap for AudioParam

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioParamBinding::AudioParam_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audioparam::AudioParam>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audioparam::AudioParam>>}

impl DomObjectWrap for AudioScheduledSourceNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioScheduledSourceNodeBinding::AudioScheduledSourceNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audioscheduledsourcenode::AudioScheduledSourceNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audioscheduledsourcenode::AudioScheduledSourceNode>>}

impl DomObjectWrap for AudioTrack

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioTrackBinding::AudioTrack_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audiotrack::AudioTrack>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audiotrack::AudioTrack>>}

impl DomObjectWrap for AudioTrackList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::AudioTrackListBinding::AudioTrackList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::audiotracklist::AudioTrackList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::audiotracklist::AudioTrackList>>}

impl DomObjectWrap for BaseAudioContext

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BaseAudioContextBinding::BaseAudioContext_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::baseaudiocontext::BaseAudioContext>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::baseaudiocontext::BaseAudioContext>>}

impl DomObjectWrap for BeforeUnloadEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BeforeUnloadEventBinding::BeforeUnloadEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::beforeunloadevent::BeforeUnloadEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::beforeunloadevent::BeforeUnloadEvent>>}

impl DomObjectWrap for BiquadFilterNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BiquadFilterNodeBinding::BiquadFilterNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::biquadfilternode::BiquadFilterNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::biquadfilternode::BiquadFilterNode>>}

impl DomObjectWrap for Blob

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BlobBinding::Blob_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::blob::Blob>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::blob::Blob>>}

impl DomObjectWrap for Bluetooth

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothBinding::Bluetooth_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetooth::Bluetooth>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetooth::Bluetooth>>}

impl DomObjectWrap for BluetoothAdvertisingEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothAdvertisingEventBinding::BluetoothAdvertisingEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetoothadvertisingevent::BluetoothAdvertisingEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetoothadvertisingevent::BluetoothAdvertisingEvent>>}

impl DomObjectWrap for BluetoothCharacteristicProperties

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothCharacteristicPropertiesBinding::BluetoothCharacteristicProperties_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetoothcharacteristicproperties::BluetoothCharacteristicProperties>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetoothcharacteristicproperties::BluetoothCharacteristicProperties>>}

impl DomObjectWrap for BluetoothDevice

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothDeviceBinding::BluetoothDevice_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetoothdevice::BluetoothDevice>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetoothdevice::BluetoothDevice>>}

impl DomObjectWrap for BluetoothPermissionResult

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothPermissionResultBinding::BluetoothPermissionResult_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetoothpermissionresult::BluetoothPermissionResult>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetoothpermissionresult::BluetoothPermissionResult>>}

impl DomObjectWrap for BluetoothRemoteGATTCharacteristic

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothRemoteGATTCharacteristicBinding::BluetoothRemoteGATTCharacteristic_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetoothremotegattcharacteristic::BluetoothRemoteGATTCharacteristic>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetoothremotegattcharacteristic::BluetoothRemoteGATTCharacteristic>>}

impl DomObjectWrap for BluetoothRemoteGATTDescriptor

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothRemoteGATTDescriptorBinding::BluetoothRemoteGATTDescriptor_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetoothremotegattdescriptor::BluetoothRemoteGATTDescriptor>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetoothremotegattdescriptor::BluetoothRemoteGATTDescriptor>>}

impl DomObjectWrap for BluetoothRemoteGATTServer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding::BluetoothRemoteGATTServer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetoothremotegattserver::BluetoothRemoteGATTServer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetoothremotegattserver::BluetoothRemoteGATTServer>>}

impl DomObjectWrap for BluetoothRemoteGATTService

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding::BluetoothRemoteGATTService_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetoothremotegattservice::BluetoothRemoteGATTService>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetoothremotegattservice::BluetoothRemoteGATTService>>}

impl DomObjectWrap for BluetoothUUID

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BluetoothUUIDBinding::BluetoothUUID_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::bluetoothuuid::BluetoothUUID>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::bluetoothuuid::BluetoothUUID>>}

impl DomObjectWrap for BroadcastChannel

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::BroadcastChannelBinding::BroadcastChannel_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::broadcastchannel::BroadcastChannel>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::broadcastchannel::BroadcastChannel>>}

impl DomObjectWrap for CanvasGradient

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasGradient_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::canvasgradient::CanvasGradient>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::canvasgradient::CanvasGradient>>}

impl DomObjectWrap for CanvasPattern

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasPattern_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::canvaspattern::CanvasPattern>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::canvaspattern::CanvasPattern>>}

impl DomObjectWrap for CanvasRenderingContext2D

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::CanvasRenderingContext2D_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::canvasrenderingcontext2d::CanvasRenderingContext2D>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::canvasrenderingcontext2d::CanvasRenderingContext2D>>}

impl DomObjectWrap for CDATASection

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CDATASectionBinding::CDATASection_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cdatasection::CDATASection>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cdatasection::CDATASection>>}

impl DomObjectWrap for ChannelMergerNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ChannelMergerNodeBinding::ChannelMergerNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::channelmergernode::ChannelMergerNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::channelmergernode::ChannelMergerNode>>}

impl DomObjectWrap for ChannelSplitterNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ChannelSplitterNodeBinding::ChannelSplitterNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::channelsplitternode::ChannelSplitterNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::channelsplitternode::ChannelSplitterNode>>}

impl DomObjectWrap for Client

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ClientBinding::Client_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::client::Client>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::client::Client>>}

impl DomObjectWrap for CloseEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CloseEventBinding::CloseEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::closeevent::CloseEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::closeevent::CloseEvent>>}

impl DomObjectWrap for Comment

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CommentBinding::Comment_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::comment::Comment>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::comment::Comment>>}

impl DomObjectWrap for CompositionEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CompositionEventBinding::CompositionEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::compositionevent::CompositionEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::compositionevent::CompositionEvent>>}

impl DomObjectWrap for ConstantSourceNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ConstantSourceNodeBinding::ConstantSourceNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::constantsourcenode::ConstantSourceNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::constantsourcenode::ConstantSourceNode>>}

impl DomObjectWrap for Crypto

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CryptoBinding::Crypto_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::crypto::Crypto>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::crypto::Crypto>>}

impl DomObjectWrap for CSSFontFaceRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSFontFaceRuleBinding::CSSFontFaceRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cssfontfacerule::CSSFontFaceRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cssfontfacerule::CSSFontFaceRule>>}

impl DomObjectWrap for CSSImportRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSImportRuleBinding::CSSImportRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cssimportrule::CSSImportRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cssimportrule::CSSImportRule>>}

impl DomObjectWrap for CSSKeyframeRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSKeyframeRuleBinding::CSSKeyframeRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::csskeyframerule::CSSKeyframeRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::csskeyframerule::CSSKeyframeRule>>}

impl DomObjectWrap for CSSKeyframesRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSKeyframesRuleBinding::CSSKeyframesRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::csskeyframesrule::CSSKeyframesRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::csskeyframesrule::CSSKeyframesRule>>}

impl DomObjectWrap for CSSLayerBlockRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSLayerBlockRuleBinding::CSSLayerBlockRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::csslayerblockrule::CSSLayerBlockRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::csslayerblockrule::CSSLayerBlockRule>>}

impl DomObjectWrap for CSSLayerStatementRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSLayerStatementRuleBinding::CSSLayerStatementRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::csslayerstatementrule::CSSLayerStatementRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::csslayerstatementrule::CSSLayerStatementRule>>}

impl DomObjectWrap for CSSMediaRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSMediaRuleBinding::CSSMediaRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cssmediarule::CSSMediaRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cssmediarule::CSSMediaRule>>}

impl DomObjectWrap for CSSNamespaceRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSNamespaceRuleBinding::CSSNamespaceRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cssnamespacerule::CSSNamespaceRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cssnamespacerule::CSSNamespaceRule>>}

impl DomObjectWrap for CSSRuleList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSRuleListBinding::CSSRuleList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cssrulelist::CSSRuleList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cssrulelist::CSSRuleList>>}

impl DomObjectWrap for CSSStyleDeclaration

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSStyleDeclarationBinding::CSSStyleDeclaration_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cssstyledeclaration::CSSStyleDeclaration>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cssstyledeclaration::CSSStyleDeclaration>>}

impl DomObjectWrap for CSSStyleRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSStyleRuleBinding::CSSStyleRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cssstylerule::CSSStyleRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cssstylerule::CSSStyleRule>>}

impl DomObjectWrap for CSSStyleSheet

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSStyleSheetBinding::CSSStyleSheet_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cssstylesheet::CSSStyleSheet>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cssstylesheet::CSSStyleSheet>>}

impl DomObjectWrap for CSSStyleValue

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSStyleValueBinding::CSSStyleValue_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::cssstylevalue::CSSStyleValue>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::cssstylevalue::CSSStyleValue>>}

impl DomObjectWrap for CSSSupportsRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CSSSupportsRuleBinding::CSSSupportsRule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::csssupportsrule::CSSSupportsRule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::csssupportsrule::CSSSupportsRule>>}

impl DomObjectWrap for CustomElementRegistry

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CustomElementRegistryBinding::CustomElementRegistry_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::customelementregistry::CustomElementRegistry>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::customelementregistry::CustomElementRegistry>>}

impl DomObjectWrap for CustomEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CustomEventBinding::CustomEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::customevent::CustomEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::customevent::CustomEvent>>}

impl DomObjectWrap for DissimilarOriginLocation

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DissimilarOriginLocationBinding::DissimilarOriginLocation_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::dissimilaroriginlocation::DissimilarOriginLocation>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::dissimilaroriginlocation::DissimilarOriginLocation>>}

impl DomObjectWrap for Document

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DocumentBinding::Document_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::document::Document>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::document::Document>>}

impl DomObjectWrap for DocumentFragment

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DocumentFragmentBinding::DocumentFragment_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::documentfragment::DocumentFragment>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::documentfragment::DocumentFragment>>}

impl DomObjectWrap for DocumentType

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DocumentTypeBinding::DocumentType_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::documenttype::DocumentType>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::documenttype::DocumentType>>}

impl DomObjectWrap for DOMException

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMException_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::domexception::DOMException>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domexception::DOMException>>}

impl DomObjectWrap for DOMImplementation

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMImplementationBinding::DOMImplementation_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::domimplementation::DOMImplementation>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domimplementation::DOMImplementation>>}

impl DomObjectWrap for DOMMatrix

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMMatrixBinding::DOMMatrix_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::dommatrix::DOMMatrix>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::dommatrix::DOMMatrix>>}

impl DomObjectWrap for DOMMatrixReadOnly

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::dommatrixreadonly::DOMMatrixReadOnly>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::dommatrixreadonly::DOMMatrixReadOnly>>}

impl DomObjectWrap for DOMParser

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMParserBinding::DOMParser_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::domparser::DOMParser>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domparser::DOMParser>>}

impl DomObjectWrap for DOMPoint

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMPointBinding::DOMPoint_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::dompoint::DOMPoint>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::dompoint::DOMPoint>>}

impl DomObjectWrap for DOMPointReadOnly

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMPointReadOnlyBinding::DOMPointReadOnly_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::dompointreadonly::DOMPointReadOnly>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::dompointreadonly::DOMPointReadOnly>>}

impl DomObjectWrap for DOMQuad

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMQuadBinding::DOMQuad_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::domquad::DOMQuad>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domquad::DOMQuad>>}

impl DomObjectWrap for DOMRect

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMRectBinding::DOMRect_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::domrect::DOMRect>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domrect::DOMRect>>}

impl DomObjectWrap for DOMRectReadOnly

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMRectReadOnlyBinding::DOMRectReadOnly_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::domrectreadonly::DOMRectReadOnly>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domrectreadonly::DOMRectReadOnly>>}

impl DomObjectWrap for DOMStringList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMStringListBinding::DOMStringList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::domstringlist::DOMStringList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domstringlist::DOMStringList>>}

impl DomObjectWrap for DOMStringMap

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMStringMapBinding::DOMStringMap_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::domstringmap::DOMStringMap>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domstringmap::DOMStringMap>>}

impl DomObjectWrap for DOMTokenList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DOMTokenListBinding::DOMTokenList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::domtokenlist::DOMTokenList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domtokenlist::DOMTokenList>>}

impl DomObjectWrap for DynamicModuleOwner

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::DynamicModuleOwnerBinding::DynamicModuleOwner_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::dynamicmoduleowner::DynamicModuleOwner>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::dynamicmoduleowner::DynamicModuleOwner>>}

impl DomObjectWrap for Element

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ElementBinding::Element_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::element::Element>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::element::Element>>}

impl DomObjectWrap for ElementInternals

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ElementInternalsBinding::ElementInternals_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::elementinternals::ElementInternals>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::elementinternals::ElementInternals>>}

impl DomObjectWrap for ErrorEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ErrorEventBinding::ErrorEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::errorevent::ErrorEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::errorevent::ErrorEvent>>}

impl DomObjectWrap for Event

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::EventBinding::Event_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::event::Event>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::event::Event>>}

impl DomObjectWrap for EventSource

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::EventSourceBinding::EventSource_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::eventsource::EventSource>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::eventsource::EventSource>>}

impl DomObjectWrap for EventTarget

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::EventTargetBinding::EventTarget_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::eventtarget::EventTarget>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::eventtarget::EventTarget>>}

impl DomObjectWrap for ExtendableEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ExtendableEventBinding::ExtendableEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::extendableevent::ExtendableEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::extendableevent::ExtendableEvent>>}

impl DomObjectWrap for ExtendableMessageEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ExtendableMessageEventBinding::ExtendableMessageEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::extendablemessageevent::ExtendableMessageEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::extendablemessageevent::ExtendableMessageEvent>>}

impl DomObjectWrap for FakeXRDevice

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::FakeXRDeviceBinding::FakeXRDevice_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::fakexrdevice::FakeXRDevice>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::fakexrdevice::FakeXRDevice>>}

impl DomObjectWrap for FakeXRInputController

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::FakeXRInputControllerBinding::FakeXRInputController_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::fakexrinputcontroller::FakeXRInputController>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::fakexrinputcontroller::FakeXRInputController>>}

impl DomObjectWrap for File

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::FileBinding::File_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::file::File>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::file::File>>}

impl DomObjectWrap for FileList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::FileListBinding::FileList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::filelist::FileList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::filelist::FileList>>}

impl DomObjectWrap for FileReader

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::FileReaderBinding::FileReader_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::filereader::FileReader>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::filereader::FileReader>>}

impl DomObjectWrap for FileReaderSync

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::FileReaderSyncBinding::FileReaderSync_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::filereadersync::FileReaderSync>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::filereadersync::FileReaderSync>>}

impl DomObjectWrap for FocusEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::FocusEventBinding::FocusEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::focusevent::FocusEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::focusevent::FocusEvent>>}

impl DomObjectWrap for FormData

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::FormDataBinding::FormData_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::formdata::FormData>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::formdata::FormData>>}

impl DomObjectWrap for FormDataEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::FormDataEventBinding::FormDataEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::formdataevent::FormDataEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::formdataevent::FormDataEvent>>}

impl DomObjectWrap for GainNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::GainNodeBinding::GainNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gainnode::GainNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gainnode::GainNode>>}

impl DomObjectWrap for Gamepad

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::GamepadBinding::Gamepad_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gamepad::Gamepad>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gamepad::Gamepad>>}

impl DomObjectWrap for GamepadButton

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::GamepadButtonBinding::GamepadButton_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gamepadbutton::GamepadButton>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gamepadbutton::GamepadButton>>}

impl DomObjectWrap for GamepadButtonList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::GamepadButtonListBinding::GamepadButtonList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gamepadbuttonlist::GamepadButtonList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gamepadbuttonlist::GamepadButtonList>>}

impl DomObjectWrap for GamepadEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::GamepadEventBinding::GamepadEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gamepadevent::GamepadEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gamepadevent::GamepadEvent>>}

impl DomObjectWrap for GamepadPose

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::GamepadPoseBinding::GamepadPose_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gamepadpose::GamepadPose>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gamepadpose::GamepadPose>>}

impl DomObjectWrap for GPU

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPU_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpu::GPU>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpu::GPU>>}

impl DomObjectWrap for GPUAdapter

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUAdapter_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpuadapter::GPUAdapter>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpuadapter::GPUAdapter>>}

impl DomObjectWrap for GPUAdapterInfo

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUAdapterInfo_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpuadapterinfo::GPUAdapterInfo>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpuadapterinfo::GPUAdapterInfo>>}

impl DomObjectWrap for GPUBindGroup

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUBindGroup_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpubindgroup::GPUBindGroup>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpubindgroup::GPUBindGroup>>}

impl DomObjectWrap for GPUBindGroupLayout

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUBindGroupLayout_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpubindgrouplayout::GPUBindGroupLayout>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpubindgrouplayout::GPUBindGroupLayout>>}

impl DomObjectWrap for GPUBuffer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUBuffer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpubuffer::GPUBuffer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpubuffer::GPUBuffer>>}

impl DomObjectWrap for GPUBufferUsage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUBufferUsage_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpubufferusage::GPUBufferUsage>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpubufferusage::GPUBufferUsage>>}

impl DomObjectWrap for GPUCanvasContext

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUCanvasContext_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpucanvascontext::GPUCanvasContext>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpucanvascontext::GPUCanvasContext>>}

impl DomObjectWrap for GPUColorWrite

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUColorWrite_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpucolorwrite::GPUColorWrite>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpucolorwrite::GPUColorWrite>>}

impl DomObjectWrap for GPUCommandBuffer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUCommandBuffer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpucommandbuffer::GPUCommandBuffer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpucommandbuffer::GPUCommandBuffer>>}

impl DomObjectWrap for GPUCommandEncoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUCommandEncoder_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpucommandencoder::GPUCommandEncoder>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpucommandencoder::GPUCommandEncoder>>}

impl DomObjectWrap for GPUCompilationInfo

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUCompilationInfo_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpucompilationinfo::GPUCompilationInfo>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpucompilationinfo::GPUCompilationInfo>>}

impl DomObjectWrap for GPUCompilationMessage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUCompilationMessage_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpucompilationmessage::GPUCompilationMessage>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpucompilationmessage::GPUCompilationMessage>>}

impl DomObjectWrap for GPUComputePassEncoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUComputePassEncoder_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpucomputepassencoder::GPUComputePassEncoder>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpucomputepassencoder::GPUComputePassEncoder>>}

impl DomObjectWrap for GPUComputePipeline

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUComputePipeline_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpucomputepipeline::GPUComputePipeline>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpucomputepipeline::GPUComputePipeline>>}

impl DomObjectWrap for GPUDevice

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUDevice_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpudevice::GPUDevice>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpudevice::GPUDevice>>}

impl DomObjectWrap for GPUDeviceLostInfo

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUDeviceLostInfo_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpudevicelostinfo::GPUDeviceLostInfo>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpudevicelostinfo::GPUDeviceLostInfo>>}

impl DomObjectWrap for GPUMapMode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUMapMode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpumapmode::GPUMapMode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpumapmode::GPUMapMode>>}

impl DomObjectWrap for GPUOutOfMemoryError

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUOutOfMemoryError_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpuoutofmemoryerror::GPUOutOfMemoryError>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpuoutofmemoryerror::GPUOutOfMemoryError>>}

impl DomObjectWrap for GPUPipelineLayout

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUPipelineLayout_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpupipelinelayout::GPUPipelineLayout>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpupipelinelayout::GPUPipelineLayout>>}

impl DomObjectWrap for GPUQuerySet

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUQuerySet_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpuqueryset::GPUQuerySet>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpuqueryset::GPUQuerySet>>}

impl DomObjectWrap for GPUQueue

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUQueue_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpuqueue::GPUQueue>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpuqueue::GPUQueue>>}

impl DomObjectWrap for GPURenderBundle

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPURenderBundle_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpurenderbundle::GPURenderBundle>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpurenderbundle::GPURenderBundle>>}

impl DomObjectWrap for GPURenderBundleEncoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPURenderBundleEncoder_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpurenderbundleencoder::GPURenderBundleEncoder>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpurenderbundleencoder::GPURenderBundleEncoder>>}

impl DomObjectWrap for GPURenderPassEncoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPURenderPassEncoder_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpurenderpassencoder::GPURenderPassEncoder>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpurenderpassencoder::GPURenderPassEncoder>>}

impl DomObjectWrap for GPURenderPipeline

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPURenderPipeline_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpurenderpipeline::GPURenderPipeline>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpurenderpipeline::GPURenderPipeline>>}

impl DomObjectWrap for GPUSampler

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUSampler_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpusampler::GPUSampler>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpusampler::GPUSampler>>}

impl DomObjectWrap for GPUShaderModule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUShaderModule_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpushadermodule::GPUShaderModule>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpushadermodule::GPUShaderModule>>}

impl DomObjectWrap for GPUShaderStage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUShaderStage_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpushaderstage::GPUShaderStage>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpushaderstage::GPUShaderStage>>}

impl DomObjectWrap for GPUSupportedFeatures

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUSupportedFeatures_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpusupportedfeatures::GPUSupportedFeatures>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpusupportedfeatures::GPUSupportedFeatures>>}

impl DomObjectWrap for GPUSupportedLimits

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUSupportedLimits_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpusupportedlimits::GPUSupportedLimits>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpusupportedlimits::GPUSupportedLimits>>}

impl DomObjectWrap for GPUTexture

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUTexture_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gputexture::GPUTexture>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gputexture::GPUTexture>>}

impl DomObjectWrap for GPUTextureUsage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUTextureUsage_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gputextureusage::GPUTextureUsage>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gputextureusage::GPUTextureUsage>>}

impl DomObjectWrap for GPUTextureView

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUTextureView_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gputextureview::GPUTextureView>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gputextureview::GPUTextureView>>}

impl DomObjectWrap for GPUUncapturedErrorEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUUncapturedErrorEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpuuncapturederrorevent::GPUUncapturedErrorEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpuuncapturederrorevent::GPUUncapturedErrorEvent>>}

impl DomObjectWrap for GPUValidationError

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGPUBinding::GPUValidationError_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::gpuvalidationerror::GPUValidationError>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gpuvalidationerror::GPUValidationError>>}

impl DomObjectWrap for HashChangeEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HashChangeEventBinding::HashChangeEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::hashchangeevent::HashChangeEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::hashchangeevent::HashChangeEvent>>}

impl DomObjectWrap for Headers

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HeadersBinding::Headers_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::headers::Headers>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::headers::Headers>>}

impl DomObjectWrap for History

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HistoryBinding::History_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::history::History>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::history::History>>}

impl DomObjectWrap for HTMLAnchorElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLAnchorElementBinding::HTMLAnchorElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlanchorelement::HTMLAnchorElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlanchorelement::HTMLAnchorElement>>}

impl DomObjectWrap for HTMLAreaElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLAreaElementBinding::HTMLAreaElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlareaelement::HTMLAreaElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlareaelement::HTMLAreaElement>>}

impl DomObjectWrap for HTMLAudioElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLAudioElementBinding::HTMLAudioElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlaudioelement::HTMLAudioElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlaudioelement::HTMLAudioElement>>}

impl DomObjectWrap for HTMLBaseElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLBaseElementBinding::HTMLBaseElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlbaseelement::HTMLBaseElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlbaseelement::HTMLBaseElement>>}

impl DomObjectWrap for HTMLBodyElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLBodyElementBinding::HTMLBodyElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlbodyelement::HTMLBodyElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlbodyelement::HTMLBodyElement>>}

impl DomObjectWrap for HTMLBRElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLBRElementBinding::HTMLBRElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlbrelement::HTMLBRElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlbrelement::HTMLBRElement>>}

impl DomObjectWrap for HTMLButtonElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLButtonElementBinding::HTMLButtonElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlbuttonelement::HTMLButtonElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlbuttonelement::HTMLButtonElement>>}

impl DomObjectWrap for HTMLCanvasElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLCanvasElementBinding::HTMLCanvasElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlcanvaselement::HTMLCanvasElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlcanvaselement::HTMLCanvasElement>>}

impl DomObjectWrap for HTMLCollection

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLCollectionBinding::HTMLCollection_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlcollection::HTMLCollection>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlcollection::HTMLCollection>>}

impl DomObjectWrap for HTMLDataElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLDataElementBinding::HTMLDataElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmldataelement::HTMLDataElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmldataelement::HTMLDataElement>>}

impl DomObjectWrap for HTMLDataListElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLDataListElementBinding::HTMLDataListElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmldatalistelement::HTMLDataListElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmldatalistelement::HTMLDataListElement>>}

impl DomObjectWrap for HTMLDetailsElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLDetailsElementBinding::HTMLDetailsElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmldetailselement::HTMLDetailsElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmldetailselement::HTMLDetailsElement>>}

impl DomObjectWrap for HTMLDialogElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLDialogElementBinding::HTMLDialogElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmldialogelement::HTMLDialogElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmldialogelement::HTMLDialogElement>>}

impl DomObjectWrap for HTMLDirectoryElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLDirectoryElementBinding::HTMLDirectoryElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmldirectoryelement::HTMLDirectoryElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmldirectoryelement::HTMLDirectoryElement>>}

impl DomObjectWrap for HTMLDivElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLDivElementBinding::HTMLDivElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmldivelement::HTMLDivElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmldivelement::HTMLDivElement>>}

impl DomObjectWrap for HTMLDListElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLDListElementBinding::HTMLDListElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmldlistelement::HTMLDListElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmldlistelement::HTMLDListElement>>}

impl DomObjectWrap for HTMLElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLElementBinding::HTMLElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlelement::HTMLElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlelement::HTMLElement>>}

impl DomObjectWrap for HTMLEmbedElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLEmbedElementBinding::HTMLEmbedElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlembedelement::HTMLEmbedElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlembedelement::HTMLEmbedElement>>}

impl DomObjectWrap for HTMLFieldSetElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLFieldSetElementBinding::HTMLFieldSetElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlfieldsetelement::HTMLFieldSetElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlfieldsetelement::HTMLFieldSetElement>>}

impl DomObjectWrap for HTMLFontElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLFontElementBinding::HTMLFontElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlfontelement::HTMLFontElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlfontelement::HTMLFontElement>>}

impl DomObjectWrap for HTMLFormControlsCollection

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLFormControlsCollectionBinding::HTMLFormControlsCollection_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlformcontrolscollection::HTMLFormControlsCollection>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlformcontrolscollection::HTMLFormControlsCollection>>}

impl DomObjectWrap for HTMLFormElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLFormElementBinding::HTMLFormElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlformelement::HTMLFormElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlformelement::HTMLFormElement>>}

impl DomObjectWrap for HTMLFrameElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLFrameElementBinding::HTMLFrameElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlframeelement::HTMLFrameElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlframeelement::HTMLFrameElement>>}

impl DomObjectWrap for HTMLFrameSetElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLFrameSetElementBinding::HTMLFrameSetElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlframesetelement::HTMLFrameSetElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlframesetelement::HTMLFrameSetElement>>}

impl DomObjectWrap for HTMLHeadElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLHeadElementBinding::HTMLHeadElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlheadelement::HTMLHeadElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlheadelement::HTMLHeadElement>>}

impl DomObjectWrap for HTMLHeadingElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLHeadingElementBinding::HTMLHeadingElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlheadingelement::HTMLHeadingElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlheadingelement::HTMLHeadingElement>>}

impl DomObjectWrap for HTMLHRElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLHRElementBinding::HTMLHRElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlhrelement::HTMLHRElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlhrelement::HTMLHRElement>>}

impl DomObjectWrap for HTMLHtmlElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLHtmlElementBinding::HTMLHtmlElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlhtmlelement::HTMLHtmlElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlhtmlelement::HTMLHtmlElement>>}

impl DomObjectWrap for HTMLIFrameElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLIFrameElementBinding::HTMLIFrameElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmliframeelement::HTMLIFrameElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmliframeelement::HTMLIFrameElement>>}

impl DomObjectWrap for HTMLImageElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLImageElementBinding::HTMLImageElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlimageelement::HTMLImageElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlimageelement::HTMLImageElement>>}

impl DomObjectWrap for HTMLInputElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlinputelement::HTMLInputElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlinputelement::HTMLInputElement>>}

impl DomObjectWrap for HTMLLabelElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLLabelElementBinding::HTMLLabelElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmllabelelement::HTMLLabelElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmllabelelement::HTMLLabelElement>>}

impl DomObjectWrap for HTMLLegendElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLLegendElementBinding::HTMLLegendElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmllegendelement::HTMLLegendElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmllegendelement::HTMLLegendElement>>}

impl DomObjectWrap for HTMLLIElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLLIElementBinding::HTMLLIElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmllielement::HTMLLIElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmllielement::HTMLLIElement>>}

impl DomObjectWrap for HTMLLinkElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLLinkElementBinding::HTMLLinkElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmllinkelement::HTMLLinkElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmllinkelement::HTMLLinkElement>>}

impl DomObjectWrap for HTMLMapElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLMapElementBinding::HTMLMapElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlmapelement::HTMLMapElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlmapelement::HTMLMapElement>>}

impl DomObjectWrap for HTMLMenuElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLMenuElementBinding::HTMLMenuElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlmenuelement::HTMLMenuElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlmenuelement::HTMLMenuElement>>}

impl DomObjectWrap for HTMLMetaElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLMetaElementBinding::HTMLMetaElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlmetaelement::HTMLMetaElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlmetaelement::HTMLMetaElement>>}

impl DomObjectWrap for HTMLMeterElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLMeterElementBinding::HTMLMeterElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlmeterelement::HTMLMeterElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlmeterelement::HTMLMeterElement>>}

impl DomObjectWrap for HTMLModElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLModElementBinding::HTMLModElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlmodelement::HTMLModElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlmodelement::HTMLModElement>>}

impl DomObjectWrap for HTMLObjectElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLObjectElementBinding::HTMLObjectElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlobjectelement::HTMLObjectElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlobjectelement::HTMLObjectElement>>}

impl DomObjectWrap for HTMLOListElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLOListElementBinding::HTMLOListElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlolistelement::HTMLOListElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlolistelement::HTMLOListElement>>}

impl DomObjectWrap for HTMLOptGroupElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLOptGroupElementBinding::HTMLOptGroupElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmloptgroupelement::HTMLOptGroupElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmloptgroupelement::HTMLOptGroupElement>>}

impl DomObjectWrap for HTMLOptionElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLOptionElementBinding::HTMLOptionElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmloptionelement::HTMLOptionElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmloptionelement::HTMLOptionElement>>}

impl DomObjectWrap for HTMLOptionsCollection

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLOptionsCollectionBinding::HTMLOptionsCollection_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmloptionscollection::HTMLOptionsCollection>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmloptionscollection::HTMLOptionsCollection>>}

impl DomObjectWrap for HTMLOutputElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLOutputElementBinding::HTMLOutputElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmloutputelement::HTMLOutputElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmloutputelement::HTMLOutputElement>>}

impl DomObjectWrap for HTMLParagraphElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLParagraphElementBinding::HTMLParagraphElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlparagraphelement::HTMLParagraphElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlparagraphelement::HTMLParagraphElement>>}

impl DomObjectWrap for HTMLParamElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLParamElementBinding::HTMLParamElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlparamelement::HTMLParamElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlparamelement::HTMLParamElement>>}

impl DomObjectWrap for HTMLPictureElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLPictureElementBinding::HTMLPictureElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlpictureelement::HTMLPictureElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlpictureelement::HTMLPictureElement>>}

impl DomObjectWrap for HTMLPreElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLPreElementBinding::HTMLPreElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlpreelement::HTMLPreElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlpreelement::HTMLPreElement>>}

impl DomObjectWrap for HTMLProgressElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLProgressElementBinding::HTMLProgressElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlprogresselement::HTMLProgressElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlprogresselement::HTMLProgressElement>>}

impl DomObjectWrap for HTMLQuoteElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLQuoteElementBinding::HTMLQuoteElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlquoteelement::HTMLQuoteElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlquoteelement::HTMLQuoteElement>>}

impl DomObjectWrap for HTMLScriptElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLScriptElementBinding::HTMLScriptElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlscriptelement::HTMLScriptElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlscriptelement::HTMLScriptElement>>}

impl DomObjectWrap for HTMLSelectElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLSelectElementBinding::HTMLSelectElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlselectelement::HTMLSelectElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlselectelement::HTMLSelectElement>>}

impl DomObjectWrap for HTMLSourceElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLSourceElementBinding::HTMLSourceElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlsourceelement::HTMLSourceElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlsourceelement::HTMLSourceElement>>}

impl DomObjectWrap for HTMLSpanElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLSpanElementBinding::HTMLSpanElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlspanelement::HTMLSpanElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlspanelement::HTMLSpanElement>>}

impl DomObjectWrap for HTMLStyleElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLStyleElementBinding::HTMLStyleElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlstyleelement::HTMLStyleElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlstyleelement::HTMLStyleElement>>}

impl DomObjectWrap for HTMLTableCaptionElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTableCaptionElementBinding::HTMLTableCaptionElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltablecaptionelement::HTMLTableCaptionElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltablecaptionelement::HTMLTableCaptionElement>>}

impl DomObjectWrap for HTMLTableCellElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTableCellElementBinding::HTMLTableCellElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltablecellelement::HTMLTableCellElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltablecellelement::HTMLTableCellElement>>}

impl DomObjectWrap for HTMLTableColElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTableColElementBinding::HTMLTableColElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltablecolelement::HTMLTableColElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltablecolelement::HTMLTableColElement>>}

impl DomObjectWrap for HTMLTableElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTableElementBinding::HTMLTableElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltableelement::HTMLTableElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltableelement::HTMLTableElement>>}

impl DomObjectWrap for HTMLTableRowElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTableRowElementBinding::HTMLTableRowElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltablerowelement::HTMLTableRowElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltablerowelement::HTMLTableRowElement>>}

impl DomObjectWrap for HTMLTableSectionElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTableSectionElementBinding::HTMLTableSectionElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltablesectionelement::HTMLTableSectionElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltablesectionelement::HTMLTableSectionElement>>}

impl DomObjectWrap for HTMLTemplateElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltemplateelement::HTMLTemplateElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltemplateelement::HTMLTemplateElement>>}

impl DomObjectWrap for HTMLTextAreaElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTextAreaElementBinding::HTMLTextAreaElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltextareaelement::HTMLTextAreaElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltextareaelement::HTMLTextAreaElement>>}

impl DomObjectWrap for HTMLTimeElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTimeElementBinding::HTMLTimeElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltimeelement::HTMLTimeElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltimeelement::HTMLTimeElement>>}

impl DomObjectWrap for HTMLTitleElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTitleElementBinding::HTMLTitleElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltitleelement::HTMLTitleElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltitleelement::HTMLTitleElement>>}

impl DomObjectWrap for HTMLTrackElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLTrackElementBinding::HTMLTrackElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmltrackelement::HTMLTrackElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmltrackelement::HTMLTrackElement>>}

impl DomObjectWrap for HTMLUListElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLUListElementBinding::HTMLUListElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlulistelement::HTMLUListElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlulistelement::HTMLUListElement>>}

impl DomObjectWrap for HTMLUnknownElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLUnknownElementBinding::HTMLUnknownElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlunknownelement::HTMLUnknownElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlunknownelement::HTMLUnknownElement>>}

impl DomObjectWrap for HTMLVideoElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::HTMLVideoElementBinding::HTMLVideoElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::htmlvideoelement::HTMLVideoElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlvideoelement::HTMLVideoElement>>}

impl DomObjectWrap for ImageBitmap

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmap_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::imagebitmap::ImageBitmap>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::imagebitmap::ImageBitmap>>}

impl DomObjectWrap for ImageData

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding::ImageData_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::imagedata::ImageData>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::imagedata::ImageData>>}

impl DomObjectWrap for InputEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::InputEventBinding::InputEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::inputevent::InputEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::inputevent::InputEvent>>}

impl DomObjectWrap for KeyboardEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::KeyboardEventBinding::KeyboardEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::keyboardevent::KeyboardEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::keyboardevent::KeyboardEvent>>}

impl DomObjectWrap for Location

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::LocationBinding::Location_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::location::Location>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::location::Location>>}

impl DomObjectWrap for MediaDeviceInfo

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaDeviceInfoBinding::MediaDeviceInfo_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediadeviceinfo::MediaDeviceInfo>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediadeviceinfo::MediaDeviceInfo>>}

impl DomObjectWrap for MediaDevices

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaDevicesBinding::MediaDevices_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediadevices::MediaDevices>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediadevices::MediaDevices>>}

impl DomObjectWrap for MediaElementAudioSourceNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaElementAudioSourceNodeBinding::MediaElementAudioSourceNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediaelementaudiosourcenode::MediaElementAudioSourceNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediaelementaudiosourcenode::MediaElementAudioSourceNode>>}

impl DomObjectWrap for MediaError

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaErrorBinding::MediaError_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediaerror::MediaError>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediaerror::MediaError>>}

impl DomObjectWrap for MediaList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaListBinding::MediaList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::medialist::MediaList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::medialist::MediaList>>}

impl DomObjectWrap for MediaMetadata

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaMetadataBinding::MediaMetadata_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediametadata::MediaMetadata>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediametadata::MediaMetadata>>}

impl DomObjectWrap for MediaQueryList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaQueryListBinding::MediaQueryList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediaquerylist::MediaQueryList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediaquerylist::MediaQueryList>>}

impl DomObjectWrap for MediaQueryListEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaQueryListEventBinding::MediaQueryListEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediaquerylistevent::MediaQueryListEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediaquerylistevent::MediaQueryListEvent>>}

impl DomObjectWrap for MediaSession

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaSessionBinding::MediaSession_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediasession::MediaSession>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediasession::MediaSession>>}

impl DomObjectWrap for MediaStream

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaStreamBinding::MediaStream_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediastream::MediaStream>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediastream::MediaStream>>}

impl DomObjectWrap for MediaStreamAudioDestinationNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaStreamAudioDestinationNodeBinding::MediaStreamAudioDestinationNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediastreamaudiodestinationnode::MediaStreamAudioDestinationNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediastreamaudiodestinationnode::MediaStreamAudioDestinationNode>>}

impl DomObjectWrap for MediaStreamAudioSourceNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaStreamAudioSourceNodeBinding::MediaStreamAudioSourceNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediastreamaudiosourcenode::MediaStreamAudioSourceNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediastreamaudiosourcenode::MediaStreamAudioSourceNode>>}

impl DomObjectWrap for MediaStreamTrack

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaStreamTrackBinding::MediaStreamTrack_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediastreamtrack::MediaStreamTrack>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediastreamtrack::MediaStreamTrack>>}

impl DomObjectWrap for MediaStreamTrackAudioSourceNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MediaStreamTrackAudioSourceNodeBinding::MediaStreamTrackAudioSourceNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mediastreamtrackaudiosourcenode::MediaStreamTrackAudioSourceNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mediastreamtrackaudiosourcenode::MediaStreamTrackAudioSourceNode>>}

impl DomObjectWrap for MessageChannel

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MessageChannelBinding::MessageChannel_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::messagechannel::MessageChannel>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::messagechannel::MessageChannel>>}

impl DomObjectWrap for MessageEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MessageEventBinding::MessageEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::messageevent::MessageEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::messageevent::MessageEvent>>}

impl DomObjectWrap for MessagePort

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MessagePortBinding::MessagePort_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::messageport::MessagePort>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::messageport::MessagePort>>}

impl DomObjectWrap for MimeType

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MimeTypeBinding::MimeType_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mimetype::MimeType>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mimetype::MimeType>>}

impl DomObjectWrap for MimeTypeArray

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MimeTypeArrayBinding::MimeTypeArray_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mimetypearray::MimeTypeArray>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mimetypearray::MimeTypeArray>>}

impl DomObjectWrap for MouseEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MouseEventBinding::MouseEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mouseevent::MouseEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mouseevent::MouseEvent>>}

impl DomObjectWrap for MutationObserver

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MutationObserverBinding::MutationObserver_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mutationobserver::MutationObserver>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mutationobserver::MutationObserver>>}

impl DomObjectWrap for MutationRecord

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::MutationRecordBinding::MutationRecord_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::mutationrecord::MutationRecord>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::mutationrecord::MutationRecord>>}

impl DomObjectWrap for NamedNodeMap

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::NamedNodeMapBinding::NamedNodeMap_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::namednodemap::NamedNodeMap>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::namednodemap::NamedNodeMap>>}

impl DomObjectWrap for NavigationPreloadManager

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::NavigationPreloadManagerBinding::NavigationPreloadManager_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::navigationpreloadmanager::NavigationPreloadManager>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::navigationpreloadmanager::NavigationPreloadManager>>}

impl DomObjectWrap for Navigator

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::NavigatorBinding::Navigator_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::navigator::Navigator>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::navigator::Navigator>>}

impl DomObjectWrap for NodeIterator

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::NodeIteratorBinding::NodeIterator_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::nodeiterator::NodeIterator>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::nodeiterator::NodeIterator>>}

impl DomObjectWrap for NodeList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::NodeListBinding::NodeList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::nodelist::NodeList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::nodelist::NodeList>>}

impl DomObjectWrap for OfflineAudioCompletionEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OfflineAudioCompletionEventBinding::OfflineAudioCompletionEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::offlineaudiocompletionevent::OfflineAudioCompletionEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::offlineaudiocompletionevent::OfflineAudioCompletionEvent>>}

impl DomObjectWrap for OfflineAudioContext

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OfflineAudioContextBinding::OfflineAudioContext_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::offlineaudiocontext::OfflineAudioContext>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::offlineaudiocontext::OfflineAudioContext>>}

impl DomObjectWrap for OffscreenCanvas

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OffscreenCanvasBinding::OffscreenCanvas_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::offscreencanvas::OffscreenCanvas>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::offscreencanvas::OffscreenCanvas>>}

impl DomObjectWrap for OffscreenCanvasRenderingContext2D

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OffscreenCanvasRenderingContext2DBinding::OffscreenCanvasRenderingContext2D_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::offscreencanvasrenderingcontext2d::OffscreenCanvasRenderingContext2D>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::offscreencanvasrenderingcontext2d::OffscreenCanvasRenderingContext2D>>}

impl DomObjectWrap for OscillatorNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OscillatorNodeBinding::OscillatorNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::oscillatornode::OscillatorNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::oscillatornode::OscillatorNode>>}

impl DomObjectWrap for PageTransitionEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PageTransitionEventBinding::PageTransitionEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::pagetransitionevent::PageTransitionEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::pagetransitionevent::PageTransitionEvent>>}

impl DomObjectWrap for PaintRenderingContext2D

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PaintRenderingContext2DBinding::PaintRenderingContext2D_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::paintrenderingcontext2d::PaintRenderingContext2D>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::paintrenderingcontext2d::PaintRenderingContext2D>>}

impl DomObjectWrap for PaintSize

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PaintSizeBinding::PaintSize_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::paintsize::PaintSize>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::paintsize::PaintSize>>}

impl DomObjectWrap for PannerNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PannerNodeBinding::PannerNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::pannernode::PannerNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::pannernode::PannerNode>>}

impl DomObjectWrap for Performance

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformanceBinding::Performance_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performance::Performance>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performance::Performance>>}

impl DomObjectWrap for PerformanceEntry

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformanceEntryBinding::PerformanceEntry_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performanceentry::PerformanceEntry>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performanceentry::PerformanceEntry>>}

impl DomObjectWrap for PerformanceMark

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformanceMarkBinding::PerformanceMark_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performancemark::PerformanceMark>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performancemark::PerformanceMark>>}

impl DomObjectWrap for PerformanceMeasure

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformanceMeasureBinding::PerformanceMeasure_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performancemeasure::PerformanceMeasure>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performancemeasure::PerformanceMeasure>>}

impl DomObjectWrap for PerformanceNavigation

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformanceNavigationBinding::PerformanceNavigation_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performancenavigation::PerformanceNavigation>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performancenavigation::PerformanceNavigation>>}

impl DomObjectWrap for PerformanceNavigationTiming

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformanceNavigationTimingBinding::PerformanceNavigationTiming_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performancenavigationtiming::PerformanceNavigationTiming>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performancenavigationtiming::PerformanceNavigationTiming>>}

impl DomObjectWrap for PerformanceObserver

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformanceObserverBinding::PerformanceObserver_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performanceobserver::PerformanceObserver>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performanceobserver::PerformanceObserver>>}

impl DomObjectWrap for PerformanceObserverEntryList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformanceObserverEntryListBinding::PerformanceObserverEntryList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performanceobserverentrylist::PerformanceObserverEntryList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performanceobserverentrylist::PerformanceObserverEntryList>>}

impl DomObjectWrap for PerformancePaintTiming

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformancePaintTimingBinding::PerformancePaintTiming_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performancepainttiming::PerformancePaintTiming>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performancepainttiming::PerformancePaintTiming>>}

impl DomObjectWrap for PerformanceResourceTiming

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PerformanceResourceTimingBinding::PerformanceResourceTiming_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::performanceresourcetiming::PerformanceResourceTiming>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::performanceresourcetiming::PerformanceResourceTiming>>}

impl DomObjectWrap for Permissions

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PermissionsBinding::Permissions_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::permissions::Permissions>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::permissions::Permissions>>}

impl DomObjectWrap for PermissionStatus

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PermissionStatusBinding::PermissionStatus_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::permissionstatus::PermissionStatus>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::permissionstatus::PermissionStatus>>}

impl DomObjectWrap for Plugin

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PluginBinding::Plugin_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::plugin::Plugin>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::plugin::Plugin>>}

impl DomObjectWrap for PluginArray

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PluginArrayBinding::PluginArray_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::pluginarray::PluginArray>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::pluginarray::PluginArray>>}

impl DomObjectWrap for PopStateEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PopStateEventBinding::PopStateEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::popstateevent::PopStateEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::popstateevent::PopStateEvent>>}

impl DomObjectWrap for ProcessingInstruction

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ProcessingInstructionBinding::ProcessingInstruction_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::processinginstruction::ProcessingInstruction>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::processinginstruction::ProcessingInstruction>>}

impl DomObjectWrap for ProgressEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ProgressEventBinding::ProgressEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::progressevent::ProgressEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::progressevent::ProgressEvent>>}

impl DomObjectWrap for PromiseNativeHandler

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PromiseNativeHandlerBinding::PromiseNativeHandler_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::promisenativehandler::PromiseNativeHandler>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::promisenativehandler::PromiseNativeHandler>>}

impl DomObjectWrap for PromiseRejectionEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::PromiseRejectionEventBinding::PromiseRejectionEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::promiserejectionevent::PromiseRejectionEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::promiserejectionevent::PromiseRejectionEvent>>}

impl DomObjectWrap for RadioNodeList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RadioNodeListBinding::RadioNodeList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::radionodelist::RadioNodeList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::radionodelist::RadioNodeList>>}

impl DomObjectWrap for Range

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RangeBinding::Range_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::range::Range>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::range::Range>>}

impl DomObjectWrap for ReadableStream

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ReadableStreamBinding::ReadableStream_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::readablestream::ReadableStream>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::readablestream::ReadableStream>>}

impl DomObjectWrap for Request

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RequestBinding::Request_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::request::Request>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::request::Request>>}

impl DomObjectWrap for Response

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ResponseBinding::Response_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::response::Response>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::response::Response>>}

impl DomObjectWrap for RTCDataChannel

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCDataChannelBinding::RTCDataChannel_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcdatachannel::RTCDataChannel>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcdatachannel::RTCDataChannel>>}

impl DomObjectWrap for RTCDataChannelEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCDataChannelEventBinding::RTCDataChannelEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcdatachannelevent::RTCDataChannelEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcdatachannelevent::RTCDataChannelEvent>>}

impl DomObjectWrap for RTCError

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCErrorBinding::RTCError_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcerror::RTCError>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcerror::RTCError>>}

impl DomObjectWrap for RTCErrorEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCErrorEventBinding::RTCErrorEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcerrorevent::RTCErrorEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcerrorevent::RTCErrorEvent>>}

impl DomObjectWrap for RTCIceCandidate

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCIceCandidateBinding::RTCIceCandidate_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcicecandidate::RTCIceCandidate>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcicecandidate::RTCIceCandidate>>}

impl DomObjectWrap for RTCPeerConnection

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCPeerConnectionBinding::RTCPeerConnection_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcpeerconnection::RTCPeerConnection>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcpeerconnection::RTCPeerConnection>>}

impl DomObjectWrap for RTCPeerConnectionIceEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCPeerConnectionIceEventBinding::RTCPeerConnectionIceEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcpeerconnectioniceevent::RTCPeerConnectionIceEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcpeerconnectioniceevent::RTCPeerConnectionIceEvent>>}

impl DomObjectWrap for RTCRtpSender

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCRtpSenderBinding::RTCRtpSender_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcrtpsender::RTCRtpSender>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcrtpsender::RTCRtpSender>>}

impl DomObjectWrap for RTCRtpTransceiver

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCRtpTransceiverBinding::RTCRtpTransceiver_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcrtptransceiver::RTCRtpTransceiver>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcrtptransceiver::RTCRtpTransceiver>>}

impl DomObjectWrap for RTCSessionDescription

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCSessionDescriptionBinding::RTCSessionDescription_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtcsessiondescription::RTCSessionDescription>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtcsessiondescription::RTCSessionDescription>>}

impl DomObjectWrap for RTCTrackEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::RTCTrackEventBinding::RTCTrackEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::rtctrackevent::RTCTrackEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::rtctrackevent::RTCTrackEvent>>}

impl DomObjectWrap for Screen

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ScreenBinding::Screen_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::screen::Screen>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::screen::Screen>>}

impl DomObjectWrap for Selection

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::SelectionBinding::Selection_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::selection::Selection>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::selection::Selection>>}

impl DomObjectWrap for ServiceWorker

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ServiceWorkerBinding::ServiceWorker_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::serviceworker::ServiceWorker>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::serviceworker::ServiceWorker>>}

impl DomObjectWrap for ServiceWorkerContainer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ServiceWorkerContainerBinding::ServiceWorkerContainer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::serviceworkercontainer::ServiceWorkerContainer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::serviceworkercontainer::ServiceWorkerContainer>>}

impl DomObjectWrap for ServiceWorkerRegistration

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ServiceWorkerRegistrationBinding::ServiceWorkerRegistration_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::serviceworkerregistration::ServiceWorkerRegistration>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::serviceworkerregistration::ServiceWorkerRegistration>>}

impl DomObjectWrap for ServoParser

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ServoParserBinding::ServoParser_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::servoparser::ServoParser>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::servoparser::ServoParser>>}

impl DomObjectWrap for ShadowRoot

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ShadowRootBinding::ShadowRoot_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::shadowroot::ShadowRoot>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::shadowroot::ShadowRoot>>}

impl DomObjectWrap for StaticRange

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::StaticRangeBinding::StaticRange_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::staticrange::StaticRange>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::staticrange::StaticRange>>}

impl DomObjectWrap for StereoPannerNode

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::StereoPannerNodeBinding::StereoPannerNode_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::stereopannernode::StereoPannerNode>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::stereopannernode::StereoPannerNode>>}

impl DomObjectWrap for Storage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::StorageBinding::Storage_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::storage::Storage>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::storage::Storage>>}

impl DomObjectWrap for StorageEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::StorageEventBinding::StorageEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::storageevent::StorageEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::storageevent::StorageEvent>>}

impl DomObjectWrap for StylePropertyMapReadOnly

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::StylePropertyMapReadOnlyBinding::StylePropertyMapReadOnly_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::stylepropertymapreadonly::StylePropertyMapReadOnly>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::stylepropertymapreadonly::StylePropertyMapReadOnly>>}

impl DomObjectWrap for StyleSheet

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::StyleSheetBinding::StyleSheet_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::stylesheet::StyleSheet>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::stylesheet::StyleSheet>>}

impl DomObjectWrap for StyleSheetList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::StyleSheetListBinding::StyleSheetList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::stylesheetlist::StyleSheetList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::stylesheetlist::StyleSheetList>>}

impl DomObjectWrap for SubmitEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::SubmitEventBinding::SubmitEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::submitevent::SubmitEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::submitevent::SubmitEvent>>}

impl DomObjectWrap for SVGElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::SVGElementBinding::SVGElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::svgelement::SVGElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::svgelement::SVGElement>>}

impl DomObjectWrap for SVGSVGElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::SVGSVGElementBinding::SVGSVGElement_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::svgsvgelement::SVGSVGElement>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::svgsvgelement::SVGSVGElement>>}

impl DomObjectWrap for TestBinding

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TestBindingBinding::TestBinding_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::testbinding::TestBinding>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::testbinding::TestBinding>>}

impl DomObjectWrap for TestBindingIterable

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TestBindingIterableBinding::TestBindingIterable_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::testbindingiterable::TestBindingIterable>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::testbindingiterable::TestBindingIterable>>}

impl DomObjectWrap for TestBindingMaplike

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TestBindingMaplikeBinding::TestBindingMaplike_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::testbindingmaplike::TestBindingMaplike>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::testbindingmaplike::TestBindingMaplike>>}

impl DomObjectWrap for TestBindingPairIterable

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TestBindingPairIterableBinding::TestBindingPairIterable_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::testbindingpairiterable::TestBindingPairIterable>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::testbindingpairiterable::TestBindingPairIterable>>}

impl DomObjectWrap for TestBindingProxy

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TestBindingProxyBinding::TestBindingProxy_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::testbindingproxy::TestBindingProxy>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::testbindingproxy::TestBindingProxy>>}

impl DomObjectWrap for TestBindingSetlike

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TestBindingSetlikeBinding::TestBindingSetlike_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::testbindingsetlike::TestBindingSetlike>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::testbindingsetlike::TestBindingSetlike>>}

impl DomObjectWrap for TestRunner

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TestRunnerBinding::TestRunner_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::testrunner::TestRunner>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::testrunner::TestRunner>>}

impl DomObjectWrap for TestWorklet

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TestWorkletBinding::TestWorklet_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::testworklet::TestWorklet>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::testworklet::TestWorklet>>}

impl DomObjectWrap for Text

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TextBinding::Text_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::text::Text>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::text::Text>>}

impl DomObjectWrap for TextDecoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TextDecoderBinding::TextDecoder_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::textdecoder::TextDecoder>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::textdecoder::TextDecoder>>}

impl DomObjectWrap for TextEncoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TextEncoderBinding::TextEncoder_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::textencoder::TextEncoder>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::textencoder::TextEncoder>>}

impl DomObjectWrap for TextMetrics

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TextMetricsBinding::TextMetrics_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::textmetrics::TextMetrics>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::textmetrics::TextMetrics>>}

impl DomObjectWrap for TextTrack

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TextTrackBinding::TextTrack_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::texttrack::TextTrack>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::texttrack::TextTrack>>}

impl DomObjectWrap for TextTrackCue

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TextTrackCueBinding::TextTrackCue_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::texttrackcue::TextTrackCue>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::texttrackcue::TextTrackCue>>}

impl DomObjectWrap for TextTrackCueList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TextTrackCueListBinding::TextTrackCueList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::texttrackcuelist::TextTrackCueList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::texttrackcuelist::TextTrackCueList>>}

impl DomObjectWrap for TextTrackList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TextTrackListBinding::TextTrackList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::texttracklist::TextTrackList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::texttracklist::TextTrackList>>}

impl DomObjectWrap for TimeRanges

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TimeRangesBinding::TimeRanges_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::timeranges::TimeRanges>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::timeranges::TimeRanges>>}

impl DomObjectWrap for Touch

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TouchBinding::Touch_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::touch::Touch>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::touch::Touch>>}

impl DomObjectWrap for TouchEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TouchEventBinding::TouchEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::touchevent::TouchEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::touchevent::TouchEvent>>}

impl DomObjectWrap for TouchList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TouchListBinding::TouchList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::touchlist::TouchList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::touchlist::TouchList>>}

impl DomObjectWrap for TrackEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TrackEventBinding::TrackEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::trackevent::TrackEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::trackevent::TrackEvent>>}

impl DomObjectWrap for TransitionEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TransitionEventBinding::TransitionEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::transitionevent::TransitionEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::transitionevent::TransitionEvent>>}

impl DomObjectWrap for TreeWalker

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::TreeWalkerBinding::TreeWalker_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::treewalker::TreeWalker>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::treewalker::TreeWalker>>}

impl DomObjectWrap for UIEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::UIEventBinding::UIEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::uievent::UIEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::uievent::UIEvent>>}

impl DomObjectWrap for URL

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::URLBinding::URL_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::url::URL>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::url::URL>>}

impl DomObjectWrap for URLSearchParams

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::URLSearchParamsBinding::URLSearchParams_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::urlsearchparams::URLSearchParams>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::urlsearchparams::URLSearchParams>>}

impl DomObjectWrap for ValidityState

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ValidityStateBinding::ValidityState_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::validitystate::ValidityState>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::validitystate::ValidityState>>}

impl DomObjectWrap for VideoTrack

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::VideoTrackBinding::VideoTrack_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::videotrack::VideoTrack>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::videotrack::VideoTrack>>}

impl DomObjectWrap for VideoTrackList

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::VideoTrackListBinding::VideoTrackList_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::videotracklist::VideoTrackList>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::videotracklist::VideoTrackList>>}

impl DomObjectWrap for VTTCue

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::VTTCueBinding::VTTCue_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::vttcue::VTTCue>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::vttcue::VTTCue>>}

impl DomObjectWrap for VTTRegion

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::VTTRegionBinding::VTTRegion_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::vttregion::VTTRegion>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::vttregion::VTTRegion>>}

impl DomObjectWrap for WebGL2RenderingContext

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl2renderingcontext::WebGL2RenderingContext>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl2renderingcontext::WebGL2RenderingContext>>}

impl DomObjectWrap for ANGLEInstancedArrays

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ANGLEInstancedArraysBinding::ANGLEInstancedArrays_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::angleinstancedarrays::ANGLEInstancedArrays>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::angleinstancedarrays::ANGLEInstancedArrays>>}

impl DomObjectWrap for EXTBlendMinmax

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::EXTBlendMinmaxBinding::EXTBlendMinmax_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::extblendminmax::EXTBlendMinmax>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::extblendminmax::EXTBlendMinmax>>}

impl DomObjectWrap for EXTColorBufferHalfFloat

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::EXTColorBufferHalfFloatBinding::EXTColorBufferHalfFloat_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::extcolorbufferhalffloat::EXTColorBufferHalfFloat>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::extcolorbufferhalffloat::EXTColorBufferHalfFloat>>}

impl DomObjectWrap for EXTFragDepth

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::EXTFragDepthBinding::EXTFragDepth_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::extfragdepth::EXTFragDepth>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::extfragdepth::EXTFragDepth>>}

impl DomObjectWrap for EXTShaderTextureLod

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::EXTShaderTextureLodBinding::EXTShaderTextureLod_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::extshadertexturelod::EXTShaderTextureLod>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::extshadertexturelod::EXTShaderTextureLod>>}

impl DomObjectWrap for EXTTextureFilterAnisotropic

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::EXTTextureFilterAnisotropicBinding::EXTTextureFilterAnisotropic_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::exttexturefilteranisotropic::EXTTextureFilterAnisotropic>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::exttexturefilteranisotropic::EXTTextureFilterAnisotropic>>}

impl DomObjectWrap for OESElementIndexUint

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OESElementIndexUintBinding::OESElementIndexUint_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::oeselementindexuint::OESElementIndexUint>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::oeselementindexuint::OESElementIndexUint>>}

impl DomObjectWrap for OESStandardDerivatives

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OESStandardDerivativesBinding::OESStandardDerivatives_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::oesstandardderivatives::OESStandardDerivatives>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::oesstandardderivatives::OESStandardDerivatives>>}

impl DomObjectWrap for OESTextureFloat

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OESTextureFloatBinding::OESTextureFloat_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::oestexturefloat::OESTextureFloat>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::oestexturefloat::OESTextureFloat>>}

impl DomObjectWrap for OESTextureFloatLinear

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OESTextureFloatLinearBinding::OESTextureFloatLinear_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::oestexturefloatlinear::OESTextureFloatLinear>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::oestexturefloatlinear::OESTextureFloatLinear>>}

impl DomObjectWrap for OESTextureHalfFloat

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OESTextureHalfFloatBinding::OESTextureHalfFloat_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::oestexturehalffloat::OESTextureHalfFloat>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::oestexturehalffloat::OESTextureHalfFloat>>}

impl DomObjectWrap for OESTextureHalfFloatLinear

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OESTextureHalfFloatLinearBinding::OESTextureHalfFloatLinear_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::oestexturehalffloatlinear::OESTextureHalfFloatLinear>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::oestexturehalffloatlinear::OESTextureHalfFloatLinear>>}

impl DomObjectWrap for OESVertexArrayObject

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::OESVertexArrayObjectBinding::OESVertexArrayObject_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::oesvertexarrayobject::OESVertexArrayObject>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::oesvertexarrayobject::OESVertexArrayObject>>}

impl DomObjectWrap for WEBGLColorBufferFloat

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WEBGLColorBufferFloatBinding::WEBGLColorBufferFloat_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::webglcolorbufferfloat::WEBGLColorBufferFloat>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::webglcolorbufferfloat::WEBGLColorBufferFloat>>}

impl DomObjectWrap for WEBGLCompressedTextureETC1

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WEBGLCompressedTextureETC1Binding::WEBGLCompressedTextureETC1_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::webglcompressedtextureetc1::WEBGLCompressedTextureETC1>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::webglcompressedtextureetc1::WEBGLCompressedTextureETC1>>}

impl DomObjectWrap for WEBGLCompressedTextureS3TC

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WEBGLCompressedTextureS3TCBinding::WEBGLCompressedTextureS3TC_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgl_extensions::ext::webglcompressedtextures3tc::WEBGLCompressedTextureS3TC>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgl_extensions::ext::webglcompressedtextures3tc::WEBGLCompressedTextureS3TC>>}

impl DomObjectWrap for WebGLActiveInfo

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLActiveInfoBinding::WebGLActiveInfo_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglactiveinfo::WebGLActiveInfo>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglactiveinfo::WebGLActiveInfo>>}

impl DomObjectWrap for WebGLBuffer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLBufferBinding::WebGLBuffer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglbuffer::WebGLBuffer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglbuffer::WebGLBuffer>>}

impl DomObjectWrap for WebGLContextEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLContextEventBinding::WebGLContextEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglcontextevent::WebGLContextEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglcontextevent::WebGLContextEvent>>}

impl DomObjectWrap for WebGLFramebuffer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLFramebufferBinding::WebGLFramebuffer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglframebuffer::WebGLFramebuffer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglframebuffer::WebGLFramebuffer>>}

impl DomObjectWrap for WebGLProgram

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLProgramBinding::WebGLProgram_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglprogram::WebGLProgram>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglprogram::WebGLProgram>>}

impl DomObjectWrap for WebGLQuery

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLQueryBinding::WebGLQuery_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglquery::WebGLQuery>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglquery::WebGLQuery>>}

impl DomObjectWrap for WebGLRenderbuffer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLRenderbufferBinding::WebGLRenderbuffer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglrenderbuffer::WebGLRenderbuffer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglrenderbuffer::WebGLRenderbuffer>>}

impl DomObjectWrap for WebGLRenderingContext

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglrenderingcontext::WebGLRenderingContext>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglrenderingcontext::WebGLRenderingContext>>}

impl DomObjectWrap for WebGLSampler

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLSamplerBinding::WebGLSampler_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglsampler::WebGLSampler>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglsampler::WebGLSampler>>}

impl DomObjectWrap for WebGLShader

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLShaderBinding::WebGLShader_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglshader::WebGLShader>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglshader::WebGLShader>>}

impl DomObjectWrap for WebGLShaderPrecisionFormat

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLShaderPrecisionFormatBinding::WebGLShaderPrecisionFormat_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglshaderprecisionformat::WebGLShaderPrecisionFormat>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglshaderprecisionformat::WebGLShaderPrecisionFormat>>}

impl DomObjectWrap for WebGLSync

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLSyncBinding::WebGLSync_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglsync::WebGLSync>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglsync::WebGLSync>>}

impl DomObjectWrap for WebGLTexture

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLTextureBinding::WebGLTexture_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgltexture::WebGLTexture>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgltexture::WebGLTexture>>}

impl DomObjectWrap for WebGLTransformFeedback

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLTransformFeedbackBinding::WebGLTransformFeedback_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgltransformfeedback::WebGLTransformFeedback>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgltransformfeedback::WebGLTransformFeedback>>}

impl DomObjectWrap for WebGLUniformLocation

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLUniformLocationBinding::WebGLUniformLocation_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webgluniformlocation::WebGLUniformLocation>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgluniformlocation::WebGLUniformLocation>>}

impl DomObjectWrap for WebGLVertexArrayObject

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLVertexArrayObjectBinding::WebGLVertexArrayObject_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglvertexarrayobject::WebGLVertexArrayObject>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglvertexarrayobject::WebGLVertexArrayObject>>}

impl DomObjectWrap for WebGLVertexArrayObjectOES

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebGLVertexArrayObjectOESBinding::WebGLVertexArrayObjectOES_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::webglvertexarrayobjectoes::WebGLVertexArrayObjectOES>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglvertexarrayobjectoes::WebGLVertexArrayObjectOES>>}

impl DomObjectWrap for WebSocket

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WebSocketBinding::WebSocket_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::websocket::WebSocket>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::websocket::WebSocket>>}

impl DomObjectWrap for WheelEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WheelEventBinding::WheelEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::wheelevent::WheelEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::wheelevent::WheelEvent>>}

impl DomObjectWrap for Worker

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WorkerBinding::Worker_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::worker::Worker>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::worker::Worker>>}

impl DomObjectWrap for WorkerLocation

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WorkerLocationBinding::WorkerLocation_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::workerlocation::WorkerLocation>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::workerlocation::WorkerLocation>>}

impl DomObjectWrap for WorkerNavigator

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WorkerNavigatorBinding::WorkerNavigator_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::workernavigator::WorkerNavigator>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::workernavigator::WorkerNavigator>>}

impl DomObjectWrap for Worklet

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WorkletBinding::Worklet_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::worklet::Worklet>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::worklet::Worklet>>}

impl DomObjectWrap for WorkletGlobalScope

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::WorkletGlobalScopeBinding::WorkletGlobalScope_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::workletglobalscope::WorkletGlobalScope>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::workletglobalscope::WorkletGlobalScope>>}

impl DomObjectWrap for XMLDocument

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XMLDocumentBinding::XMLDocument_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xmldocument::XMLDocument>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xmldocument::XMLDocument>>}

impl DomObjectWrap for XMLHttpRequest

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequest_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xmlhttprequest::XMLHttpRequest>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xmlhttprequest::XMLHttpRequest>>}

impl DomObjectWrap for XMLHttpRequestUpload

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XMLHttpRequestUploadBinding::XMLHttpRequestUpload_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xmlhttprequestupload::XMLHttpRequestUpload>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xmlhttprequestupload::XMLHttpRequestUpload>>}

impl DomObjectWrap for XMLSerializer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XMLSerializerBinding::XMLSerializer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xmlserializer::XMLSerializer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xmlserializer::XMLSerializer>>}

impl DomObjectWrap for XRCompositionLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRCompositionLayerBinding::XRCompositionLayer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrcompositionlayer::XRCompositionLayer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrcompositionlayer::XRCompositionLayer>>}

impl DomObjectWrap for XRCubeLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRCubeLayerBinding::XRCubeLayer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrcubelayer::XRCubeLayer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrcubelayer::XRCubeLayer>>}

impl DomObjectWrap for XRCylinderLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRCylinderLayerBinding::XRCylinderLayer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrcylinderlayer::XRCylinderLayer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrcylinderlayer::XRCylinderLayer>>}

impl DomObjectWrap for XREquirectLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XREquirectLayerBinding::XREquirectLayer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrequirectlayer::XREquirectLayer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrequirectlayer::XREquirectLayer>>}

impl DomObjectWrap for XRFrame

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRFrameBinding::XRFrame_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrframe::XRFrame>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrframe::XRFrame>>}

impl DomObjectWrap for XRHand

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRHandBinding::XRHand_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrhand::XRHand>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrhand::XRHand>>}

impl DomObjectWrap for XRHitTestResult

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRHitTestResultBinding::XRHitTestResult_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrhittestresult::XRHitTestResult>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrhittestresult::XRHitTestResult>>}

impl DomObjectWrap for XRHitTestSource

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRHitTestSourceBinding::XRHitTestSource_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrhittestsource::XRHitTestSource>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrhittestsource::XRHitTestSource>>}

impl DomObjectWrap for XRInputSource

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRInputSourceBinding::XRInputSource_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrinputsource::XRInputSource>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrinputsource::XRInputSource>>}

impl DomObjectWrap for XRInputSourceArray

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRInputSourceArrayBinding::XRInputSourceArray_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrinputsourcearray::XRInputSourceArray>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrinputsourcearray::XRInputSourceArray>>}

impl DomObjectWrap for XRInputSourceEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRInputSourceEventBinding::XRInputSourceEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrinputsourceevent::XRInputSourceEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrinputsourceevent::XRInputSourceEvent>>}

impl DomObjectWrap for XRInputSourcesChangeEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRInputSourcesChangeEventBinding::XRInputSourcesChangeEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrinputsourceschangeevent::XRInputSourcesChangeEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrinputsourceschangeevent::XRInputSourcesChangeEvent>>}

impl DomObjectWrap for XRJointPose

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRJointPoseBinding::XRJointPose_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrjointpose::XRJointPose>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrjointpose::XRJointPose>>}

impl DomObjectWrap for XRJointSpace

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRJointSpaceBinding::XRJointSpace_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrjointspace::XRJointSpace>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrjointspace::XRJointSpace>>}

impl DomObjectWrap for XRLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRLayerBinding::XRLayer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrlayer::XRLayer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrlayer::XRLayer>>}

impl DomObjectWrap for XRLayerEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRLayerEventBinding::XRLayerEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrlayerevent::XRLayerEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrlayerevent::XRLayerEvent>>}

impl DomObjectWrap for XRMediaBinding

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRMediaBindingBinding::XRMediaBinding_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrmediabinding::XRMediaBinding>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrmediabinding::XRMediaBinding>>}

impl DomObjectWrap for XRPose

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRPoseBinding::XRPose_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrpose::XRPose>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrpose::XRPose>>}

impl DomObjectWrap for XRProjectionLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRProjectionLayerBinding::XRProjectionLayer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrprojectionlayer::XRProjectionLayer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrprojectionlayer::XRProjectionLayer>>}

impl DomObjectWrap for XRQuadLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRQuadLayerBinding::XRQuadLayer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrquadlayer::XRQuadLayer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrquadlayer::XRQuadLayer>>}

impl DomObjectWrap for XRRay

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRRayBinding::XRRay_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrray::XRRay>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrray::XRRay>>}

impl DomObjectWrap for XRReferenceSpace

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRReferenceSpaceBinding::XRReferenceSpace_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrreferencespace::XRReferenceSpace>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrreferencespace::XRReferenceSpace>>}

impl DomObjectWrap for XRRenderState

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRRenderStateBinding::XRRenderState_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrrenderstate::XRRenderState>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrrenderstate::XRRenderState>>}

impl DomObjectWrap for XRRigidTransform

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRRigidTransformBinding::XRRigidTransform_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrrigidtransform::XRRigidTransform>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrrigidtransform::XRRigidTransform>>}

impl DomObjectWrap for XRSession

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRSessionBinding::XRSession_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrsession::XRSession>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrsession::XRSession>>}

impl DomObjectWrap for XRSessionEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRSessionEventBinding::XRSessionEvent_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrsessionevent::XRSessionEvent>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrsessionevent::XRSessionEvent>>}

impl DomObjectWrap for XRSpace

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRSpaceBinding::XRSpace_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrspace::XRSpace>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrspace::XRSpace>>}

impl DomObjectWrap for XRSubImage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRSubImageBinding::XRSubImage_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrsubimage::XRSubImage>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrsubimage::XRSubImage>>}

impl DomObjectWrap for XRSystem

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRSystemBinding::XRSystem_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrsystem::XRSystem>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrsystem::XRSystem>>}

impl DomObjectWrap for XRTest

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRTestBinding::XRTest_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrtest::XRTest>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrtest::XRTest>>}

impl DomObjectWrap for XRView

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRViewBinding::XRView_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrview::XRView>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrview::XRView>>}

impl DomObjectWrap for XRViewerPose

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRViewerPoseBinding::XRViewerPose_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrviewerpose::XRViewerPose>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrviewerpose::XRViewerPose>>}

impl DomObjectWrap for XRViewport

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRViewportBinding::XRViewport_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrviewport::XRViewport>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrviewport::XRViewport>>}

impl DomObjectWrap for XRWebGLBinding

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRWebGLBindingBinding::XRWebGLBinding_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrwebglbinding::XRWebGLBinding>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrwebglbinding::XRWebGLBinding>>}

impl DomObjectWrap for XRWebGLLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRWebGLLayerBinding::XRWebGLLayer_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrwebgllayer::XRWebGLLayer>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrwebgllayer::XRWebGLLayer>>}

impl DomObjectWrap for XRWebGLSubImage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::XRWebGLSubImageBinding::XRWebGLSubImage_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::xrwebglsubimage::XRWebGLSubImage>) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xrwebglsubimage::XRWebGLSubImage>>}

impl<T: DomObjectIteratorWrap + JSTraceable + Iterable> DomObjectWrap for IterableIterator<T>

const WRAP: unsafe fn(_: JSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>) -> Root<Dom<Self>> = T::ITER_WRAP