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

pub trait DomObjectWrap: Sized + DomObject {
    const WRAP: unsafe fn(_: JSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, _: CanGc) -> Root<Dom<Self>>

Function pointer to the general wrap function type

Object Safety

This trait is not object safe.

Implementors

impl DomObjectWrap for AbortController

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

impl DomObjectWrap for AbstractRange

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::broadcastchannel::BroadcastChannel>>}

impl DomObjectWrap for ByteLengthQueuingStrategy

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

impl DomObjectWrap for CanvasGradient

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::constantsourcenode::ConstantSourceNode>>}

impl DomObjectWrap for CountQueuingStrategy

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

impl DomObjectWrap for Crypto

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::crypto::Crypto>>}

impl DomObjectWrap for CryptoKey

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

impl DomObjectWrap for CSSFontFaceRule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::customevent::CustomEvent>>}

impl DomObjectWrap for DataTransfer

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

impl DomObjectWrap for DataTransferItem

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

impl DomObjectWrap for DataTransferItemList

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

impl DomObjectWrap for DefaultTeeReadRequest

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

impl DomObjectWrap for DefaultTeeUnderlyingSource

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

impl DomObjectWrap for DissimilarOriginLocation

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::domrect::DOMRect>>}

impl DomObjectWrap for DOMRectList

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

impl DomObjectWrap for DOMRectReadOnly

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::extendablemessageevent::ExtendableMessageEvent>>}

impl DomObjectWrap for File

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::focusevent::FocusEvent>>}

impl DomObjectWrap for FontFaceSet

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

impl DomObjectWrap for FormData

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gamepadevent::GamepadEvent>>}

impl DomObjectWrap for GamepadHapticActuator

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

impl DomObjectWrap for GamepadPose

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::gamepadpose::GamepadPose>>}

impl DomObjectWrap for HashChangeEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::htmlvideoelement::HTMLVideoElement>>}

impl DomObjectWrap for IIRFilterNode

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

impl DomObjectWrap for ImageBitmap

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::inputevent::InputEvent>>}

impl DomObjectWrap for IntersectionObserver

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

impl DomObjectWrap for IntersectionObserverEntry

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

impl DomObjectWrap for KeyboardEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::pluginarray::PluginArray>>}

impl DomObjectWrap for PointerEvent

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

impl DomObjectWrap for PopStateEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::range::Range>>}

impl DomObjectWrap for ReadableByteStreamController

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

impl DomObjectWrap for ReadableStream

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::readablestream::ReadableStream>>}

impl DomObjectWrap for ReadableStreamBYOBReader

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

impl DomObjectWrap for ReadableStreamBYOBRequest

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

impl DomObjectWrap for ReadableStreamDefaultController

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

impl DomObjectWrap for ReadableStreamDefaultReader

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

impl DomObjectWrap for Request

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::request::Request>>}

impl DomObjectWrap for ResizeObserver

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

impl DomObjectWrap for ResizeObserverEntry

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

impl DomObjectWrap for ResizeObserverSize

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

impl DomObjectWrap for Response

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::screen::Screen>>}

impl DomObjectWrap for SecurityPolicyViolationEvent

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

impl DomObjectWrap for Selection

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::submitevent::SubmitEvent>>}

impl DomObjectWrap for SubtleCrypto

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

impl DomObjectWrap for SVGElement

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::uievent::UIEvent>>}

impl DomObjectWrap for UnderlyingSourceContainer

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

impl DomObjectWrap for URL

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::videotracklist::VideoTrackList>>}

impl DomObjectWrap for VisibilityStateEntry

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

impl DomObjectWrap for VTTCue

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webglvertexarrayobjectoes::WebGLVertexArrayObjectOES>>}

impl DomObjectWrap for GPU

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpu::GPU>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpu::GPU>>}

impl DomObjectWrap for GPUAdapter

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpuadapter::GPUAdapter>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpuadapter::GPUAdapter>>}

impl DomObjectWrap for GPUAdapterInfo

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpuadapterinfo::GPUAdapterInfo>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpuadapterinfo::GPUAdapterInfo>>}

impl DomObjectWrap for GPUBindGroup

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpubindgroup::GPUBindGroup>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpubindgroup::GPUBindGroup>>}

impl DomObjectWrap for GPUBindGroupLayout

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpubindgrouplayout::GPUBindGroupLayout>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpubindgrouplayout::GPUBindGroupLayout>>}

impl DomObjectWrap for GPUBuffer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpubuffer::GPUBuffer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpubuffer::GPUBuffer>>}

impl DomObjectWrap for GPUCanvasContext

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::GPUCanvasContextBinding::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::webgpu::gpucanvascontext::GPUCanvasContext>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpucanvascontext::GPUCanvasContext>>}

impl DomObjectWrap for GPUColorWrite

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpucolorwrite::GPUColorWrite>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpucolorwrite::GPUColorWrite>>}

impl DomObjectWrap for GPUCommandBuffer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpucommandbuffer::GPUCommandBuffer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpucommandbuffer::GPUCommandBuffer>>}

impl DomObjectWrap for GPUCommandEncoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpucommandencoder::GPUCommandEncoder>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpucommandencoder::GPUCommandEncoder>>}

impl DomObjectWrap for GPUCompilationInfo

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpucompilationinfo::GPUCompilationInfo>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpucompilationinfo::GPUCompilationInfo>>}

impl DomObjectWrap for GPUCompilationMessage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpucompilationmessage::GPUCompilationMessage>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpucompilationmessage::GPUCompilationMessage>>}

impl DomObjectWrap for GPUComputePassEncoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpucomputepassencoder::GPUComputePassEncoder>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpucomputepassencoder::GPUComputePassEncoder>>}

impl DomObjectWrap for GPUComputePipeline

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpucomputepipeline::GPUComputePipeline>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpucomputepipeline::GPUComputePipeline>>}

impl DomObjectWrap for GPUDevice

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpudevice::GPUDevice>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpudevice::GPUDevice>>}

impl DomObjectWrap for GPUDeviceLostInfo

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpudevicelostinfo::GPUDeviceLostInfo>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpudevicelostinfo::GPUDeviceLostInfo>>}

impl DomObjectWrap for GPUError

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

impl DomObjectWrap for GPUInternalError

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

impl DomObjectWrap for GPUOutOfMemoryError

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpuoutofmemoryerror::GPUOutOfMemoryError>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpuoutofmemoryerror::GPUOutOfMemoryError>>}

impl DomObjectWrap for GPUPipelineError

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

impl DomObjectWrap for GPUPipelineLayout

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpupipelinelayout::GPUPipelineLayout>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpupipelinelayout::GPUPipelineLayout>>}

impl DomObjectWrap for GPUQuerySet

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpuqueryset::GPUQuerySet>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpuqueryset::GPUQuerySet>>}

impl DomObjectWrap for GPUQueue

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpuqueue::GPUQueue>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpuqueue::GPUQueue>>}

impl DomObjectWrap for GPURenderBundle

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpurenderbundle::GPURenderBundle>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpurenderbundle::GPURenderBundle>>}

impl DomObjectWrap for GPURenderBundleEncoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpurenderbundleencoder::GPURenderBundleEncoder>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpurenderbundleencoder::GPURenderBundleEncoder>>}

impl DomObjectWrap for GPURenderPassEncoder

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpurenderpassencoder::GPURenderPassEncoder>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpurenderpassencoder::GPURenderPassEncoder>>}

impl DomObjectWrap for GPURenderPipeline

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpurenderpipeline::GPURenderPipeline>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpurenderpipeline::GPURenderPipeline>>}

impl DomObjectWrap for GPUSampler

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpusampler::GPUSampler>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpusampler::GPUSampler>>}

impl DomObjectWrap for GPUShaderModule

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpushadermodule::GPUShaderModule>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpushadermodule::GPUShaderModule>>}

impl DomObjectWrap for GPUShaderStage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpushaderstage::GPUShaderStage>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpushaderstage::GPUShaderStage>>}

impl DomObjectWrap for GPUSupportedFeatures

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpusupportedfeatures::GPUSupportedFeatures>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpusupportedfeatures::GPUSupportedFeatures>>}

impl DomObjectWrap for GPUSupportedLimits

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpusupportedlimits::GPUSupportedLimits>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpusupportedlimits::GPUSupportedLimits>>}

impl DomObjectWrap for GPUTexture

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gputexture::GPUTexture>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gputexture::GPUTexture>>}

impl DomObjectWrap for GPUTextureUsage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gputextureusage::GPUTextureUsage>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gputextureusage::GPUTextureUsage>>}

impl DomObjectWrap for GPUTextureView

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gputextureview::GPUTextureView>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gputextureview::GPUTextureView>>}

impl DomObjectWrap for GPUUncapturedErrorEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpuuncapturederrorevent::GPUUncapturedErrorEvent>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpuuncapturederrorevent::GPUUncapturedErrorEvent>>}

impl DomObjectWrap for GPUValidationError

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webgpu::gpuvalidationerror::GPUValidationError>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webgpu::gpuvalidationerror::GPUValidationError>>}

impl DomObjectWrap for WebSocket

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::websocket::WebSocket>>}

impl DomObjectWrap for FakeXRDevice

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::fakexrdevice::FakeXRDevice>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::fakexrdevice::FakeXRDevice>>}

impl DomObjectWrap for FakeXRInputController

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::fakexrinputcontroller::FakeXRInputController>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::fakexrinputcontroller::FakeXRInputController>>}

impl DomObjectWrap for XRBoundedReferenceSpace

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

impl DomObjectWrap for XRCompositionLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrcompositionlayer::XRCompositionLayer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrcompositionlayer::XRCompositionLayer>>}

impl DomObjectWrap for XRCubeLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrcubelayer::XRCubeLayer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrcubelayer::XRCubeLayer>>}

impl DomObjectWrap for XRCylinderLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrcylinderlayer::XRCylinderLayer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrcylinderlayer::XRCylinderLayer>>}

impl DomObjectWrap for XREquirectLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrequirectlayer::XREquirectLayer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrequirectlayer::XREquirectLayer>>}

impl DomObjectWrap for XRFrame

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrframe::XRFrame>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrframe::XRFrame>>}

impl DomObjectWrap for XRHand

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrhand::XRHand>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrhand::XRHand>>}

impl DomObjectWrap for XRHitTestResult

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrhittestresult::XRHitTestResult>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrhittestresult::XRHitTestResult>>}

impl DomObjectWrap for XRHitTestSource

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrhittestsource::XRHitTestSource>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrhittestsource::XRHitTestSource>>}

impl DomObjectWrap for XRInputSource

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrinputsource::XRInputSource>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrinputsource::XRInputSource>>}

impl DomObjectWrap for XRInputSourceArray

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrinputsourcearray::XRInputSourceArray>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrinputsourcearray::XRInputSourceArray>>}

impl DomObjectWrap for XRInputSourceEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrinputsourceevent::XRInputSourceEvent>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrinputsourceevent::XRInputSourceEvent>>}

impl DomObjectWrap for XRInputSourcesChangeEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrinputsourceschangeevent::XRInputSourcesChangeEvent>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrinputsourceschangeevent::XRInputSourcesChangeEvent>>}

impl DomObjectWrap for XRJointPose

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrjointpose::XRJointPose>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrjointpose::XRJointPose>>}

impl DomObjectWrap for XRJointSpace

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrjointspace::XRJointSpace>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrjointspace::XRJointSpace>>}

impl DomObjectWrap for XRLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrlayer::XRLayer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrlayer::XRLayer>>}

impl DomObjectWrap for XRLayerEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrlayerevent::XRLayerEvent>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrlayerevent::XRLayerEvent>>}

impl DomObjectWrap for XRMediaBinding

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrmediabinding::XRMediaBinding>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrmediabinding::XRMediaBinding>>}

impl DomObjectWrap for XRPose

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrpose::XRPose>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrpose::XRPose>>}

impl DomObjectWrap for XRProjectionLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrprojectionlayer::XRProjectionLayer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrprojectionlayer::XRProjectionLayer>>}

impl DomObjectWrap for XRQuadLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrquadlayer::XRQuadLayer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrquadlayer::XRQuadLayer>>}

impl DomObjectWrap for XRRay

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrray::XRRay>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrray::XRRay>>}

impl DomObjectWrap for XRReferenceSpace

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrreferencespace::XRReferenceSpace>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrreferencespace::XRReferenceSpace>>}

impl DomObjectWrap for XRReferenceSpaceEvent

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

impl DomObjectWrap for XRRenderState

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrrenderstate::XRRenderState>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrrenderstate::XRRenderState>>}

impl DomObjectWrap for XRRigidTransform

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrrigidtransform::XRRigidTransform>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrrigidtransform::XRRigidTransform>>}

impl DomObjectWrap for XRSession

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrsession::XRSession>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrsession::XRSession>>}

impl DomObjectWrap for XRSessionEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrsessionevent::XRSessionEvent>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrsessionevent::XRSessionEvent>>}

impl DomObjectWrap for XRSpace

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrspace::XRSpace>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrspace::XRSpace>>}

impl DomObjectWrap for XRSubImage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrsubimage::XRSubImage>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrsubimage::XRSubImage>>}

impl DomObjectWrap for XRSystem

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrsystem::XRSystem>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrsystem::XRSystem>>}

impl DomObjectWrap for XRTest

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrtest::XRTest>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrtest::XRTest>>}

impl DomObjectWrap for XRView

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrview::XRView>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrview::XRView>>}

impl DomObjectWrap for XRViewerPose

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrviewerpose::XRViewerPose>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrviewerpose::XRViewerPose>>}

impl DomObjectWrap for XRViewport

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrviewport::XRViewport>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrviewport::XRViewport>>}

impl DomObjectWrap for XRWebGLBinding

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrwebglbinding::XRWebGLBinding>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrwebglbinding::XRWebGLBinding>>}

impl DomObjectWrap for XRWebGLLayer

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrwebgllayer::XRWebGLLayer>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrwebgllayer::XRWebGLLayer>>}

impl DomObjectWrap for XRWebGLSubImage

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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::webxr::xrwebglsubimage::XRWebGLSubImage>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::webxr::xrwebglsubimage::XRWebGLSubImage>>}

impl DomObjectWrap for WheelEvent

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> 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>, _: CanGc) -> 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>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::xmlserializer::XMLSerializer>>}

impl DomObjectWrap for XPathEvaluator

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

impl DomObjectWrap for XPathExpression

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

impl DomObjectWrap for XPathResult

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

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

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