1#![allow(non_camel_case_types,non_upper_case_globals,unsafe_op_in_unsafe_fn,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::enum_variant_names,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]
4
5use crate::codegen::GenericBindings::AbstractRangeBinding::AbstractRange_Binding;
6use crate::codegen::GenericBindings::CharacterDataBinding::CharacterData_Binding;
7use crate::codegen::GenericBindings::DocumentFragmentBinding::DocumentFragment_Binding;
8use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
9use crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull;
10use crate::codegen::GenericBindings::EventHandlerBinding::OnErrorEventHandlerNonNull;
11use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
12use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
13use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
14use crate::codegen::GenericBindings::TextBinding::Text_Binding;
15use crate::import::base::*;
16
17
18#[repr(usize)]
19#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
20pub enum DocumentReadyState {
21 Loading,
22 Interactive,
23 Complete
24}
25pub mod DocumentReadyStateValues {
26
27 use crate::utils::find_enum_value;
28 use js::conversions::ConversionResult;
29 use js::conversions::FromJSValConvertible;
30 use js::conversions::ToJSValConvertible;
31 use js::context::RawJSContext;
32 use js::rust::HandleValue;
33 use js::rust::MutableHandleValue;
34 use js::jsval::JSVal;
35
36 pub(crate) const pairs: &[(&str, super::DocumentReadyState)] = &[
37 ("loading", super::DocumentReadyState::Loading),
38 ("interactive", super::DocumentReadyState::Interactive),
39 ("complete", super::DocumentReadyState::Complete),
40 ];
41
42 impl super::DocumentReadyState {
43 pub fn as_str(&self) -> &'static str {
44 pairs[*self as usize].0
45 }
46 }
47
48 impl Default for super::DocumentReadyState {
49 fn default() -> super::DocumentReadyState {
50 pairs[0].1
51 }
52 }
53
54 impl std::str::FromStr for super::DocumentReadyState {
55 type Err = ();
56
57 fn from_str(s: &str) -> Result<Self, Self::Err> {
58 pairs
59 .iter()
60 .find(|&&(key, _)| s == key)
61 .map(|&(_, ev)| ev)
62 .ok_or(())
63 }
64 }
65
66 impl ToJSValConvertible for super::DocumentReadyState {
67 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
68 pairs[*self as usize].0.to_jsval(cx, rval);
69 }
70 }
71
72 impl FromJSValConvertible for super::DocumentReadyState {
73 type Config = ();
74 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
75 -> Result<ConversionResult<super::DocumentReadyState>, ()> {
76 match find_enum_value(cx, value, pairs) {
77 Err(_) => Err(()),
78 Ok((None, search)) => {
79 Ok(ConversionResult::Failure(
80 format!("'{}' is not a valid enum value for enumeration 'DocumentReadyState'.", search).into()
81 ))
82 }
83 Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
84 }
85 }
86 }
87 } #[repr(usize)]
91#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
92pub enum DocumentVisibilityState {
93 Visible,
94 Hidden
95}
96pub mod DocumentVisibilityStateValues {
97
98 use crate::utils::find_enum_value;
99 use js::conversions::ConversionResult;
100 use js::conversions::FromJSValConvertible;
101 use js::conversions::ToJSValConvertible;
102 use js::context::RawJSContext;
103 use js::rust::HandleValue;
104 use js::rust::MutableHandleValue;
105 use js::jsval::JSVal;
106
107 pub(crate) const pairs: &[(&str, super::DocumentVisibilityState)] = &[
108 ("visible", super::DocumentVisibilityState::Visible),
109 ("hidden", super::DocumentVisibilityState::Hidden),
110 ];
111
112 impl super::DocumentVisibilityState {
113 pub fn as_str(&self) -> &'static str {
114 pairs[*self as usize].0
115 }
116 }
117
118 impl Default for super::DocumentVisibilityState {
119 fn default() -> super::DocumentVisibilityState {
120 pairs[0].1
121 }
122 }
123
124 impl std::str::FromStr for super::DocumentVisibilityState {
125 type Err = ();
126
127 fn from_str(s: &str) -> Result<Self, Self::Err> {
128 pairs
129 .iter()
130 .find(|&&(key, _)| s == key)
131 .map(|&(_, ev)| ev)
132 .ok_or(())
133 }
134 }
135
136 impl ToJSValConvertible for super::DocumentVisibilityState {
137 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
138 pairs[*self as usize].0.to_jsval(cx, rval);
139 }
140 }
141
142 impl FromJSValConvertible for super::DocumentVisibilityState {
143 type Config = ();
144 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
145 -> Result<ConversionResult<super::DocumentVisibilityState>, ()> {
146 match find_enum_value(cx, value, pairs) {
147 Err(_) => Err(()),
148 Ok((None, search)) => {
149 Ok(ConversionResult::Failure(
150 format!("'{}' is not a valid enum value for enumeration 'DocumentVisibilityState'.", search).into()
151 ))
152 }
153 Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
154 }
155 }
156 }
157 } pub use self::GenericUnionTypes::WindowProxyOrElementOrHTMLCollection as NamedPropertyValue;
160
161#[derive(JSTraceable)]
162pub struct ElementCreationOptions {
163 pub is: Option<DOMString>,
164}
165impl Default for ElementCreationOptions {
166 fn default() -> Self {
167 Self::empty()
168 }
169}
170
171impl ElementCreationOptions {
172 pub fn empty() -> Self {
173 Self {
174 is: None,
175 }
176 }
177 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
178 -> Result<ConversionResult<ElementCreationOptions>, ()> {
179 unsafe {
180 let object = if val.get().is_null_or_undefined() {
181 ptr::null_mut()
182 } else if val.get().is_object() {
183 val.get().to_object()
184 } else {
185 return Ok(ConversionResult::Failure("Value is not an object.".into()));
186 };
187 rooted!(&in(cx) let object = object);
188 let dictionary = ElementCreationOptions {
189 is: {
190 rooted!(&in(cx) let mut rval = UndefinedValue());
191 if get_dictionary_property(cx.raw_cx(), object.handle(), "is", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
192 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
193 Ok(ConversionResult::Success(value)) => value,
194 Ok(ConversionResult::Failure(error)) => {
195 throw_type_error(cx.raw_cx(), &error);
196 return Err(());
197
198 }
199 _ => {
200 return Err(());
201
202 },
203 }
204 )
205 } else {
206 None
207 }
208 },
209 };
210 Ok(ConversionResult::Success(dictionary))
211 }
212 }
213}
214
215impl FromJSValConvertible for ElementCreationOptions {
216 type Config = ();
217 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
218 -> Result<ConversionResult<ElementCreationOptions>, ()> {
219 ElementCreationOptions::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
220 }
221}
222
223impl ElementCreationOptions {
224 #[allow(clippy::wrong_self_convention)]
225 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
226 if let Some(ref is) = self.is {
227 rooted!(in(cx) let mut is_js = UndefinedValue());
228 is.to_jsval(cx, is_js.handle_mut());
229 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "is", is_js.handle()).unwrap();
230 }
231 }
232}
233
234impl ToJSValConvertible for ElementCreationOptions {
235 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
236 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
237 self.to_jsobject(cx, obj.handle_mut());
238 rval.set(ObjectOrNullValue(obj.get()))
239 }
240}
241
242
243pub use self::Document_Binding::{Wrap, DocumentMethods, GetProtoObject, GetConstructorObject, DefineDOMInterface};
244pub mod Document_Binding {
245use crate::codegen::GenericBindings::AbstractRangeBinding::AbstractRange_Binding;
246use crate::codegen::GenericBindings::CharacterDataBinding::CharacterData_Binding;
247use crate::codegen::GenericBindings::DocumentBinding::DocumentReadyState;
248use crate::codegen::GenericBindings::DocumentBinding::DocumentReadyStateValues;
249use crate::codegen::GenericBindings::DocumentBinding::DocumentVisibilityState;
250use crate::codegen::GenericBindings::DocumentBinding::DocumentVisibilityStateValues;
251use crate::codegen::GenericBindings::DocumentBinding::ElementCreationOptions;
252use crate::codegen::GenericBindings::DocumentFragmentBinding::DocumentFragment_Binding;
253use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
254use crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull;
255use crate::codegen::GenericBindings::EventHandlerBinding::OnErrorEventHandlerNonNull;
256use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
257use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
258use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
259use crate::codegen::GenericBindings::TextBinding::Text_Binding;
260use crate::import::module::*;
261
262unsafe extern "C" fn get_implementation<D: DomTypes>
263(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
264 let mut result = false;
265 wrap_panic(&mut || result = (|| {
266 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
267 let this = &*(this as *const D::Document);
268 let result: DomRoot<D::DOMImplementation> = this.Implementation(CanGc::note());
269
270 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
271 return true;
272 })());
273 result
274}
275
276
277static implementation_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
278
279pub(crate) fn init_implementation_getterinfo<D: DomTypes>() {
280 implementation_getterinfo.set(JSJitInfo {
281 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
282 getter: Some(get_implementation::<D>)
283 },
284 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
285 protoID: PrototypeList::ID::Document as u16,
286 },
287 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
288 _bitfield_align_1: [],
289 _bitfield_1: __BindgenBitfieldUnit::new(
290 new_jsjitinfo_bitfield_1!(
291 JSJitInfo_OpType::Getter as u8,
292 JSJitInfo_AliasSet::AliasNone as u8,
293 JSValueType::JSVAL_TYPE_OBJECT as u8,
294 true,
295 true,
296 false,
297 false,
298 false,
299 false,
300 0,
301 ).to_ne_bytes()
302 ),
303});
304}
305unsafe extern "C" fn get_URL<D: DomTypes>
306(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
307 let mut result = false;
308 wrap_panic(&mut || result = (|| {
309 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
310 let this = &*(this as *const D::Document);
311 let result: USVString = this.URL();
312
313 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
314 return true;
315 })());
316 result
317}
318
319
320static URL_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
321
322pub(crate) fn init_URL_getterinfo<D: DomTypes>() {
323 URL_getterinfo.set(JSJitInfo {
324 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
325 getter: Some(get_URL::<D>)
326 },
327 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
328 protoID: PrototypeList::ID::Document as u16,
329 },
330 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
331 _bitfield_align_1: [],
332 _bitfield_1: __BindgenBitfieldUnit::new(
333 new_jsjitinfo_bitfield_1!(
334 JSJitInfo_OpType::Getter as u8,
335 JSJitInfo_AliasSet::AliasNone as u8,
336 JSValueType::JSVAL_TYPE_STRING as u8,
337 true,
338 true,
339 false,
340 false,
341 false,
342 false,
343 0,
344 ).to_ne_bytes()
345 ),
346});
347}
348unsafe extern "C" fn get_documentURI<D: DomTypes>
349(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
350 let mut result = false;
351 wrap_panic(&mut || result = (|| {
352 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
353 let this = &*(this as *const D::Document);
354 let result: USVString = this.DocumentURI();
355
356 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
357 return true;
358 })());
359 result
360}
361
362
363static documentURI_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
364
365pub(crate) fn init_documentURI_getterinfo<D: DomTypes>() {
366 documentURI_getterinfo.set(JSJitInfo {
367 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
368 getter: Some(get_documentURI::<D>)
369 },
370 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
371 protoID: PrototypeList::ID::Document as u16,
372 },
373 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
374 _bitfield_align_1: [],
375 _bitfield_1: __BindgenBitfieldUnit::new(
376 new_jsjitinfo_bitfield_1!(
377 JSJitInfo_OpType::Getter as u8,
378 JSJitInfo_AliasSet::AliasNone as u8,
379 JSValueType::JSVAL_TYPE_STRING as u8,
380 true,
381 true,
382 false,
383 false,
384 false,
385 false,
386 0,
387 ).to_ne_bytes()
388 ),
389});
390}
391unsafe extern "C" fn get_compatMode<D: DomTypes>
392(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
393 let mut result = false;
394 wrap_panic(&mut || result = (|| {
395 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
396 let this = &*(this as *const D::Document);
397 let result: DOMString = this.CompatMode();
398
399 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
400 return true;
401 })());
402 result
403}
404
405
406static compatMode_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
407
408pub(crate) fn init_compatMode_getterinfo<D: DomTypes>() {
409 compatMode_getterinfo.set(JSJitInfo {
410 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
411 getter: Some(get_compatMode::<D>)
412 },
413 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
414 protoID: PrototypeList::ID::Document as u16,
415 },
416 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
417 _bitfield_align_1: [],
418 _bitfield_1: __BindgenBitfieldUnit::new(
419 new_jsjitinfo_bitfield_1!(
420 JSJitInfo_OpType::Getter as u8,
421 JSJitInfo_AliasSet::AliasEverything as u8,
422 JSValueType::JSVAL_TYPE_STRING as u8,
423 true,
424 false,
425 false,
426 false,
427 false,
428 false,
429 0,
430 ).to_ne_bytes()
431 ),
432});
433}
434unsafe extern "C" fn get_characterSet<D: DomTypes>
435(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
436 let mut result = false;
437 wrap_panic(&mut || result = (|| {
438 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
439 let this = &*(this as *const D::Document);
440 let result: DOMString = this.CharacterSet();
441
442 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
443 return true;
444 })());
445 result
446}
447
448
449static characterSet_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
450
451pub(crate) fn init_characterSet_getterinfo<D: DomTypes>() {
452 characterSet_getterinfo.set(JSJitInfo {
453 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
454 getter: Some(get_characterSet::<D>)
455 },
456 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
457 protoID: PrototypeList::ID::Document as u16,
458 },
459 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
460 _bitfield_align_1: [],
461 _bitfield_1: __BindgenBitfieldUnit::new(
462 new_jsjitinfo_bitfield_1!(
463 JSJitInfo_OpType::Getter as u8,
464 JSJitInfo_AliasSet::AliasEverything as u8,
465 JSValueType::JSVAL_TYPE_STRING as u8,
466 true,
467 false,
468 false,
469 false,
470 false,
471 false,
472 0,
473 ).to_ne_bytes()
474 ),
475});
476}
477unsafe extern "C" fn get_charset<D: DomTypes>
478(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
479 let mut result = false;
480 wrap_panic(&mut || result = (|| {
481 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
482 let this = &*(this as *const D::Document);
483 let result: DOMString = this.Charset();
484
485 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
486 return true;
487 })());
488 result
489}
490
491
492static charset_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
493
494pub(crate) fn init_charset_getterinfo<D: DomTypes>() {
495 charset_getterinfo.set(JSJitInfo {
496 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
497 getter: Some(get_charset::<D>)
498 },
499 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
500 protoID: PrototypeList::ID::Document as u16,
501 },
502 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
503 _bitfield_align_1: [],
504 _bitfield_1: __BindgenBitfieldUnit::new(
505 new_jsjitinfo_bitfield_1!(
506 JSJitInfo_OpType::Getter as u8,
507 JSJitInfo_AliasSet::AliasEverything as u8,
508 JSValueType::JSVAL_TYPE_STRING as u8,
509 true,
510 false,
511 false,
512 false,
513 false,
514 false,
515 0,
516 ).to_ne_bytes()
517 ),
518});
519}
520unsafe extern "C" fn get_inputEncoding<D: DomTypes>
521(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
522 let mut result = false;
523 wrap_panic(&mut || result = (|| {
524 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
525 let this = &*(this as *const D::Document);
526 let result: DOMString = this.InputEncoding();
527
528 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
529 return true;
530 })());
531 result
532}
533
534
535static inputEncoding_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
536
537pub(crate) fn init_inputEncoding_getterinfo<D: DomTypes>() {
538 inputEncoding_getterinfo.set(JSJitInfo {
539 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
540 getter: Some(get_inputEncoding::<D>)
541 },
542 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
543 protoID: PrototypeList::ID::Document as u16,
544 },
545 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
546 _bitfield_align_1: [],
547 _bitfield_1: __BindgenBitfieldUnit::new(
548 new_jsjitinfo_bitfield_1!(
549 JSJitInfo_OpType::Getter as u8,
550 JSJitInfo_AliasSet::AliasEverything as u8,
551 JSValueType::JSVAL_TYPE_STRING as u8,
552 true,
553 false,
554 false,
555 false,
556 false,
557 false,
558 0,
559 ).to_ne_bytes()
560 ),
561});
562}
563unsafe extern "C" fn get_contentType<D: DomTypes>
564(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
565 let mut result = false;
566 wrap_panic(&mut || result = (|| {
567 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
568 let this = &*(this as *const D::Document);
569 let result: DOMString = this.ContentType();
570
571 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
572 return true;
573 })());
574 result
575}
576
577
578static contentType_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
579
580pub(crate) fn init_contentType_getterinfo<D: DomTypes>() {
581 contentType_getterinfo.set(JSJitInfo {
582 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
583 getter: Some(get_contentType::<D>)
584 },
585 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
586 protoID: PrototypeList::ID::Document as u16,
587 },
588 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
589 _bitfield_align_1: [],
590 _bitfield_1: __BindgenBitfieldUnit::new(
591 new_jsjitinfo_bitfield_1!(
592 JSJitInfo_OpType::Getter as u8,
593 JSJitInfo_AliasSet::AliasNone as u8,
594 JSValueType::JSVAL_TYPE_STRING as u8,
595 true,
596 true,
597 false,
598 false,
599 false,
600 false,
601 0,
602 ).to_ne_bytes()
603 ),
604});
605}
606unsafe extern "C" fn get_doctype<D: DomTypes>
607(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
608 let mut result = false;
609 wrap_panic(&mut || result = (|| {
610 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
611 let this = &*(this as *const D::Document);
612 let result: Option<DomRoot<D::DocumentType>> = this.GetDoctype();
613
614 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
615 return true;
616 })());
617 result
618}
619
620
621static doctype_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
622
623pub(crate) fn init_doctype_getterinfo<D: DomTypes>() {
624 doctype_getterinfo.set(JSJitInfo {
625 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
626 getter: Some(get_doctype::<D>)
627 },
628 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
629 protoID: PrototypeList::ID::Document as u16,
630 },
631 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
632 _bitfield_align_1: [],
633 _bitfield_1: __BindgenBitfieldUnit::new(
634 new_jsjitinfo_bitfield_1!(
635 JSJitInfo_OpType::Getter as u8,
636 JSJitInfo_AliasSet::AliasDOMSets as u8,
637 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
638 true,
639 true,
640 false,
641 false,
642 false,
643 false,
644 0,
645 ).to_ne_bytes()
646 ),
647});
648}
649unsafe extern "C" fn get_documentElement<D: DomTypes>
650(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
651 let mut result = false;
652 wrap_panic(&mut || result = (|| {
653 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
654 let this = &*(this as *const D::Document);
655 let result: Option<DomRoot<D::Element>> = this.GetDocumentElement();
656
657 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
658 return true;
659 })());
660 result
661}
662
663
664static documentElement_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
665
666pub(crate) fn init_documentElement_getterinfo<D: DomTypes>() {
667 documentElement_getterinfo.set(JSJitInfo {
668 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
669 getter: Some(get_documentElement::<D>)
670 },
671 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
672 protoID: PrototypeList::ID::Document as u16,
673 },
674 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
675 _bitfield_align_1: [],
676 _bitfield_1: __BindgenBitfieldUnit::new(
677 new_jsjitinfo_bitfield_1!(
678 JSJitInfo_OpType::Getter as u8,
679 JSJitInfo_AliasSet::AliasDOMSets as u8,
680 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
681 true,
682 true,
683 false,
684 false,
685 false,
686 false,
687 0,
688 ).to_ne_bytes()
689 ),
690});
691}
692unsafe extern "C" fn getElementsByTagName<D: DomTypes>
693(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
694 let mut result = false;
695 wrap_panic(&mut || result = (|| {
696 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
697 let this = &*(this as *const D::Document);
698 let args = &*args;
699 let argc = args.argc_;
700
701 if argc < 1 {
702 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.getElementsByTagName\".");
703 return false;
704 }
705 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
706 Ok(ConversionResult::Success(value)) => value,
707 Ok(ConversionResult::Failure(error)) => {
708 throw_type_error(cx.raw_cx(), &error);
709 return false;
710
711 }
712 _ => {
713 return false;
714
715 },
716 }
717 ;
718 let result: DomRoot<D::HTMLCollection> = this.GetElementsByTagName(arg0, CanGc::note());
719
720 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
721 return true;
722 })());
723 result
724}
725
726
727static getElementsByTagName_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
728
729pub(crate) fn init_getElementsByTagName_methodinfo<D: DomTypes>() {
730 getElementsByTagName_methodinfo.set(JSJitInfo {
731 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
732 method: Some(getElementsByTagName::<D>)
733 },
734 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
735 protoID: PrototypeList::ID::Document as u16,
736 },
737 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
738 _bitfield_align_1: [],
739 _bitfield_1: __BindgenBitfieldUnit::new(
740 new_jsjitinfo_bitfield_1!(
741 JSJitInfo_OpType::Method as u8,
742 JSJitInfo_AliasSet::AliasEverything as u8,
743 JSValueType::JSVAL_TYPE_OBJECT as u8,
744 false,
745 false,
746 false,
747 false,
748 false,
749 false,
750 0,
751 ).to_ne_bytes()
752 ),
753});
754}
755unsafe extern "C" fn getElementsByTagNameNS<D: DomTypes>
756(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
757 let mut result = false;
758 wrap_panic(&mut || result = (|| {
759 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
760 let this = &*(this as *const D::Document);
761 let args = &*args;
762 let argc = args.argc_;
763
764 if argc < 2 {
765 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.getElementsByTagNameNS\".");
766 return false;
767 }
768 let arg0: Option<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
769 Ok(ConversionResult::Success(value)) => value,
770 Ok(ConversionResult::Failure(error)) => {
771 throw_type_error(cx.raw_cx(), &error);
772 return false;
773
774 }
775 _ => {
776 return false;
777
778 },
779 }
780 ;
781 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
782 Ok(ConversionResult::Success(value)) => value,
783 Ok(ConversionResult::Failure(error)) => {
784 throw_type_error(cx.raw_cx(), &error);
785 return false;
786
787 }
788 _ => {
789 return false;
790
791 },
792 }
793 ;
794 let result: DomRoot<D::HTMLCollection> = this.GetElementsByTagNameNS(arg0, arg1, CanGc::note());
795
796 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
797 return true;
798 })());
799 result
800}
801
802
803static getElementsByTagNameNS_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
804
805pub(crate) fn init_getElementsByTagNameNS_methodinfo<D: DomTypes>() {
806 getElementsByTagNameNS_methodinfo.set(JSJitInfo {
807 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
808 method: Some(getElementsByTagNameNS::<D>)
809 },
810 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
811 protoID: PrototypeList::ID::Document as u16,
812 },
813 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
814 _bitfield_align_1: [],
815 _bitfield_1: __BindgenBitfieldUnit::new(
816 new_jsjitinfo_bitfield_1!(
817 JSJitInfo_OpType::Method as u8,
818 JSJitInfo_AliasSet::AliasEverything as u8,
819 JSValueType::JSVAL_TYPE_OBJECT as u8,
820 false,
821 false,
822 false,
823 false,
824 false,
825 false,
826 0,
827 ).to_ne_bytes()
828 ),
829});
830}
831unsafe extern "C" fn getElementsByClassName<D: DomTypes>
832(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
833 let mut result = false;
834 wrap_panic(&mut || result = (|| {
835 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
836 let this = &*(this as *const D::Document);
837 let args = &*args;
838 let argc = args.argc_;
839
840 if argc < 1 {
841 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.getElementsByClassName\".");
842 return false;
843 }
844 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
845 Ok(ConversionResult::Success(value)) => value,
846 Ok(ConversionResult::Failure(error)) => {
847 throw_type_error(cx.raw_cx(), &error);
848 return false;
849
850 }
851 _ => {
852 return false;
853
854 },
855 }
856 ;
857 let result: DomRoot<D::HTMLCollection> = this.GetElementsByClassName(arg0, CanGc::note());
858
859 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
860 return true;
861 })());
862 result
863}
864
865
866static getElementsByClassName_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
867
868pub(crate) fn init_getElementsByClassName_methodinfo<D: DomTypes>() {
869 getElementsByClassName_methodinfo.set(JSJitInfo {
870 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
871 method: Some(getElementsByClassName::<D>)
872 },
873 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
874 protoID: PrototypeList::ID::Document as u16,
875 },
876 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
877 _bitfield_align_1: [],
878 _bitfield_1: __BindgenBitfieldUnit::new(
879 new_jsjitinfo_bitfield_1!(
880 JSJitInfo_OpType::Method as u8,
881 JSJitInfo_AliasSet::AliasEverything as u8,
882 JSValueType::JSVAL_TYPE_OBJECT as u8,
883 false,
884 false,
885 false,
886 false,
887 false,
888 false,
889 0,
890 ).to_ne_bytes()
891 ),
892});
893}
894unsafe extern "C" fn createElement<D: DomTypes>
895(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
896 let mut result = false;
897 wrap_panic(&mut || result = (|| {
898 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
899 let this = &*(this as *const D::Document);
900 let args = &*args;
901 let argc = args.argc_;
902
903 if argc < 1 {
904 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createElement\".");
905 return false;
906 }
907 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
908 Ok(ConversionResult::Success(value)) => value,
909 Ok(ConversionResult::Failure(error)) => {
910 throw_type_error(cx.raw_cx(), &error);
911 return false;
912
913 }
914 _ => {
915 return false;
916
917 },
918 }
919 ;
920 let arg1: GenericUnionTypes::StringOrElementCreationOptions = if args.get(1).is_undefined() {
921 GenericUnionTypes::StringOrElementCreationOptions::ElementCreationOptions(crate::codegen::GenericBindings::DocumentBinding::ElementCreationOptions::empty())
922 } else {
923 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
924 Ok(ConversionResult::Success(value)) => value,
925 Ok(ConversionResult::Failure(error)) => {
926 throw_type_error(cx.raw_cx(), &error);
927 return false;
928
929 }
930 _ => {
931 return false;
932
933 },
934 }
935
936 };
937 <D as DomHelpers<D>>::push_new_element_queue();
938
939 let result: Result<DomRoot<D::Element>, Error> = this.CreateElement(arg0, arg1, CanGc::note());
940 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
941
942 let result = match result {
943 Ok(result) => result,
944 Err(e) => {
945 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
946 return false;
947 },
948 };
949
950 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
951 return true;
952 })());
953 result
954}
955
956
957static createElement_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
958
959pub(crate) fn init_createElement_methodinfo<D: DomTypes>() {
960 createElement_methodinfo.set(JSJitInfo {
961 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
962 method: Some(createElement::<D>)
963 },
964 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
965 protoID: PrototypeList::ID::Document as u16,
966 },
967 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
968 _bitfield_align_1: [],
969 _bitfield_1: __BindgenBitfieldUnit::new(
970 new_jsjitinfo_bitfield_1!(
971 JSJitInfo_OpType::Method as u8,
972 JSJitInfo_AliasSet::AliasEverything as u8,
973 JSValueType::JSVAL_TYPE_OBJECT as u8,
974 false,
975 false,
976 false,
977 false,
978 false,
979 false,
980 0,
981 ).to_ne_bytes()
982 ),
983});
984}
985unsafe extern "C" fn createElementNS<D: DomTypes>
986(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
987 let mut result = false;
988 wrap_panic(&mut || result = (|| {
989 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
990 let this = &*(this as *const D::Document);
991 let args = &*args;
992 let argc = args.argc_;
993
994 if argc < 2 {
995 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createElementNS\".");
996 return false;
997 }
998 let arg0: Option<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
999 Ok(ConversionResult::Success(value)) => value,
1000 Ok(ConversionResult::Failure(error)) => {
1001 throw_type_error(cx.raw_cx(), &error);
1002 return false;
1003
1004 }
1005 _ => {
1006 return false;
1007
1008 },
1009 }
1010 ;
1011 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
1012 Ok(ConversionResult::Success(value)) => value,
1013 Ok(ConversionResult::Failure(error)) => {
1014 throw_type_error(cx.raw_cx(), &error);
1015 return false;
1016
1017 }
1018 _ => {
1019 return false;
1020
1021 },
1022 }
1023 ;
1024 let arg2: GenericUnionTypes::StringOrElementCreationOptions = if args.get(2).is_undefined() {
1025 GenericUnionTypes::StringOrElementCreationOptions::ElementCreationOptions(crate::codegen::GenericBindings::DocumentBinding::ElementCreationOptions::empty())
1026 } else {
1027 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
1028 Ok(ConversionResult::Success(value)) => value,
1029 Ok(ConversionResult::Failure(error)) => {
1030 throw_type_error(cx.raw_cx(), &error);
1031 return false;
1032
1033 }
1034 _ => {
1035 return false;
1036
1037 },
1038 }
1039
1040 };
1041 <D as DomHelpers<D>>::push_new_element_queue();
1042
1043 let result: Result<DomRoot<D::Element>, Error> = this.CreateElementNS(arg0, arg1, arg2, CanGc::note());
1044 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1045
1046 let result = match result {
1047 Ok(result) => result,
1048 Err(e) => {
1049 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1050 return false;
1051 },
1052 };
1053
1054 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1055 return true;
1056 })());
1057 result
1058}
1059
1060
1061static createElementNS_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1062
1063pub(crate) fn init_createElementNS_methodinfo<D: DomTypes>() {
1064 createElementNS_methodinfo.set(JSJitInfo {
1065 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1066 method: Some(createElementNS::<D>)
1067 },
1068 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1069 protoID: PrototypeList::ID::Document as u16,
1070 },
1071 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1072 _bitfield_align_1: [],
1073 _bitfield_1: __BindgenBitfieldUnit::new(
1074 new_jsjitinfo_bitfield_1!(
1075 JSJitInfo_OpType::Method as u8,
1076 JSJitInfo_AliasSet::AliasEverything as u8,
1077 JSValueType::JSVAL_TYPE_OBJECT as u8,
1078 false,
1079 false,
1080 false,
1081 false,
1082 false,
1083 false,
1084 0,
1085 ).to_ne_bytes()
1086 ),
1087});
1088}
1089unsafe extern "C" fn createDocumentFragment<D: DomTypes>
1090(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1091 let mut result = false;
1092 wrap_panic(&mut || result = (|| {
1093 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1094 let this = &*(this as *const D::Document);
1095 let args = &*args;
1096 let argc = args.argc_;
1097 let result: DomRoot<D::DocumentFragment> = this.CreateDocumentFragment(CanGc::note());
1098
1099 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1100 return true;
1101 })());
1102 result
1103}
1104
1105
1106static createDocumentFragment_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1107
1108pub(crate) fn init_createDocumentFragment_methodinfo<D: DomTypes>() {
1109 createDocumentFragment_methodinfo.set(JSJitInfo {
1110 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1111 method: Some(createDocumentFragment::<D>)
1112 },
1113 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1114 protoID: PrototypeList::ID::Document as u16,
1115 },
1116 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1117 _bitfield_align_1: [],
1118 _bitfield_1: __BindgenBitfieldUnit::new(
1119 new_jsjitinfo_bitfield_1!(
1120 JSJitInfo_OpType::Method as u8,
1121 JSJitInfo_AliasSet::AliasEverything as u8,
1122 JSValueType::JSVAL_TYPE_OBJECT as u8,
1123 true,
1124 false,
1125 false,
1126 false,
1127 false,
1128 false,
1129 0,
1130 ).to_ne_bytes()
1131 ),
1132});
1133}
1134unsafe extern "C" fn createTextNode<D: DomTypes>
1135(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1136 let mut result = false;
1137 wrap_panic(&mut || result = (|| {
1138 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1139 let this = &*(this as *const D::Document);
1140 let args = &*args;
1141 let argc = args.argc_;
1142
1143 if argc < 1 {
1144 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createTextNode\".");
1145 return false;
1146 }
1147 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1148 Ok(ConversionResult::Success(value)) => value,
1149 Ok(ConversionResult::Failure(error)) => {
1150 throw_type_error(cx.raw_cx(), &error);
1151 return false;
1152
1153 }
1154 _ => {
1155 return false;
1156
1157 },
1158 }
1159 ;
1160 let result: DomRoot<D::Text> = this.CreateTextNode(arg0, CanGc::note());
1161
1162 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1163 return true;
1164 })());
1165 result
1166}
1167
1168
1169static createTextNode_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1170
1171pub(crate) fn init_createTextNode_methodinfo<D: DomTypes>() {
1172 createTextNode_methodinfo.set(JSJitInfo {
1173 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1174 method: Some(createTextNode::<D>)
1175 },
1176 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1177 protoID: PrototypeList::ID::Document as u16,
1178 },
1179 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1180 _bitfield_align_1: [],
1181 _bitfield_1: __BindgenBitfieldUnit::new(
1182 new_jsjitinfo_bitfield_1!(
1183 JSJitInfo_OpType::Method as u8,
1184 JSJitInfo_AliasSet::AliasEverything as u8,
1185 JSValueType::JSVAL_TYPE_OBJECT as u8,
1186 false,
1187 false,
1188 false,
1189 false,
1190 false,
1191 false,
1192 0,
1193 ).to_ne_bytes()
1194 ),
1195});
1196}
1197unsafe extern "C" fn createCDATASection<D: DomTypes>
1198(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1199 let mut result = false;
1200 wrap_panic(&mut || result = (|| {
1201 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1202 let this = &*(this as *const D::Document);
1203 let args = &*args;
1204 let argc = args.argc_;
1205
1206 if argc < 1 {
1207 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createCDATASection\".");
1208 return false;
1209 }
1210 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1211 Ok(ConversionResult::Success(value)) => value,
1212 Ok(ConversionResult::Failure(error)) => {
1213 throw_type_error(cx.raw_cx(), &error);
1214 return false;
1215
1216 }
1217 _ => {
1218 return false;
1219
1220 },
1221 }
1222 ;
1223 let result: Result<DomRoot<D::CDATASection>, Error> = this.CreateCDATASection(arg0, CanGc::note());
1224 let result = match result {
1225 Ok(result) => result,
1226 Err(e) => {
1227 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1228 return false;
1229 },
1230 };
1231
1232 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1233 return true;
1234 })());
1235 result
1236}
1237
1238
1239static createCDATASection_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1240
1241pub(crate) fn init_createCDATASection_methodinfo<D: DomTypes>() {
1242 createCDATASection_methodinfo.set(JSJitInfo {
1243 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1244 method: Some(createCDATASection::<D>)
1245 },
1246 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1247 protoID: PrototypeList::ID::Document as u16,
1248 },
1249 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1250 _bitfield_align_1: [],
1251 _bitfield_1: __BindgenBitfieldUnit::new(
1252 new_jsjitinfo_bitfield_1!(
1253 JSJitInfo_OpType::Method as u8,
1254 JSJitInfo_AliasSet::AliasEverything as u8,
1255 JSValueType::JSVAL_TYPE_OBJECT as u8,
1256 false,
1257 false,
1258 false,
1259 false,
1260 false,
1261 false,
1262 0,
1263 ).to_ne_bytes()
1264 ),
1265});
1266}
1267unsafe extern "C" fn createComment<D: DomTypes>
1268(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1269 let mut result = false;
1270 wrap_panic(&mut || result = (|| {
1271 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1272 let this = &*(this as *const D::Document);
1273 let args = &*args;
1274 let argc = args.argc_;
1275
1276 if argc < 1 {
1277 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createComment\".");
1278 return false;
1279 }
1280 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1281 Ok(ConversionResult::Success(value)) => value,
1282 Ok(ConversionResult::Failure(error)) => {
1283 throw_type_error(cx.raw_cx(), &error);
1284 return false;
1285
1286 }
1287 _ => {
1288 return false;
1289
1290 },
1291 }
1292 ;
1293 let result: DomRoot<D::Comment> = this.CreateComment(arg0, CanGc::note());
1294
1295 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1296 return true;
1297 })());
1298 result
1299}
1300
1301
1302static createComment_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1303
1304pub(crate) fn init_createComment_methodinfo<D: DomTypes>() {
1305 createComment_methodinfo.set(JSJitInfo {
1306 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1307 method: Some(createComment::<D>)
1308 },
1309 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1310 protoID: PrototypeList::ID::Document as u16,
1311 },
1312 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1313 _bitfield_align_1: [],
1314 _bitfield_1: __BindgenBitfieldUnit::new(
1315 new_jsjitinfo_bitfield_1!(
1316 JSJitInfo_OpType::Method as u8,
1317 JSJitInfo_AliasSet::AliasEverything as u8,
1318 JSValueType::JSVAL_TYPE_OBJECT as u8,
1319 false,
1320 false,
1321 false,
1322 false,
1323 false,
1324 false,
1325 0,
1326 ).to_ne_bytes()
1327 ),
1328});
1329}
1330unsafe extern "C" fn createProcessingInstruction<D: DomTypes>
1331(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1332 let mut result = false;
1333 wrap_panic(&mut || result = (|| {
1334 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1335 let this = &*(this as *const D::Document);
1336 let args = &*args;
1337 let argc = args.argc_;
1338
1339 if argc < 2 {
1340 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createProcessingInstruction\".");
1341 return false;
1342 }
1343 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1344 Ok(ConversionResult::Success(value)) => value,
1345 Ok(ConversionResult::Failure(error)) => {
1346 throw_type_error(cx.raw_cx(), &error);
1347 return false;
1348
1349 }
1350 _ => {
1351 return false;
1352
1353 },
1354 }
1355 ;
1356 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
1357 Ok(ConversionResult::Success(value)) => value,
1358 Ok(ConversionResult::Failure(error)) => {
1359 throw_type_error(cx.raw_cx(), &error);
1360 return false;
1361
1362 }
1363 _ => {
1364 return false;
1365
1366 },
1367 }
1368 ;
1369 let result: Result<DomRoot<D::ProcessingInstruction>, Error> = this.CreateProcessingInstruction(arg0, arg1, CanGc::note());
1370 let result = match result {
1371 Ok(result) => result,
1372 Err(e) => {
1373 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1374 return false;
1375 },
1376 };
1377
1378 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1379 return true;
1380 })());
1381 result
1382}
1383
1384
1385static createProcessingInstruction_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1386
1387pub(crate) fn init_createProcessingInstruction_methodinfo<D: DomTypes>() {
1388 createProcessingInstruction_methodinfo.set(JSJitInfo {
1389 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1390 method: Some(createProcessingInstruction::<D>)
1391 },
1392 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1393 protoID: PrototypeList::ID::Document as u16,
1394 },
1395 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1396 _bitfield_align_1: [],
1397 _bitfield_1: __BindgenBitfieldUnit::new(
1398 new_jsjitinfo_bitfield_1!(
1399 JSJitInfo_OpType::Method as u8,
1400 JSJitInfo_AliasSet::AliasEverything as u8,
1401 JSValueType::JSVAL_TYPE_OBJECT as u8,
1402 false,
1403 false,
1404 false,
1405 false,
1406 false,
1407 false,
1408 0,
1409 ).to_ne_bytes()
1410 ),
1411});
1412}
1413unsafe extern "C" fn importNode<D: DomTypes>
1414(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1415 let mut result = false;
1416 wrap_panic(&mut || result = (|| {
1417 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1418 let this = &*(this as *const D::Document);
1419 let args = &*args;
1420 let argc = args.argc_;
1421
1422 if argc < 1 {
1423 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.importNode\".");
1424 return false;
1425 }
1426 let arg0: DomRoot<D::Node> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1427 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1428 Ok(val) => val,
1429 Err(()) => {
1430 throw_type_error(cx.raw_cx(), "value does not implement interface Node.");
1431 return false;
1432
1433 }
1434 }
1435
1436 } else {
1437 throw_type_error(cx.raw_cx(), "Value is not an object.");
1438 return false;
1439
1440 };
1441 let arg1: bool = if args.get(1).is_undefined() {
1442 false
1443 } else {
1444 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1445 Ok(ConversionResult::Success(value)) => value,
1446 Ok(ConversionResult::Failure(error)) => {
1447 throw_type_error(cx.raw_cx(), &error);
1448 return false;
1449
1450 }
1451 _ => {
1452 return false;
1453
1454 },
1455 }
1456
1457 };
1458 <D as DomHelpers<D>>::push_new_element_queue();
1459
1460 let result: Result<DomRoot<D::Node>, Error> = this.ImportNode(&arg0, arg1, CanGc::note());
1461 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1462
1463 let result = match result {
1464 Ok(result) => result,
1465 Err(e) => {
1466 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1467 return false;
1468 },
1469 };
1470
1471 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1472 return true;
1473 })());
1474 result
1475}
1476
1477
1478static importNode_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1479
1480pub(crate) fn init_importNode_methodinfo<D: DomTypes>() {
1481 importNode_methodinfo.set(JSJitInfo {
1482 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1483 method: Some(importNode::<D>)
1484 },
1485 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1486 protoID: PrototypeList::ID::Document as u16,
1487 },
1488 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1489 _bitfield_align_1: [],
1490 _bitfield_1: __BindgenBitfieldUnit::new(
1491 new_jsjitinfo_bitfield_1!(
1492 JSJitInfo_OpType::Method as u8,
1493 JSJitInfo_AliasSet::AliasEverything as u8,
1494 JSValueType::JSVAL_TYPE_OBJECT as u8,
1495 false,
1496 false,
1497 false,
1498 false,
1499 false,
1500 false,
1501 0,
1502 ).to_ne_bytes()
1503 ),
1504});
1505}
1506unsafe extern "C" fn adoptNode<D: DomTypes>
1507(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1508 let mut result = false;
1509 wrap_panic(&mut || result = (|| {
1510 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1511 let this = &*(this as *const D::Document);
1512 let args = &*args;
1513 let argc = args.argc_;
1514
1515 if argc < 1 {
1516 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.adoptNode\".");
1517 return false;
1518 }
1519 let arg0: DomRoot<D::Node> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1520 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1521 Ok(val) => val,
1522 Err(()) => {
1523 throw_type_error(cx.raw_cx(), "value does not implement interface Node.");
1524 return false;
1525
1526 }
1527 }
1528
1529 } else {
1530 throw_type_error(cx.raw_cx(), "Value is not an object.");
1531 return false;
1532
1533 };
1534 <D as DomHelpers<D>>::push_new_element_queue();
1535
1536 let result: Result<DomRoot<D::Node>, Error> = this.AdoptNode(&arg0, CanGc::note());
1537 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1538
1539 let result = match result {
1540 Ok(result) => result,
1541 Err(e) => {
1542 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1543 return false;
1544 },
1545 };
1546
1547 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1548 return true;
1549 })());
1550 result
1551}
1552
1553
1554static adoptNode_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1555
1556pub(crate) fn init_adoptNode_methodinfo<D: DomTypes>() {
1557 adoptNode_methodinfo.set(JSJitInfo {
1558 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1559 method: Some(adoptNode::<D>)
1560 },
1561 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1562 protoID: PrototypeList::ID::Document as u16,
1563 },
1564 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1565 _bitfield_align_1: [],
1566 _bitfield_1: __BindgenBitfieldUnit::new(
1567 new_jsjitinfo_bitfield_1!(
1568 JSJitInfo_OpType::Method as u8,
1569 JSJitInfo_AliasSet::AliasEverything as u8,
1570 JSValueType::JSVAL_TYPE_OBJECT as u8,
1571 false,
1572 false,
1573 false,
1574 false,
1575 false,
1576 false,
1577 0,
1578 ).to_ne_bytes()
1579 ),
1580});
1581}
1582unsafe extern "C" fn createAttribute<D: DomTypes>
1583(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1584 let mut result = false;
1585 wrap_panic(&mut || result = (|| {
1586 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1587 let this = &*(this as *const D::Document);
1588 let args = &*args;
1589 let argc = args.argc_;
1590
1591 if argc < 1 {
1592 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createAttribute\".");
1593 return false;
1594 }
1595 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1596 Ok(ConversionResult::Success(value)) => value,
1597 Ok(ConversionResult::Failure(error)) => {
1598 throw_type_error(cx.raw_cx(), &error);
1599 return false;
1600
1601 }
1602 _ => {
1603 return false;
1604
1605 },
1606 }
1607 ;
1608 let result: Result<DomRoot<D::Attr>, Error> = this.CreateAttribute(arg0, CanGc::note());
1609 let result = match result {
1610 Ok(result) => result,
1611 Err(e) => {
1612 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1613 return false;
1614 },
1615 };
1616
1617 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1618 return true;
1619 })());
1620 result
1621}
1622
1623
1624static createAttribute_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1625
1626pub(crate) fn init_createAttribute_methodinfo<D: DomTypes>() {
1627 createAttribute_methodinfo.set(JSJitInfo {
1628 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1629 method: Some(createAttribute::<D>)
1630 },
1631 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1632 protoID: PrototypeList::ID::Document as u16,
1633 },
1634 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1635 _bitfield_align_1: [],
1636 _bitfield_1: __BindgenBitfieldUnit::new(
1637 new_jsjitinfo_bitfield_1!(
1638 JSJitInfo_OpType::Method as u8,
1639 JSJitInfo_AliasSet::AliasEverything as u8,
1640 JSValueType::JSVAL_TYPE_OBJECT as u8,
1641 false,
1642 false,
1643 false,
1644 false,
1645 false,
1646 false,
1647 0,
1648 ).to_ne_bytes()
1649 ),
1650});
1651}
1652unsafe extern "C" fn createAttributeNS<D: DomTypes>
1653(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1654 let mut result = false;
1655 wrap_panic(&mut || result = (|| {
1656 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1657 let this = &*(this as *const D::Document);
1658 let args = &*args;
1659 let argc = args.argc_;
1660
1661 if argc < 2 {
1662 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createAttributeNS\".");
1663 return false;
1664 }
1665 let arg0: Option<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1666 Ok(ConversionResult::Success(value)) => value,
1667 Ok(ConversionResult::Failure(error)) => {
1668 throw_type_error(cx.raw_cx(), &error);
1669 return false;
1670
1671 }
1672 _ => {
1673 return false;
1674
1675 },
1676 }
1677 ;
1678 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
1679 Ok(ConversionResult::Success(value)) => value,
1680 Ok(ConversionResult::Failure(error)) => {
1681 throw_type_error(cx.raw_cx(), &error);
1682 return false;
1683
1684 }
1685 _ => {
1686 return false;
1687
1688 },
1689 }
1690 ;
1691 let result: Result<DomRoot<D::Attr>, Error> = this.CreateAttributeNS(arg0, arg1, CanGc::note());
1692 let result = match result {
1693 Ok(result) => result,
1694 Err(e) => {
1695 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1696 return false;
1697 },
1698 };
1699
1700 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1701 return true;
1702 })());
1703 result
1704}
1705
1706
1707static createAttributeNS_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1708
1709pub(crate) fn init_createAttributeNS_methodinfo<D: DomTypes>() {
1710 createAttributeNS_methodinfo.set(JSJitInfo {
1711 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1712 method: Some(createAttributeNS::<D>)
1713 },
1714 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1715 protoID: PrototypeList::ID::Document as u16,
1716 },
1717 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1718 _bitfield_align_1: [],
1719 _bitfield_1: __BindgenBitfieldUnit::new(
1720 new_jsjitinfo_bitfield_1!(
1721 JSJitInfo_OpType::Method as u8,
1722 JSJitInfo_AliasSet::AliasEverything as u8,
1723 JSValueType::JSVAL_TYPE_OBJECT as u8,
1724 false,
1725 false,
1726 false,
1727 false,
1728 false,
1729 false,
1730 0,
1731 ).to_ne_bytes()
1732 ),
1733});
1734}
1735unsafe extern "C" fn createEvent<D: DomTypes>
1736(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1737 let mut result = false;
1738 wrap_panic(&mut || result = (|| {
1739 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1740 let this = &*(this as *const D::Document);
1741 let args = &*args;
1742 let argc = args.argc_;
1743
1744 if argc < 1 {
1745 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createEvent\".");
1746 return false;
1747 }
1748 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1749 Ok(ConversionResult::Success(value)) => value,
1750 Ok(ConversionResult::Failure(error)) => {
1751 throw_type_error(cx.raw_cx(), &error);
1752 return false;
1753
1754 }
1755 _ => {
1756 return false;
1757
1758 },
1759 }
1760 ;
1761 let result: Result<DomRoot<D::Event>, Error> = this.CreateEvent(arg0, CanGc::note());
1762 let result = match result {
1763 Ok(result) => result,
1764 Err(e) => {
1765 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1766 return false;
1767 },
1768 };
1769
1770 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1771 return true;
1772 })());
1773 result
1774}
1775
1776
1777static createEvent_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1778
1779pub(crate) fn init_createEvent_methodinfo<D: DomTypes>() {
1780 createEvent_methodinfo.set(JSJitInfo {
1781 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1782 method: Some(createEvent::<D>)
1783 },
1784 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1785 protoID: PrototypeList::ID::Document as u16,
1786 },
1787 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1788 _bitfield_align_1: [],
1789 _bitfield_1: __BindgenBitfieldUnit::new(
1790 new_jsjitinfo_bitfield_1!(
1791 JSJitInfo_OpType::Method as u8,
1792 JSJitInfo_AliasSet::AliasEverything as u8,
1793 JSValueType::JSVAL_TYPE_OBJECT as u8,
1794 false,
1795 false,
1796 false,
1797 false,
1798 false,
1799 false,
1800 0,
1801 ).to_ne_bytes()
1802 ),
1803});
1804}
1805unsafe extern "C" fn createRange<D: DomTypes>
1806(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1807 let mut result = false;
1808 wrap_panic(&mut || result = (|| {
1809 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1810 let this = &*(this as *const D::Document);
1811 let args = &*args;
1812 let argc = args.argc_;
1813 let result: DomRoot<D::Range> = this.CreateRange(CanGc::note());
1814
1815 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1816 return true;
1817 })());
1818 result
1819}
1820
1821
1822static createRange_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1823
1824pub(crate) fn init_createRange_methodinfo<D: DomTypes>() {
1825 createRange_methodinfo.set(JSJitInfo {
1826 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1827 method: Some(createRange::<D>)
1828 },
1829 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1830 protoID: PrototypeList::ID::Document as u16,
1831 },
1832 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1833 _bitfield_align_1: [],
1834 _bitfield_1: __BindgenBitfieldUnit::new(
1835 new_jsjitinfo_bitfield_1!(
1836 JSJitInfo_OpType::Method as u8,
1837 JSJitInfo_AliasSet::AliasEverything as u8,
1838 JSValueType::JSVAL_TYPE_OBJECT as u8,
1839 true,
1840 false,
1841 false,
1842 false,
1843 false,
1844 false,
1845 0,
1846 ).to_ne_bytes()
1847 ),
1848});
1849}
1850unsafe extern "C" fn createNodeIterator<D: DomTypes>
1851(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1852 let mut result = false;
1853 wrap_panic(&mut || result = (|| {
1854 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1855 let this = &*(this as *const D::Document);
1856 let args = &*args;
1857 let argc = args.argc_;
1858
1859 if argc < 1 {
1860 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createNodeIterator\".");
1861 return false;
1862 }
1863 let arg0: DomRoot<D::Node> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1864 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1865 Ok(val) => val,
1866 Err(()) => {
1867 throw_type_error(cx.raw_cx(), "value does not implement interface Node.");
1868 return false;
1869
1870 }
1871 }
1872
1873 } else {
1874 throw_type_error(cx.raw_cx(), "Value is not an object.");
1875 return false;
1876
1877 };
1878 let arg1: u32 = if args.get(1).is_undefined() {
1879 4294967295
1880 } else {
1881 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1882 Ok(ConversionResult::Success(value)) => value,
1883 Ok(ConversionResult::Failure(error)) => {
1884 throw_type_error(cx.raw_cx(), &error);
1885 return false;
1886
1887 }
1888 _ => {
1889 return false;
1890
1891 },
1892 }
1893
1894 };
1895 let arg2: Option<Rc<crate::codegen::GenericBindings::NodeFilterBinding::NodeFilter<D>>> = if args.get(2).is_undefined() {
1896 None
1897 } else if HandleValue::from_raw(args.get(2)).get().is_object() {
1898 Some(crate::codegen::GenericBindings::NodeFilterBinding::NodeFilter::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(2)).get().to_object()))
1899 } else if HandleValue::from_raw(args.get(2)).get().is_null_or_undefined() {
1900 None
1901 } else {
1902 throw_type_error(cx.raw_cx(), "Value is not an object.");
1903 return false;
1904
1905 };
1906 let result: DomRoot<D::NodeIterator> = this.CreateNodeIterator(&arg0, arg1, arg2, CanGc::note());
1907
1908 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1909 return true;
1910 })());
1911 result
1912}
1913
1914
1915static createNodeIterator_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1916
1917pub(crate) fn init_createNodeIterator_methodinfo<D: DomTypes>() {
1918 createNodeIterator_methodinfo.set(JSJitInfo {
1919 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1920 method: Some(createNodeIterator::<D>)
1921 },
1922 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1923 protoID: PrototypeList::ID::Document as u16,
1924 },
1925 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
1926 _bitfield_align_1: [],
1927 _bitfield_1: __BindgenBitfieldUnit::new(
1928 new_jsjitinfo_bitfield_1!(
1929 JSJitInfo_OpType::Method as u8,
1930 JSJitInfo_AliasSet::AliasEverything as u8,
1931 JSValueType::JSVAL_TYPE_OBJECT as u8,
1932 false,
1933 false,
1934 false,
1935 false,
1936 false,
1937 false,
1938 0,
1939 ).to_ne_bytes()
1940 ),
1941});
1942}
1943unsafe extern "C" fn createTreeWalker<D: DomTypes>
1944(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1945 let mut result = false;
1946 wrap_panic(&mut || result = (|| {
1947 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1948 let this = &*(this as *const D::Document);
1949 let args = &*args;
1950 let argc = args.argc_;
1951
1952 if argc < 1 {
1953 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createTreeWalker\".");
1954 return false;
1955 }
1956 let arg0: DomRoot<D::Node> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1957 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1958 Ok(val) => val,
1959 Err(()) => {
1960 throw_type_error(cx.raw_cx(), "value does not implement interface Node.");
1961 return false;
1962
1963 }
1964 }
1965
1966 } else {
1967 throw_type_error(cx.raw_cx(), "Value is not an object.");
1968 return false;
1969
1970 };
1971 let arg1: u32 = if args.get(1).is_undefined() {
1972 4294967295
1973 } else {
1974 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1975 Ok(ConversionResult::Success(value)) => value,
1976 Ok(ConversionResult::Failure(error)) => {
1977 throw_type_error(cx.raw_cx(), &error);
1978 return false;
1979
1980 }
1981 _ => {
1982 return false;
1983
1984 },
1985 }
1986
1987 };
1988 let arg2: Option<Rc<crate::codegen::GenericBindings::NodeFilterBinding::NodeFilter<D>>> = if args.get(2).is_undefined() {
1989 None
1990 } else if HandleValue::from_raw(args.get(2)).get().is_object() {
1991 Some(crate::codegen::GenericBindings::NodeFilterBinding::NodeFilter::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(2)).get().to_object()))
1992 } else if HandleValue::from_raw(args.get(2)).get().is_null_or_undefined() {
1993 None
1994 } else {
1995 throw_type_error(cx.raw_cx(), "Value is not an object.");
1996 return false;
1997
1998 };
1999 let result: DomRoot<D::TreeWalker> = this.CreateTreeWalker(&arg0, arg1, arg2);
2000
2001 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2002 return true;
2003 })());
2004 result
2005}
2006
2007
2008static createTreeWalker_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2009
2010pub(crate) fn init_createTreeWalker_methodinfo<D: DomTypes>() {
2011 createTreeWalker_methodinfo.set(JSJitInfo {
2012 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2013 method: Some(createTreeWalker::<D>)
2014 },
2015 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2016 protoID: PrototypeList::ID::Document as u16,
2017 },
2018 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2019 _bitfield_align_1: [],
2020 _bitfield_1: __BindgenBitfieldUnit::new(
2021 new_jsjitinfo_bitfield_1!(
2022 JSJitInfo_OpType::Method as u8,
2023 JSJitInfo_AliasSet::AliasEverything as u8,
2024 JSValueType::JSVAL_TYPE_OBJECT as u8,
2025 false,
2026 false,
2027 false,
2028 false,
2029 false,
2030 false,
2031 0,
2032 ).to_ne_bytes()
2033 ),
2034});
2035}
2036unsafe extern "C" fn parseHTMLUnsafe<D: DomTypes>
2037(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
2038 let mut result = false;
2039 wrap_panic(&mut || result = (|| {
2040 let args = CallArgs::from_vp(vp, argc);
2041 let global = D::GlobalScope::from_object(args.callee());
2042 let global = DomRoot::downcast::<D::Window>(global).unwrap();
2043 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2044 let args = CallArgs::from_vp(vp, argc);
2045
2046 if argc < 1 {
2047 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.parseHTMLUnsafe\".");
2048 return false;
2049 }
2050 let arg0: GenericUnionTypes::TrustedHTMLOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
2051 Ok(ConversionResult::Success(value)) => value,
2052 Ok(ConversionResult::Failure(error)) => {
2053 throw_type_error(cx.raw_cx(), &error);
2054 return false;
2055
2056 }
2057 _ => {
2058 return false;
2059
2060 },
2061 }
2062 ;
2063 let result: Result<DomRoot<D::Document>, Error> = <D::Document>::ParseHTMLUnsafe(&global, arg0, CanGc::note());
2064 let result = match result {
2065 Ok(result) => result,
2066 Err(e) => {
2067 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
2068 return false;
2069 },
2070 };
2071
2072 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2073 return true;
2074 })());
2075 result
2076}
2077
2078unsafe extern "C" fn get_location<D: DomTypes>
2079(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2080 let mut result = false;
2081 wrap_panic(&mut || result = (|| {
2082 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2083 let this = &*(this as *const D::Document);
2084 let result: Option<DomRoot<D::Location>> = this.GetLocation();
2085
2086 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2087 return true;
2088 })());
2089 result
2090}
2091
2092unsafe extern "C" fn set_location<D: DomTypes>
2093(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2094 let mut result = false;
2095 wrap_panic(&mut || result = (|| {
2096
2097 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2098 rooted!(&in(cx) let mut v = UndefinedValue());
2099 if !JS_GetProperty(cx.raw_cx(), HandleObject::from_raw(obj), c"location".as_ptr(), v.handle_mut()) {
2100 return false;
2101 }
2102 if !v.is_object() {
2103 throw_type_error(cx.raw_cx(), "Value.location is not an object.");
2104 return false;
2105 }
2106 rooted!(&in(cx) let target_obj = v.to_object());
2107 JS_SetProperty(cx.raw_cx(), target_obj.handle(), c"href".as_ptr(), HandleValue::from_raw(args.get(0)))
2108
2109 })());
2110 result
2111}
2112
2113
2114static location_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2115
2116pub(crate) fn init_location_getterinfo<D: DomTypes>() {
2117 location_getterinfo.set(JSJitInfo {
2118 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2119 getter: Some(get_location::<D>)
2120 },
2121 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2122 protoID: PrototypeList::ID::Document as u16,
2123 },
2124 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2125 _bitfield_align_1: [],
2126 _bitfield_1: __BindgenBitfieldUnit::new(
2127 new_jsjitinfo_bitfield_1!(
2128 JSJitInfo_OpType::Getter as u8,
2129 JSJitInfo_AliasSet::AliasEverything as u8,
2130 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2131 true,
2132 false,
2133 false,
2134 false,
2135 false,
2136 false,
2137 0,
2138 ).to_ne_bytes()
2139 ),
2140});
2141}
2142static location_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2143
2144pub(crate) fn init_location_setterinfo<D: DomTypes>() {
2145 location_setterinfo.set(JSJitInfo {
2146 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2147 setter: Some(set_location::<D>)
2148 },
2149 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2150 protoID: PrototypeList::ID::Document as u16,
2151 },
2152 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2153 _bitfield_align_1: [],
2154 _bitfield_1: __BindgenBitfieldUnit::new(
2155 new_jsjitinfo_bitfield_1!(
2156 JSJitInfo_OpType::Setter as u8,
2157 JSJitInfo_AliasSet::AliasEverything as u8,
2158 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2159 false,
2160 false,
2161 false,
2162 false,
2163 false,
2164 false,
2165 0,
2166 ).to_ne_bytes()
2167 ),
2168});
2169}
2170unsafe extern "C" fn get_domain<D: DomTypes>
2171(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2172 let mut result = false;
2173 wrap_panic(&mut || result = (|| {
2174 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2175 let this = &*(this as *const D::Document);
2176 let result: DOMString = this.Domain();
2177
2178 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2179 return true;
2180 })());
2181 result
2182}
2183
2184unsafe extern "C" fn set_domain<D: DomTypes>
2185(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2186 let mut result = false;
2187 wrap_panic(&mut || result = (|| {
2188 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2189 let this = &*(this as *const D::Document);
2190 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2191 Ok(ConversionResult::Success(value)) => value,
2192 Ok(ConversionResult::Failure(error)) => {
2193 throw_type_error(cx.raw_cx(), &error);
2194 return false;
2195
2196 }
2197 _ => {
2198 return false;
2199
2200 },
2201 }
2202 ;
2203 let result: Result<(), Error> = this.SetDomain(arg0);
2204 let result = match result {
2205 Ok(result) => result,
2206 Err(e) => {
2207 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2208 return false;
2209 },
2210 };
2211
2212 true
2213 })());
2214 result
2215}
2216
2217
2218static domain_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2219
2220pub(crate) fn init_domain_getterinfo<D: DomTypes>() {
2221 domain_getterinfo.set(JSJitInfo {
2222 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2223 getter: Some(get_domain::<D>)
2224 },
2225 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2226 protoID: PrototypeList::ID::Document as u16,
2227 },
2228 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2229 _bitfield_align_1: [],
2230 _bitfield_1: __BindgenBitfieldUnit::new(
2231 new_jsjitinfo_bitfield_1!(
2232 JSJitInfo_OpType::Getter as u8,
2233 JSJitInfo_AliasSet::AliasEverything as u8,
2234 JSValueType::JSVAL_TYPE_STRING as u8,
2235 true,
2236 false,
2237 false,
2238 false,
2239 false,
2240 false,
2241 0,
2242 ).to_ne_bytes()
2243 ),
2244});
2245}
2246static domain_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2247
2248pub(crate) fn init_domain_setterinfo<D: DomTypes>() {
2249 domain_setterinfo.set(JSJitInfo {
2250 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2251 setter: Some(set_domain::<D>)
2252 },
2253 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2254 protoID: PrototypeList::ID::Document as u16,
2255 },
2256 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2257 _bitfield_align_1: [],
2258 _bitfield_1: __BindgenBitfieldUnit::new(
2259 new_jsjitinfo_bitfield_1!(
2260 JSJitInfo_OpType::Setter as u8,
2261 JSJitInfo_AliasSet::AliasEverything as u8,
2262 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2263 false,
2264 false,
2265 false,
2266 false,
2267 false,
2268 false,
2269 0,
2270 ).to_ne_bytes()
2271 ),
2272});
2273}
2274unsafe extern "C" fn get_referrer<D: DomTypes>
2275(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2276 let mut result = false;
2277 wrap_panic(&mut || result = (|| {
2278 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2279 let this = &*(this as *const D::Document);
2280 let result: DOMString = this.Referrer();
2281
2282 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2283 return true;
2284 })());
2285 result
2286}
2287
2288
2289static referrer_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2290
2291pub(crate) fn init_referrer_getterinfo<D: DomTypes>() {
2292 referrer_getterinfo.set(JSJitInfo {
2293 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2294 getter: Some(get_referrer::<D>)
2295 },
2296 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2297 protoID: PrototypeList::ID::Document as u16,
2298 },
2299 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2300 _bitfield_align_1: [],
2301 _bitfield_1: __BindgenBitfieldUnit::new(
2302 new_jsjitinfo_bitfield_1!(
2303 JSJitInfo_OpType::Getter as u8,
2304 JSJitInfo_AliasSet::AliasEverything as u8,
2305 JSValueType::JSVAL_TYPE_STRING as u8,
2306 true,
2307 false,
2308 false,
2309 false,
2310 false,
2311 false,
2312 0,
2313 ).to_ne_bytes()
2314 ),
2315});
2316}
2317unsafe extern "C" fn get_cookie<D: DomTypes>
2318(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2319 let mut result = false;
2320 wrap_panic(&mut || result = (|| {
2321 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2322 let this = &*(this as *const D::Document);
2323 let result: Result<DOMString, Error> = this.GetCookie();
2324 let result = match result {
2325 Ok(result) => result,
2326 Err(e) => {
2327 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2328 return false;
2329 },
2330 };
2331
2332 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2333 return true;
2334 })());
2335 result
2336}
2337
2338unsafe extern "C" fn set_cookie<D: DomTypes>
2339(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2340 let mut result = false;
2341 wrap_panic(&mut || result = (|| {
2342 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2343 let this = &*(this as *const D::Document);
2344 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2345 Ok(ConversionResult::Success(value)) => value,
2346 Ok(ConversionResult::Failure(error)) => {
2347 throw_type_error(cx.raw_cx(), &error);
2348 return false;
2349
2350 }
2351 _ => {
2352 return false;
2353
2354 },
2355 }
2356 ;
2357 let result: Result<(), Error> = this.SetCookie(arg0);
2358 let result = match result {
2359 Ok(result) => result,
2360 Err(e) => {
2361 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2362 return false;
2363 },
2364 };
2365
2366 true
2367 })());
2368 result
2369}
2370
2371
2372static cookie_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2373
2374pub(crate) fn init_cookie_getterinfo<D: DomTypes>() {
2375 cookie_getterinfo.set(JSJitInfo {
2376 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2377 getter: Some(get_cookie::<D>)
2378 },
2379 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2380 protoID: PrototypeList::ID::Document as u16,
2381 },
2382 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2383 _bitfield_align_1: [],
2384 _bitfield_1: __BindgenBitfieldUnit::new(
2385 new_jsjitinfo_bitfield_1!(
2386 JSJitInfo_OpType::Getter as u8,
2387 JSJitInfo_AliasSet::AliasEverything as u8,
2388 JSValueType::JSVAL_TYPE_STRING as u8,
2389 false,
2390 false,
2391 false,
2392 false,
2393 false,
2394 false,
2395 0,
2396 ).to_ne_bytes()
2397 ),
2398});
2399}
2400static cookie_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2401
2402pub(crate) fn init_cookie_setterinfo<D: DomTypes>() {
2403 cookie_setterinfo.set(JSJitInfo {
2404 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2405 setter: Some(set_cookie::<D>)
2406 },
2407 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2408 protoID: PrototypeList::ID::Document as u16,
2409 },
2410 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2411 _bitfield_align_1: [],
2412 _bitfield_1: __BindgenBitfieldUnit::new(
2413 new_jsjitinfo_bitfield_1!(
2414 JSJitInfo_OpType::Setter as u8,
2415 JSJitInfo_AliasSet::AliasEverything as u8,
2416 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2417 false,
2418 false,
2419 false,
2420 false,
2421 false,
2422 false,
2423 0,
2424 ).to_ne_bytes()
2425 ),
2426});
2427}
2428unsafe extern "C" fn get_lastModified<D: DomTypes>
2429(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2430 let mut result = false;
2431 wrap_panic(&mut || result = (|| {
2432 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2433 let this = &*(this as *const D::Document);
2434 let result: DOMString = this.LastModified();
2435
2436 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2437 return true;
2438 })());
2439 result
2440}
2441
2442
2443static lastModified_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2444
2445pub(crate) fn init_lastModified_getterinfo<D: DomTypes>() {
2446 lastModified_getterinfo.set(JSJitInfo {
2447 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2448 getter: Some(get_lastModified::<D>)
2449 },
2450 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2451 protoID: PrototypeList::ID::Document as u16,
2452 },
2453 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2454 _bitfield_align_1: [],
2455 _bitfield_1: __BindgenBitfieldUnit::new(
2456 new_jsjitinfo_bitfield_1!(
2457 JSJitInfo_OpType::Getter as u8,
2458 JSJitInfo_AliasSet::AliasEverything as u8,
2459 JSValueType::JSVAL_TYPE_STRING as u8,
2460 true,
2461 false,
2462 false,
2463 false,
2464 false,
2465 false,
2466 0,
2467 ).to_ne_bytes()
2468 ),
2469});
2470}
2471unsafe extern "C" fn get_readyState<D: DomTypes>
2472(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2473 let mut result = false;
2474 wrap_panic(&mut || result = (|| {
2475 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2476 let this = &*(this as *const D::Document);
2477 let result: DocumentReadyState = this.ReadyState();
2478
2479 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2480 return true;
2481 })());
2482 result
2483}
2484
2485
2486static readyState_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2487
2488pub(crate) fn init_readyState_getterinfo<D: DomTypes>() {
2489 readyState_getterinfo.set(JSJitInfo {
2490 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2491 getter: Some(get_readyState::<D>)
2492 },
2493 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2494 protoID: PrototypeList::ID::Document as u16,
2495 },
2496 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2497 _bitfield_align_1: [],
2498 _bitfield_1: __BindgenBitfieldUnit::new(
2499 new_jsjitinfo_bitfield_1!(
2500 JSJitInfo_OpType::Getter as u8,
2501 JSJitInfo_AliasSet::AliasEverything as u8,
2502 JSValueType::JSVAL_TYPE_STRING as u8,
2503 true,
2504 false,
2505 false,
2506 false,
2507 false,
2508 false,
2509 0,
2510 ).to_ne_bytes()
2511 ),
2512});
2513}
2514unsafe extern "C" fn get_title<D: DomTypes>
2515(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2516 let mut result = false;
2517 wrap_panic(&mut || result = (|| {
2518 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2519 let this = &*(this as *const D::Document);
2520 <D as DomHelpers<D>>::push_new_element_queue();
2521
2522 let result: DOMString = this.Title();
2523 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2524
2525
2526 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2527 return true;
2528 })());
2529 result
2530}
2531
2532unsafe extern "C" fn set_title<D: DomTypes>
2533(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2534 let mut result = false;
2535 wrap_panic(&mut || result = (|| {
2536 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2537 let this = &*(this as *const D::Document);
2538 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2539 Ok(ConversionResult::Success(value)) => value,
2540 Ok(ConversionResult::Failure(error)) => {
2541 throw_type_error(cx.raw_cx(), &error);
2542 return false;
2543
2544 }
2545 _ => {
2546 return false;
2547
2548 },
2549 }
2550 ;
2551 <D as DomHelpers<D>>::push_new_element_queue();
2552
2553 let result: () = this.SetTitle(arg0, CanGc::note());
2554 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2555
2556
2557 true
2558 })());
2559 result
2560}
2561
2562
2563static title_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2564
2565pub(crate) fn init_title_getterinfo<D: DomTypes>() {
2566 title_getterinfo.set(JSJitInfo {
2567 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2568 getter: Some(get_title::<D>)
2569 },
2570 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2571 protoID: PrototypeList::ID::Document as u16,
2572 },
2573 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2574 _bitfield_align_1: [],
2575 _bitfield_1: __BindgenBitfieldUnit::new(
2576 new_jsjitinfo_bitfield_1!(
2577 JSJitInfo_OpType::Getter as u8,
2578 JSJitInfo_AliasSet::AliasEverything as u8,
2579 JSValueType::JSVAL_TYPE_STRING as u8,
2580 true,
2581 false,
2582 false,
2583 false,
2584 false,
2585 false,
2586 0,
2587 ).to_ne_bytes()
2588 ),
2589});
2590}
2591static title_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2592
2593pub(crate) fn init_title_setterinfo<D: DomTypes>() {
2594 title_setterinfo.set(JSJitInfo {
2595 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2596 setter: Some(set_title::<D>)
2597 },
2598 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2599 protoID: PrototypeList::ID::Document as u16,
2600 },
2601 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2602 _bitfield_align_1: [],
2603 _bitfield_1: __BindgenBitfieldUnit::new(
2604 new_jsjitinfo_bitfield_1!(
2605 JSJitInfo_OpType::Setter as u8,
2606 JSJitInfo_AliasSet::AliasEverything as u8,
2607 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2608 false,
2609 false,
2610 false,
2611 false,
2612 false,
2613 false,
2614 0,
2615 ).to_ne_bytes()
2616 ),
2617});
2618}
2619unsafe extern "C" fn get_body<D: DomTypes>
2620(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2621 let mut result = false;
2622 wrap_panic(&mut || result = (|| {
2623 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2624 let this = &*(this as *const D::Document);
2625 <D as DomHelpers<D>>::push_new_element_queue();
2626
2627 let result: Option<DomRoot<D::HTMLElement>> = this.GetBody();
2628 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2629
2630
2631 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2632 return true;
2633 })());
2634 result
2635}
2636
2637unsafe extern "C" fn set_body<D: DomTypes>
2638(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2639 let mut result = false;
2640 wrap_panic(&mut || result = (|| {
2641 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2642 let this = &*(this as *const D::Document);
2643 let arg0: Option<DomRoot<D::HTMLElement>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2644 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2645 Ok(val) => val,
2646 Err(()) => {
2647 throw_type_error(cx.raw_cx(), "value does not implement interface HTMLElement.");
2648 return false;
2649
2650 }
2651 }
2652 )
2653 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2654 None
2655 } else {
2656 throw_type_error(cx.raw_cx(), "Value is not an object.");
2657 return false;
2658
2659 };
2660 <D as DomHelpers<D>>::push_new_element_queue();
2661
2662 let result: Result<(), Error> = this.SetBody(arg0.as_deref(), CanGc::note());
2663 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2664
2665 let result = match result {
2666 Ok(result) => result,
2667 Err(e) => {
2668 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2669 return false;
2670 },
2671 };
2672
2673 true
2674 })());
2675 result
2676}
2677
2678
2679static body_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2680
2681pub(crate) fn init_body_getterinfo<D: DomTypes>() {
2682 body_getterinfo.set(JSJitInfo {
2683 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2684 getter: Some(get_body::<D>)
2685 },
2686 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2687 protoID: PrototypeList::ID::Document as u16,
2688 },
2689 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2690 _bitfield_align_1: [],
2691 _bitfield_1: __BindgenBitfieldUnit::new(
2692 new_jsjitinfo_bitfield_1!(
2693 JSJitInfo_OpType::Getter as u8,
2694 JSJitInfo_AliasSet::AliasEverything as u8,
2695 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2696 true,
2697 false,
2698 false,
2699 false,
2700 false,
2701 false,
2702 0,
2703 ).to_ne_bytes()
2704 ),
2705});
2706}
2707static body_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2708
2709pub(crate) fn init_body_setterinfo<D: DomTypes>() {
2710 body_setterinfo.set(JSJitInfo {
2711 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2712 setter: Some(set_body::<D>)
2713 },
2714 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2715 protoID: PrototypeList::ID::Document as u16,
2716 },
2717 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2718 _bitfield_align_1: [],
2719 _bitfield_1: __BindgenBitfieldUnit::new(
2720 new_jsjitinfo_bitfield_1!(
2721 JSJitInfo_OpType::Setter as u8,
2722 JSJitInfo_AliasSet::AliasEverything as u8,
2723 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2724 false,
2725 false,
2726 false,
2727 false,
2728 false,
2729 false,
2730 0,
2731 ).to_ne_bytes()
2732 ),
2733});
2734}
2735unsafe extern "C" fn get_head<D: DomTypes>
2736(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2737 let mut result = false;
2738 wrap_panic(&mut || result = (|| {
2739 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2740 let this = &*(this as *const D::Document);
2741 let result: Option<DomRoot<D::HTMLHeadElement>> = this.GetHead();
2742
2743 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2744 return true;
2745 })());
2746 result
2747}
2748
2749
2750static head_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2751
2752pub(crate) fn init_head_getterinfo<D: DomTypes>() {
2753 head_getterinfo.set(JSJitInfo {
2754 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2755 getter: Some(get_head::<D>)
2756 },
2757 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2758 protoID: PrototypeList::ID::Document as u16,
2759 },
2760 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2761 _bitfield_align_1: [],
2762 _bitfield_1: __BindgenBitfieldUnit::new(
2763 new_jsjitinfo_bitfield_1!(
2764 JSJitInfo_OpType::Getter as u8,
2765 JSJitInfo_AliasSet::AliasEverything as u8,
2766 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2767 true,
2768 false,
2769 false,
2770 false,
2771 false,
2772 false,
2773 0,
2774 ).to_ne_bytes()
2775 ),
2776});
2777}
2778unsafe extern "C" fn get_images<D: DomTypes>
2779(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2780 let mut result = false;
2781 wrap_panic(&mut || result = (|| {
2782 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2783 let this = &*(this as *const D::Document);
2784 let result: DomRoot<D::HTMLCollection> = this.Images(CanGc::note());
2785
2786 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2787 return true;
2788 })());
2789 result
2790}
2791
2792
2793static images_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2794
2795pub(crate) fn init_images_getterinfo<D: DomTypes>() {
2796 images_getterinfo.set(JSJitInfo {
2797 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2798 getter: Some(get_images::<D>)
2799 },
2800 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2801 protoID: PrototypeList::ID::Document as u16,
2802 },
2803 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2804 _bitfield_align_1: [],
2805 _bitfield_1: __BindgenBitfieldUnit::new(
2806 new_jsjitinfo_bitfield_1!(
2807 JSJitInfo_OpType::Getter as u8,
2808 JSJitInfo_AliasSet::AliasNone as u8,
2809 JSValueType::JSVAL_TYPE_OBJECT as u8,
2810 true,
2811 true,
2812 false,
2813 false,
2814 false,
2815 false,
2816 0,
2817 ).to_ne_bytes()
2818 ),
2819});
2820}
2821unsafe extern "C" fn get_embeds<D: DomTypes>
2822(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2823 let mut result = false;
2824 wrap_panic(&mut || result = (|| {
2825 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2826 let this = &*(this as *const D::Document);
2827 let result: DomRoot<D::HTMLCollection> = this.Embeds(CanGc::note());
2828
2829 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2830 return true;
2831 })());
2832 result
2833}
2834
2835
2836static embeds_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2837
2838pub(crate) fn init_embeds_getterinfo<D: DomTypes>() {
2839 embeds_getterinfo.set(JSJitInfo {
2840 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2841 getter: Some(get_embeds::<D>)
2842 },
2843 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2844 protoID: PrototypeList::ID::Document as u16,
2845 },
2846 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2847 _bitfield_align_1: [],
2848 _bitfield_1: __BindgenBitfieldUnit::new(
2849 new_jsjitinfo_bitfield_1!(
2850 JSJitInfo_OpType::Getter as u8,
2851 JSJitInfo_AliasSet::AliasNone as u8,
2852 JSValueType::JSVAL_TYPE_OBJECT as u8,
2853 true,
2854 true,
2855 false,
2856 false,
2857 false,
2858 false,
2859 0,
2860 ).to_ne_bytes()
2861 ),
2862});
2863}
2864unsafe extern "C" fn get_plugins<D: DomTypes>
2865(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2866 let mut result = false;
2867 wrap_panic(&mut || result = (|| {
2868 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2869 let this = &*(this as *const D::Document);
2870 let result: DomRoot<D::HTMLCollection> = this.Plugins(CanGc::note());
2871
2872 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2873 return true;
2874 })());
2875 result
2876}
2877
2878
2879static plugins_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2880
2881pub(crate) fn init_plugins_getterinfo<D: DomTypes>() {
2882 plugins_getterinfo.set(JSJitInfo {
2883 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2884 getter: Some(get_plugins::<D>)
2885 },
2886 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2887 protoID: PrototypeList::ID::Document as u16,
2888 },
2889 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2890 _bitfield_align_1: [],
2891 _bitfield_1: __BindgenBitfieldUnit::new(
2892 new_jsjitinfo_bitfield_1!(
2893 JSJitInfo_OpType::Getter as u8,
2894 JSJitInfo_AliasSet::AliasNone as u8,
2895 JSValueType::JSVAL_TYPE_OBJECT as u8,
2896 true,
2897 true,
2898 false,
2899 false,
2900 false,
2901 false,
2902 0,
2903 ).to_ne_bytes()
2904 ),
2905});
2906}
2907unsafe extern "C" fn get_links<D: DomTypes>
2908(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2909 let mut result = false;
2910 wrap_panic(&mut || result = (|| {
2911 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2912 let this = &*(this as *const D::Document);
2913 let result: DomRoot<D::HTMLCollection> = this.Links(CanGc::note());
2914
2915 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2916 return true;
2917 })());
2918 result
2919}
2920
2921
2922static links_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2923
2924pub(crate) fn init_links_getterinfo<D: DomTypes>() {
2925 links_getterinfo.set(JSJitInfo {
2926 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2927 getter: Some(get_links::<D>)
2928 },
2929 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2930 protoID: PrototypeList::ID::Document as u16,
2931 },
2932 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2933 _bitfield_align_1: [],
2934 _bitfield_1: __BindgenBitfieldUnit::new(
2935 new_jsjitinfo_bitfield_1!(
2936 JSJitInfo_OpType::Getter as u8,
2937 JSJitInfo_AliasSet::AliasNone as u8,
2938 JSValueType::JSVAL_TYPE_OBJECT as u8,
2939 true,
2940 true,
2941 false,
2942 false,
2943 false,
2944 false,
2945 0,
2946 ).to_ne_bytes()
2947 ),
2948});
2949}
2950unsafe extern "C" fn get_forms<D: DomTypes>
2951(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2952 let mut result = false;
2953 wrap_panic(&mut || result = (|| {
2954 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2955 let this = &*(this as *const D::Document);
2956 let result: DomRoot<D::HTMLCollection> = this.Forms(CanGc::note());
2957
2958 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2959 return true;
2960 })());
2961 result
2962}
2963
2964
2965static forms_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2966
2967pub(crate) fn init_forms_getterinfo<D: DomTypes>() {
2968 forms_getterinfo.set(JSJitInfo {
2969 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2970 getter: Some(get_forms::<D>)
2971 },
2972 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2973 protoID: PrototypeList::ID::Document as u16,
2974 },
2975 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
2976 _bitfield_align_1: [],
2977 _bitfield_1: __BindgenBitfieldUnit::new(
2978 new_jsjitinfo_bitfield_1!(
2979 JSJitInfo_OpType::Getter as u8,
2980 JSJitInfo_AliasSet::AliasNone as u8,
2981 JSValueType::JSVAL_TYPE_OBJECT as u8,
2982 true,
2983 true,
2984 false,
2985 false,
2986 false,
2987 false,
2988 0,
2989 ).to_ne_bytes()
2990 ),
2991});
2992}
2993unsafe extern "C" fn get_scripts<D: DomTypes>
2994(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2995 let mut result = false;
2996 wrap_panic(&mut || result = (|| {
2997 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2998 let this = &*(this as *const D::Document);
2999 let result: DomRoot<D::HTMLCollection> = this.Scripts(CanGc::note());
3000
3001 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3002 return true;
3003 })());
3004 result
3005}
3006
3007
3008static scripts_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3009
3010pub(crate) fn init_scripts_getterinfo<D: DomTypes>() {
3011 scripts_getterinfo.set(JSJitInfo {
3012 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3013 getter: Some(get_scripts::<D>)
3014 },
3015 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3016 protoID: PrototypeList::ID::Document as u16,
3017 },
3018 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3019 _bitfield_align_1: [],
3020 _bitfield_1: __BindgenBitfieldUnit::new(
3021 new_jsjitinfo_bitfield_1!(
3022 JSJitInfo_OpType::Getter as u8,
3023 JSJitInfo_AliasSet::AliasNone as u8,
3024 JSValueType::JSVAL_TYPE_OBJECT as u8,
3025 true,
3026 true,
3027 false,
3028 false,
3029 false,
3030 false,
3031 0,
3032 ).to_ne_bytes()
3033 ),
3034});
3035}
3036unsafe extern "C" fn getElementsByName<D: DomTypes>
3037(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3038 let mut result = false;
3039 wrap_panic(&mut || result = (|| {
3040 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3041 let this = &*(this as *const D::Document);
3042 let args = &*args;
3043 let argc = args.argc_;
3044
3045 if argc < 1 {
3046 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.getElementsByName\".");
3047 return false;
3048 }
3049 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
3050 Ok(ConversionResult::Success(value)) => value,
3051 Ok(ConversionResult::Failure(error)) => {
3052 throw_type_error(cx.raw_cx(), &error);
3053 return false;
3054
3055 }
3056 _ => {
3057 return false;
3058
3059 },
3060 }
3061 ;
3062 let result: DomRoot<D::NodeList> = this.GetElementsByName(arg0, CanGc::note());
3063
3064 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3065 return true;
3066 })());
3067 result
3068}
3069
3070
3071static getElementsByName_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3072
3073pub(crate) fn init_getElementsByName_methodinfo<D: DomTypes>() {
3074 getElementsByName_methodinfo.set(JSJitInfo {
3075 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3076 method: Some(getElementsByName::<D>)
3077 },
3078 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3079 protoID: PrototypeList::ID::Document as u16,
3080 },
3081 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3082 _bitfield_align_1: [],
3083 _bitfield_1: __BindgenBitfieldUnit::new(
3084 new_jsjitinfo_bitfield_1!(
3085 JSJitInfo_OpType::Method as u8,
3086 JSJitInfo_AliasSet::AliasEverything as u8,
3087 JSValueType::JSVAL_TYPE_OBJECT as u8,
3088 false,
3089 false,
3090 false,
3091 false,
3092 false,
3093 false,
3094 0,
3095 ).to_ne_bytes()
3096 ),
3097});
3098}
3099unsafe extern "C" fn get_currentScript<D: DomTypes>
3100(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3101 let mut result = false;
3102 wrap_panic(&mut || result = (|| {
3103 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3104 let this = &*(this as *const D::Document);
3105 let result: Option<DomRoot<D::HTMLScriptElement>> = this.GetCurrentScript();
3106
3107 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3108 return true;
3109 })());
3110 result
3111}
3112
3113
3114static currentScript_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3115
3116pub(crate) fn init_currentScript_getterinfo<D: DomTypes>() {
3117 currentScript_getterinfo.set(JSJitInfo {
3118 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3119 getter: Some(get_currentScript::<D>)
3120 },
3121 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3122 protoID: PrototypeList::ID::Document as u16,
3123 },
3124 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3125 _bitfield_align_1: [],
3126 _bitfield_1: __BindgenBitfieldUnit::new(
3127 new_jsjitinfo_bitfield_1!(
3128 JSJitInfo_OpType::Getter as u8,
3129 JSJitInfo_AliasSet::AliasEverything as u8,
3130 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
3131 true,
3132 false,
3133 false,
3134 false,
3135 false,
3136 false,
3137 0,
3138 ).to_ne_bytes()
3139 ),
3140});
3141}
3142unsafe extern "C" fn open<D: DomTypes>
3143(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3144 let mut result = false;
3145 wrap_panic(&mut || result = (|| {
3146 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3147 let this = &*(this as *const D::Document);
3148 let args = &*args;
3149 let argc = args.argc_;
3150
3151 let argcount = cmp::min(argc, 3);
3152 match argcount {
3153 0 => {
3154 let arg0: Option<DOMString> = if args.get(0).is_undefined() {
3155 None
3156 } else {
3157 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
3158 Ok(ConversionResult::Success(value)) => value,
3159 Ok(ConversionResult::Failure(error)) => {
3160 throw_type_error(cx.raw_cx(), &error);
3161 return false;
3162
3163 }
3164 _ => {
3165 return false;
3166
3167 },
3168 }
3169 )
3170 };
3171 let arg1: Option<DOMString> = if args.get(1).is_undefined() {
3172 None
3173 } else {
3174 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
3175 Ok(ConversionResult::Success(value)) => value,
3176 Ok(ConversionResult::Failure(error)) => {
3177 throw_type_error(cx.raw_cx(), &error);
3178 return false;
3179
3180 }
3181 _ => {
3182 return false;
3183
3184 },
3185 }
3186 )
3187 };
3188 <D as DomHelpers<D>>::push_new_element_queue();
3189
3190 let result: Result<DomRoot<D::Document>, Error> = this.Open(arg0, arg1, CanGc::note());
3191 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3192
3193 let result = match result {
3194 Ok(result) => result,
3195 Err(e) => {
3196 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3197 return false;
3198 },
3199 };
3200
3201 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3202 return true;
3203 }
3204 1 => {
3205 let arg0: Option<DOMString> = if args.get(0).is_undefined() {
3206 None
3207 } else {
3208 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
3209 Ok(ConversionResult::Success(value)) => value,
3210 Ok(ConversionResult::Failure(error)) => {
3211 throw_type_error(cx.raw_cx(), &error);
3212 return false;
3213
3214 }
3215 _ => {
3216 return false;
3217
3218 },
3219 }
3220 )
3221 };
3222 let arg1: Option<DOMString> = if args.get(1).is_undefined() {
3223 None
3224 } else {
3225 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
3226 Ok(ConversionResult::Success(value)) => value,
3227 Ok(ConversionResult::Failure(error)) => {
3228 throw_type_error(cx.raw_cx(), &error);
3229 return false;
3230
3231 }
3232 _ => {
3233 return false;
3234
3235 },
3236 }
3237 )
3238 };
3239 <D as DomHelpers<D>>::push_new_element_queue();
3240
3241 let result: Result<DomRoot<D::Document>, Error> = this.Open(arg0, arg1, CanGc::note());
3242 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3243
3244 let result = match result {
3245 Ok(result) => result,
3246 Err(e) => {
3247 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3248 return false;
3249 },
3250 };
3251
3252 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3253 return true;
3254 }
3255 2 => {
3256 let arg0: Option<DOMString> = if args.get(0).is_undefined() {
3257 None
3258 } else {
3259 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
3260 Ok(ConversionResult::Success(value)) => value,
3261 Ok(ConversionResult::Failure(error)) => {
3262 throw_type_error(cx.raw_cx(), &error);
3263 return false;
3264
3265 }
3266 _ => {
3267 return false;
3268
3269 },
3270 }
3271 )
3272 };
3273 let arg1: Option<DOMString> = if args.get(1).is_undefined() {
3274 None
3275 } else {
3276 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
3277 Ok(ConversionResult::Success(value)) => value,
3278 Ok(ConversionResult::Failure(error)) => {
3279 throw_type_error(cx.raw_cx(), &error);
3280 return false;
3281
3282 }
3283 _ => {
3284 return false;
3285
3286 },
3287 }
3288 )
3289 };
3290 <D as DomHelpers<D>>::push_new_element_queue();
3291
3292 let result: Result<DomRoot<D::Document>, Error> = this.Open(arg0, arg1, CanGc::note());
3293 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3294
3295 let result = match result {
3296 Ok(result) => result,
3297 Err(e) => {
3298 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3299 return false;
3300 },
3301 };
3302
3303 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3304 return true;
3305 }
3306 3 => {
3307 let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3308 Ok(ConversionResult::Success(value)) => value,
3309 Ok(ConversionResult::Failure(error)) => {
3310 throw_type_error(cx.raw_cx(), &error);
3311 return false;
3312
3313 }
3314 _ => {
3315 return false;
3316
3317 },
3318 }
3319 ;
3320 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
3321 Ok(ConversionResult::Success(value)) => value,
3322 Ok(ConversionResult::Failure(error)) => {
3323 throw_type_error(cx.raw_cx(), &error);
3324 return false;
3325
3326 }
3327 _ => {
3328 return false;
3329
3330 },
3331 }
3332 ;
3333 let arg2: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), StringificationBehavior::Default) {
3334 Ok(ConversionResult::Success(value)) => value,
3335 Ok(ConversionResult::Failure(error)) => {
3336 throw_type_error(cx.raw_cx(), &error);
3337 return false;
3338
3339 }
3340 _ => {
3341 return false;
3342
3343 },
3344 }
3345 ;
3346 <D as DomHelpers<D>>::push_new_element_queue();
3347
3348 let result: Result<Option<DomRoot<D::WindowProxy>>, Error> = this.Open_(arg0, arg1, arg2, CanGc::note());
3349 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3350
3351 let result = match result {
3352 Ok(result) => result,
3353 Err(e) => {
3354 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3355 return false;
3356 },
3357 };
3358
3359 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3360 return true;
3361 }
3362 _ => {
3363 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.open\".");
3364 return false;
3365 }
3366 }
3367 })());
3368 result
3369}
3370
3371
3372static open_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3373
3374pub(crate) fn init_open_methodinfo<D: DomTypes>() {
3375 open_methodinfo.set(JSJitInfo {
3376 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3377 method: Some(open::<D>)
3378 },
3379 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3380 protoID: PrototypeList::ID::Document as u16,
3381 },
3382 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3383 _bitfield_align_1: [],
3384 _bitfield_1: __BindgenBitfieldUnit::new(
3385 new_jsjitinfo_bitfield_1!(
3386 JSJitInfo_OpType::Method as u8,
3387 JSJitInfo_AliasSet::AliasEverything as u8,
3388 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
3389 false,
3390 false,
3391 false,
3392 false,
3393 false,
3394 false,
3395 0,
3396 ).to_ne_bytes()
3397 ),
3398});
3399}
3400unsafe extern "C" fn close<D: DomTypes>
3401(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3402 let mut result = false;
3403 wrap_panic(&mut || result = (|| {
3404 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3405 let this = &*(this as *const D::Document);
3406 let args = &*args;
3407 let argc = args.argc_;
3408 <D as DomHelpers<D>>::push_new_element_queue();
3409
3410 let result: Result<(), Error> = this.Close(CanGc::note());
3411 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3412
3413 let result = match result {
3414 Ok(result) => result,
3415 Err(e) => {
3416 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3417 return false;
3418 },
3419 };
3420
3421 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3422 return true;
3423 })());
3424 result
3425}
3426
3427
3428static close_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3429
3430pub(crate) fn init_close_methodinfo<D: DomTypes>() {
3431 close_methodinfo.set(JSJitInfo {
3432 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3433 method: Some(close::<D>)
3434 },
3435 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3436 protoID: PrototypeList::ID::Document as u16,
3437 },
3438 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3439 _bitfield_align_1: [],
3440 _bitfield_1: __BindgenBitfieldUnit::new(
3441 new_jsjitinfo_bitfield_1!(
3442 JSJitInfo_OpType::Method as u8,
3443 JSJitInfo_AliasSet::AliasEverything as u8,
3444 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3445 false,
3446 false,
3447 false,
3448 false,
3449 false,
3450 false,
3451 0,
3452 ).to_ne_bytes()
3453 ),
3454});
3455}
3456unsafe extern "C" fn write<D: DomTypes>
3457(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3458 let mut result = false;
3459 wrap_panic(&mut || result = (|| {
3460 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3461 let this = &*(this as *const D::Document);
3462 let args = &*args;
3463 let argc = args.argc_;
3464
3465 let mut arg0 = vec![];
3466 if argc > 0 {
3467 arg0.reserve(argc as usize);
3468 for variadicArg in 0..argc {
3469 let slot: GenericUnionTypes::TrustedHTMLOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
3470 Ok(ConversionResult::Success(value)) => value,
3471 Ok(ConversionResult::Failure(error)) => {
3472 throw_type_error(cx.raw_cx(), &error);
3473 return false;
3474
3475 }
3476 _ => {
3477 return false;
3478
3479 },
3480 }
3481 ;
3482 arg0.push(slot);
3483 }
3484 }
3485 <D as DomHelpers<D>>::push_new_element_queue();
3486
3487 let result: Result<(), Error> = this.Write(arg0, CanGc::note());
3488 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3489
3490 let result = match result {
3491 Ok(result) => result,
3492 Err(e) => {
3493 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3494 return false;
3495 },
3496 };
3497
3498 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3499 return true;
3500 })());
3501 result
3502}
3503
3504
3505static write_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3506
3507pub(crate) fn init_write_methodinfo<D: DomTypes>() {
3508 write_methodinfo.set(JSJitInfo {
3509 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3510 method: Some(write::<D>)
3511 },
3512 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3513 protoID: PrototypeList::ID::Document as u16,
3514 },
3515 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3516 _bitfield_align_1: [],
3517 _bitfield_1: __BindgenBitfieldUnit::new(
3518 new_jsjitinfo_bitfield_1!(
3519 JSJitInfo_OpType::Method as u8,
3520 JSJitInfo_AliasSet::AliasEverything as u8,
3521 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3522 false,
3523 false,
3524 false,
3525 false,
3526 false,
3527 false,
3528 0,
3529 ).to_ne_bytes()
3530 ),
3531});
3532}
3533unsafe extern "C" fn writeln<D: DomTypes>
3534(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3535 let mut result = false;
3536 wrap_panic(&mut || result = (|| {
3537 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3538 let this = &*(this as *const D::Document);
3539 let args = &*args;
3540 let argc = args.argc_;
3541
3542 let mut arg0 = vec![];
3543 if argc > 0 {
3544 arg0.reserve(argc as usize);
3545 for variadicArg in 0..argc {
3546 let slot: GenericUnionTypes::TrustedHTMLOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
3547 Ok(ConversionResult::Success(value)) => value,
3548 Ok(ConversionResult::Failure(error)) => {
3549 throw_type_error(cx.raw_cx(), &error);
3550 return false;
3551
3552 }
3553 _ => {
3554 return false;
3555
3556 },
3557 }
3558 ;
3559 arg0.push(slot);
3560 }
3561 }
3562 <D as DomHelpers<D>>::push_new_element_queue();
3563
3564 let result: Result<(), Error> = this.Writeln(arg0, CanGc::note());
3565 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3566
3567 let result = match result {
3568 Ok(result) => result,
3569 Err(e) => {
3570 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3571 return false;
3572 },
3573 };
3574
3575 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3576 return true;
3577 })());
3578 result
3579}
3580
3581
3582static writeln_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3583
3584pub(crate) fn init_writeln_methodinfo<D: DomTypes>() {
3585 writeln_methodinfo.set(JSJitInfo {
3586 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3587 method: Some(writeln::<D>)
3588 },
3589 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3590 protoID: PrototypeList::ID::Document as u16,
3591 },
3592 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3593 _bitfield_align_1: [],
3594 _bitfield_1: __BindgenBitfieldUnit::new(
3595 new_jsjitinfo_bitfield_1!(
3596 JSJitInfo_OpType::Method as u8,
3597 JSJitInfo_AliasSet::AliasEverything as u8,
3598 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3599 false,
3600 false,
3601 false,
3602 false,
3603 false,
3604 false,
3605 0,
3606 ).to_ne_bytes()
3607 ),
3608});
3609}
3610unsafe extern "C" fn get_defaultView<D: DomTypes>
3611(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3612 let mut result = false;
3613 wrap_panic(&mut || result = (|| {
3614 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3615 let this = &*(this as *const D::Document);
3616 let result: Option<DomRoot<D::Window>> = this.GetDefaultView();
3617
3618 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3619 return true;
3620 })());
3621 result
3622}
3623
3624
3625static defaultView_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3626
3627pub(crate) fn init_defaultView_getterinfo<D: DomTypes>() {
3628 defaultView_getterinfo.set(JSJitInfo {
3629 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3630 getter: Some(get_defaultView::<D>)
3631 },
3632 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3633 protoID: PrototypeList::ID::Document as u16,
3634 },
3635 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3636 _bitfield_align_1: [],
3637 _bitfield_1: __BindgenBitfieldUnit::new(
3638 new_jsjitinfo_bitfield_1!(
3639 JSJitInfo_OpType::Getter as u8,
3640 JSJitInfo_AliasSet::AliasEverything as u8,
3641 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
3642 true,
3643 false,
3644 false,
3645 false,
3646 false,
3647 false,
3648 0,
3649 ).to_ne_bytes()
3650 ),
3651});
3652}
3653unsafe extern "C" fn hasFocus<D: DomTypes>
3654(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3655 let mut result = false;
3656 wrap_panic(&mut || result = (|| {
3657 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3658 let this = &*(this as *const D::Document);
3659 let args = &*args;
3660 let argc = args.argc_;
3661 let result: bool = this.HasFocus();
3662
3663 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3664 return true;
3665 })());
3666 result
3667}
3668
3669
3670static hasFocus_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3671
3672pub(crate) fn init_hasFocus_methodinfo<D: DomTypes>() {
3673 hasFocus_methodinfo.set(JSJitInfo {
3674 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3675 method: Some(hasFocus::<D>)
3676 },
3677 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3678 protoID: PrototypeList::ID::Document as u16,
3679 },
3680 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3681 _bitfield_align_1: [],
3682 _bitfield_1: __BindgenBitfieldUnit::new(
3683 new_jsjitinfo_bitfield_1!(
3684 JSJitInfo_OpType::Method as u8,
3685 JSJitInfo_AliasSet::AliasEverything as u8,
3686 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
3687 true,
3688 false,
3689 false,
3690 false,
3691 false,
3692 false,
3693 0,
3694 ).to_ne_bytes()
3695 ),
3696});
3697}
3698unsafe extern "C" fn queryCommandSupported<D: DomTypes>
3699(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3700 let mut result = false;
3701 wrap_panic(&mut || result = (|| {
3702 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3703 let this = &*(this as *const D::Document);
3704 let args = &*args;
3705 let argc = args.argc_;
3706
3707 if argc < 1 {
3708 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.queryCommandSupported\".");
3709 return false;
3710 }
3711 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
3712 Ok(ConversionResult::Success(value)) => value,
3713 Ok(ConversionResult::Failure(error)) => {
3714 throw_type_error(cx.raw_cx(), &error);
3715 return false;
3716
3717 }
3718 _ => {
3719 return false;
3720
3721 },
3722 }
3723 ;
3724 let result: bool = this.QueryCommandSupported(arg0);
3725
3726 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3727 return true;
3728 })());
3729 result
3730}
3731
3732
3733static queryCommandSupported_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3734
3735pub(crate) fn init_queryCommandSupported_methodinfo<D: DomTypes>() {
3736 queryCommandSupported_methodinfo.set(JSJitInfo {
3737 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3738 method: Some(queryCommandSupported::<D>)
3739 },
3740 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3741 protoID: PrototypeList::ID::Document as u16,
3742 },
3743 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3744 _bitfield_align_1: [],
3745 _bitfield_1: __BindgenBitfieldUnit::new(
3746 new_jsjitinfo_bitfield_1!(
3747 JSJitInfo_OpType::Method as u8,
3748 JSJitInfo_AliasSet::AliasEverything as u8,
3749 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
3750 false,
3751 false,
3752 false,
3753 false,
3754 false,
3755 false,
3756 0,
3757 ).to_ne_bytes()
3758 ),
3759});
3760}
3761unsafe extern "C" fn get_hidden<D: DomTypes>
3762(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3763 let mut result = false;
3764 wrap_panic(&mut || result = (|| {
3765 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3766 let this = &*(this as *const D::Document);
3767 let result: bool = this.Hidden();
3768
3769 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3770 return true;
3771 })());
3772 result
3773}
3774
3775
3776static hidden_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3777
3778pub(crate) fn init_hidden_getterinfo<D: DomTypes>() {
3779 hidden_getterinfo.set(JSJitInfo {
3780 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3781 getter: Some(get_hidden::<D>)
3782 },
3783 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3784 protoID: PrototypeList::ID::Document as u16,
3785 },
3786 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3787 _bitfield_align_1: [],
3788 _bitfield_1: __BindgenBitfieldUnit::new(
3789 new_jsjitinfo_bitfield_1!(
3790 JSJitInfo_OpType::Getter as u8,
3791 JSJitInfo_AliasSet::AliasEverything as u8,
3792 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
3793 true,
3794 false,
3795 false,
3796 false,
3797 false,
3798 false,
3799 0,
3800 ).to_ne_bytes()
3801 ),
3802});
3803}
3804unsafe extern "C" fn get_visibilityState<D: DomTypes>
3805(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3806 let mut result = false;
3807 wrap_panic(&mut || result = (|| {
3808 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3809 let this = &*(this as *const D::Document);
3810 let result: DocumentVisibilityState = this.VisibilityState();
3811
3812 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3813 return true;
3814 })());
3815 result
3816}
3817
3818
3819static visibilityState_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3820
3821pub(crate) fn init_visibilityState_getterinfo<D: DomTypes>() {
3822 visibilityState_getterinfo.set(JSJitInfo {
3823 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3824 getter: Some(get_visibilityState::<D>)
3825 },
3826 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3827 protoID: PrototypeList::ID::Document as u16,
3828 },
3829 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3830 _bitfield_align_1: [],
3831 _bitfield_1: __BindgenBitfieldUnit::new(
3832 new_jsjitinfo_bitfield_1!(
3833 JSJitInfo_OpType::Getter as u8,
3834 JSJitInfo_AliasSet::AliasEverything as u8,
3835 JSValueType::JSVAL_TYPE_STRING as u8,
3836 true,
3837 false,
3838 false,
3839 false,
3840 false,
3841 false,
3842 0,
3843 ).to_ne_bytes()
3844 ),
3845});
3846}
3847unsafe extern "C" fn get_onreadystatechange<D: DomTypes>
3848(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3849 let mut result = false;
3850 wrap_panic(&mut || result = (|| {
3851 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3852 let this = &*(this as *const D::Document);
3853 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnreadystatechange();
3854
3855 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3856 return true;
3857 })());
3858 result
3859}
3860
3861unsafe extern "C" fn set_onreadystatechange<D: DomTypes>
3862(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3863 let mut result = false;
3864 wrap_panic(&mut || result = {
3865 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3866 let this = &*(this as *const D::Document);
3867 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
3868 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
3869 } else {
3870 None
3871 };
3872 let result: () = this.SetOnreadystatechange(arg0);
3873
3874 true
3875 });
3876 result
3877}
3878
3879
3880static onreadystatechange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3881
3882pub(crate) fn init_onreadystatechange_getterinfo<D: DomTypes>() {
3883 onreadystatechange_getterinfo.set(JSJitInfo {
3884 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3885 getter: Some(get_onreadystatechange::<D>)
3886 },
3887 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3888 protoID: PrototypeList::ID::Document as u16,
3889 },
3890 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3891 _bitfield_align_1: [],
3892 _bitfield_1: __BindgenBitfieldUnit::new(
3893 new_jsjitinfo_bitfield_1!(
3894 JSJitInfo_OpType::Getter as u8,
3895 JSJitInfo_AliasSet::AliasEverything as u8,
3896 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
3897 true,
3898 false,
3899 false,
3900 false,
3901 false,
3902 false,
3903 0,
3904 ).to_ne_bytes()
3905 ),
3906});
3907}
3908static onreadystatechange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3909
3910pub(crate) fn init_onreadystatechange_setterinfo<D: DomTypes>() {
3911 onreadystatechange_setterinfo.set(JSJitInfo {
3912 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3913 setter: Some(set_onreadystatechange::<D>)
3914 },
3915 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3916 protoID: PrototypeList::ID::Document as u16,
3917 },
3918 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3919 _bitfield_align_1: [],
3920 _bitfield_1: __BindgenBitfieldUnit::new(
3921 new_jsjitinfo_bitfield_1!(
3922 JSJitInfo_OpType::Setter as u8,
3923 JSJitInfo_AliasSet::AliasEverything as u8,
3924 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3925 false,
3926 false,
3927 false,
3928 false,
3929 false,
3930 false,
3931 0,
3932 ).to_ne_bytes()
3933 ),
3934});
3935}
3936unsafe extern "C" fn get_fgColor<D: DomTypes>
3937(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3938 let mut result = false;
3939 wrap_panic(&mut || result = (|| {
3940 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3941 let this = &*(this as *const D::Document);
3942 <D as DomHelpers<D>>::push_new_element_queue();
3943
3944 let result: DOMString = this.FgColor();
3945 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3946
3947
3948 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3949 return true;
3950 })());
3951 result
3952}
3953
3954unsafe extern "C" fn set_fgColor<D: DomTypes>
3955(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3956 let mut result = false;
3957 wrap_panic(&mut || result = (|| {
3958 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3959 let this = &*(this as *const D::Document);
3960 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Empty) {
3961 Ok(ConversionResult::Success(value)) => value,
3962 Ok(ConversionResult::Failure(error)) => {
3963 throw_type_error(cx.raw_cx(), &error);
3964 return false;
3965
3966 }
3967 _ => {
3968 return false;
3969
3970 },
3971 }
3972 ;
3973 <D as DomHelpers<D>>::push_new_element_queue();
3974
3975 let result: () = this.SetFgColor(arg0, CanGc::note());
3976 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3977
3978
3979 true
3980 })());
3981 result
3982}
3983
3984
3985static fgColor_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3986
3987pub(crate) fn init_fgColor_getterinfo<D: DomTypes>() {
3988 fgColor_getterinfo.set(JSJitInfo {
3989 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3990 getter: Some(get_fgColor::<D>)
3991 },
3992 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3993 protoID: PrototypeList::ID::Document as u16,
3994 },
3995 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
3996 _bitfield_align_1: [],
3997 _bitfield_1: __BindgenBitfieldUnit::new(
3998 new_jsjitinfo_bitfield_1!(
3999 JSJitInfo_OpType::Getter as u8,
4000 JSJitInfo_AliasSet::AliasEverything as u8,
4001 JSValueType::JSVAL_TYPE_STRING as u8,
4002 true,
4003 false,
4004 false,
4005 false,
4006 false,
4007 false,
4008 0,
4009 ).to_ne_bytes()
4010 ),
4011});
4012}
4013static fgColor_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4014
4015pub(crate) fn init_fgColor_setterinfo<D: DomTypes>() {
4016 fgColor_setterinfo.set(JSJitInfo {
4017 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4018 setter: Some(set_fgColor::<D>)
4019 },
4020 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4021 protoID: PrototypeList::ID::Document as u16,
4022 },
4023 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4024 _bitfield_align_1: [],
4025 _bitfield_1: __BindgenBitfieldUnit::new(
4026 new_jsjitinfo_bitfield_1!(
4027 JSJitInfo_OpType::Setter as u8,
4028 JSJitInfo_AliasSet::AliasEverything as u8,
4029 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4030 false,
4031 false,
4032 false,
4033 false,
4034 false,
4035 false,
4036 0,
4037 ).to_ne_bytes()
4038 ),
4039});
4040}
4041unsafe extern "C" fn get_bgColor<D: DomTypes>
4042(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4043 let mut result = false;
4044 wrap_panic(&mut || result = (|| {
4045 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4046 let this = &*(this as *const D::Document);
4047 <D as DomHelpers<D>>::push_new_element_queue();
4048
4049 let result: DOMString = this.BgColor();
4050 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
4051
4052
4053 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4054 return true;
4055 })());
4056 result
4057}
4058
4059unsafe extern "C" fn set_bgColor<D: DomTypes>
4060(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4061 let mut result = false;
4062 wrap_panic(&mut || result = (|| {
4063 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4064 let this = &*(this as *const D::Document);
4065 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Empty) {
4066 Ok(ConversionResult::Success(value)) => value,
4067 Ok(ConversionResult::Failure(error)) => {
4068 throw_type_error(cx.raw_cx(), &error);
4069 return false;
4070
4071 }
4072 _ => {
4073 return false;
4074
4075 },
4076 }
4077 ;
4078 <D as DomHelpers<D>>::push_new_element_queue();
4079
4080 let result: () = this.SetBgColor(arg0, CanGc::note());
4081 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
4082
4083
4084 true
4085 })());
4086 result
4087}
4088
4089
4090static bgColor_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4091
4092pub(crate) fn init_bgColor_getterinfo<D: DomTypes>() {
4093 bgColor_getterinfo.set(JSJitInfo {
4094 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4095 getter: Some(get_bgColor::<D>)
4096 },
4097 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4098 protoID: PrototypeList::ID::Document as u16,
4099 },
4100 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4101 _bitfield_align_1: [],
4102 _bitfield_1: __BindgenBitfieldUnit::new(
4103 new_jsjitinfo_bitfield_1!(
4104 JSJitInfo_OpType::Getter as u8,
4105 JSJitInfo_AliasSet::AliasEverything as u8,
4106 JSValueType::JSVAL_TYPE_STRING as u8,
4107 true,
4108 false,
4109 false,
4110 false,
4111 false,
4112 false,
4113 0,
4114 ).to_ne_bytes()
4115 ),
4116});
4117}
4118static bgColor_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4119
4120pub(crate) fn init_bgColor_setterinfo<D: DomTypes>() {
4121 bgColor_setterinfo.set(JSJitInfo {
4122 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4123 setter: Some(set_bgColor::<D>)
4124 },
4125 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4126 protoID: PrototypeList::ID::Document as u16,
4127 },
4128 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4129 _bitfield_align_1: [],
4130 _bitfield_1: __BindgenBitfieldUnit::new(
4131 new_jsjitinfo_bitfield_1!(
4132 JSJitInfo_OpType::Setter as u8,
4133 JSJitInfo_AliasSet::AliasEverything as u8,
4134 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4135 false,
4136 false,
4137 false,
4138 false,
4139 false,
4140 false,
4141 0,
4142 ).to_ne_bytes()
4143 ),
4144});
4145}
4146unsafe extern "C" fn get_anchors<D: DomTypes>
4147(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4148 let mut result = false;
4149 wrap_panic(&mut || result = (|| {
4150 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4151 let this = &*(this as *const D::Document);
4152 let result: DomRoot<D::HTMLCollection> = this.Anchors(CanGc::note());
4153
4154 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4155 return true;
4156 })());
4157 result
4158}
4159
4160
4161static anchors_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4162
4163pub(crate) fn init_anchors_getterinfo<D: DomTypes>() {
4164 anchors_getterinfo.set(JSJitInfo {
4165 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4166 getter: Some(get_anchors::<D>)
4167 },
4168 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4169 protoID: PrototypeList::ID::Document as u16,
4170 },
4171 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4172 _bitfield_align_1: [],
4173 _bitfield_1: __BindgenBitfieldUnit::new(
4174 new_jsjitinfo_bitfield_1!(
4175 JSJitInfo_OpType::Getter as u8,
4176 JSJitInfo_AliasSet::AliasNone as u8,
4177 JSValueType::JSVAL_TYPE_OBJECT as u8,
4178 true,
4179 true,
4180 false,
4181 false,
4182 false,
4183 false,
4184 0,
4185 ).to_ne_bytes()
4186 ),
4187});
4188}
4189unsafe extern "C" fn get_applets<D: DomTypes>
4190(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4191 let mut result = false;
4192 wrap_panic(&mut || result = (|| {
4193 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4194 let this = &*(this as *const D::Document);
4195 let result: DomRoot<D::HTMLCollection> = this.Applets(CanGc::note());
4196
4197 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4198 return true;
4199 })());
4200 result
4201}
4202
4203
4204static applets_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4205
4206pub(crate) fn init_applets_getterinfo<D: DomTypes>() {
4207 applets_getterinfo.set(JSJitInfo {
4208 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4209 getter: Some(get_applets::<D>)
4210 },
4211 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4212 protoID: PrototypeList::ID::Document as u16,
4213 },
4214 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4215 _bitfield_align_1: [],
4216 _bitfield_1: __BindgenBitfieldUnit::new(
4217 new_jsjitinfo_bitfield_1!(
4218 JSJitInfo_OpType::Getter as u8,
4219 JSJitInfo_AliasSet::AliasNone as u8,
4220 JSValueType::JSVAL_TYPE_OBJECT as u8,
4221 true,
4222 true,
4223 false,
4224 false,
4225 false,
4226 false,
4227 0,
4228 ).to_ne_bytes()
4229 ),
4230});
4231}
4232unsafe extern "C" fn clear<D: DomTypes>
4233(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4234 let mut result = false;
4235 wrap_panic(&mut || result = (|| {
4236 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4237 let this = &*(this as *const D::Document);
4238 let args = &*args;
4239 let argc = args.argc_;
4240 let result: () = this.Clear();
4241
4242 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4243 return true;
4244 })());
4245 result
4246}
4247
4248
4249static clear_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4250
4251pub(crate) fn init_clear_methodinfo<D: DomTypes>() {
4252 clear_methodinfo.set(JSJitInfo {
4253 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4254 method: Some(clear::<D>)
4255 },
4256 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4257 protoID: PrototypeList::ID::Document as u16,
4258 },
4259 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4260 _bitfield_align_1: [],
4261 _bitfield_1: __BindgenBitfieldUnit::new(
4262 new_jsjitinfo_bitfield_1!(
4263 JSJitInfo_OpType::Method as u8,
4264 JSJitInfo_AliasSet::AliasEverything as u8,
4265 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4266 true,
4267 false,
4268 false,
4269 false,
4270 false,
4271 false,
4272 0,
4273 ).to_ne_bytes()
4274 ),
4275});
4276}
4277unsafe extern "C" fn captureEvents<D: DomTypes>
4278(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4279 let mut result = false;
4280 wrap_panic(&mut || result = (|| {
4281 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4282 let this = &*(this as *const D::Document);
4283 let args = &*args;
4284 let argc = args.argc_;
4285 let result: () = this.CaptureEvents();
4286
4287 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4288 return true;
4289 })());
4290 result
4291}
4292
4293
4294static captureEvents_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4295
4296pub(crate) fn init_captureEvents_methodinfo<D: DomTypes>() {
4297 captureEvents_methodinfo.set(JSJitInfo {
4298 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4299 method: Some(captureEvents::<D>)
4300 },
4301 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4302 protoID: PrototypeList::ID::Document as u16,
4303 },
4304 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4305 _bitfield_align_1: [],
4306 _bitfield_1: __BindgenBitfieldUnit::new(
4307 new_jsjitinfo_bitfield_1!(
4308 JSJitInfo_OpType::Method as u8,
4309 JSJitInfo_AliasSet::AliasEverything as u8,
4310 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4311 true,
4312 false,
4313 false,
4314 false,
4315 false,
4316 false,
4317 0,
4318 ).to_ne_bytes()
4319 ),
4320});
4321}
4322unsafe extern "C" fn releaseEvents<D: DomTypes>
4323(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4324 let mut result = false;
4325 wrap_panic(&mut || result = (|| {
4326 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4327 let this = &*(this as *const D::Document);
4328 let args = &*args;
4329 let argc = args.argc_;
4330 let result: () = this.ReleaseEvents();
4331
4332 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4333 return true;
4334 })());
4335 result
4336}
4337
4338
4339static releaseEvents_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4340
4341pub(crate) fn init_releaseEvents_methodinfo<D: DomTypes>() {
4342 releaseEvents_methodinfo.set(JSJitInfo {
4343 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4344 method: Some(releaseEvents::<D>)
4345 },
4346 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4347 protoID: PrototypeList::ID::Document as u16,
4348 },
4349 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4350 _bitfield_align_1: [],
4351 _bitfield_1: __BindgenBitfieldUnit::new(
4352 new_jsjitinfo_bitfield_1!(
4353 JSJitInfo_OpType::Method as u8,
4354 JSJitInfo_AliasSet::AliasEverything as u8,
4355 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4356 true,
4357 false,
4358 false,
4359 false,
4360 false,
4361 false,
4362 0,
4363 ).to_ne_bytes()
4364 ),
4365});
4366}
4367unsafe extern "C" fn get_fullscreenEnabled<D: DomTypes>
4368(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4369 let mut result = false;
4370 wrap_panic(&mut || result = (|| {
4371 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4372 let this = &*(this as *const D::Document);
4373 let result: bool = this.FullscreenEnabled();
4374
4375 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4376 return true;
4377 })());
4378 result
4379}
4380
4381
4382static fullscreenEnabled_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4383
4384pub(crate) fn init_fullscreenEnabled_getterinfo<D: DomTypes>() {
4385 fullscreenEnabled_getterinfo.set(JSJitInfo {
4386 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4387 getter: Some(get_fullscreenEnabled::<D>)
4388 },
4389 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4390 protoID: PrototypeList::ID::Document as u16,
4391 },
4392 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4393 _bitfield_align_1: [],
4394 _bitfield_1: __BindgenBitfieldUnit::new(
4395 new_jsjitinfo_bitfield_1!(
4396 JSJitInfo_OpType::Getter as u8,
4397 JSJitInfo_AliasSet::AliasEverything as u8,
4398 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
4399 true,
4400 false,
4401 false,
4402 false,
4403 false,
4404 false,
4405 0,
4406 ).to_ne_bytes()
4407 ),
4408});
4409}
4410unsafe extern "C" fn get_fullscreenElement<D: DomTypes>
4411(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4412 let mut result = false;
4413 wrap_panic(&mut || result = (|| {
4414 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4415 let this = &*(this as *const D::Document);
4416 let result: Option<DomRoot<D::Element>> = this.GetFullscreenElement();
4417
4418 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4419 return true;
4420 })());
4421 result
4422}
4423
4424
4425static fullscreenElement_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4426
4427pub(crate) fn init_fullscreenElement_getterinfo<D: DomTypes>() {
4428 fullscreenElement_getterinfo.set(JSJitInfo {
4429 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4430 getter: Some(get_fullscreenElement::<D>)
4431 },
4432 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4433 protoID: PrototypeList::ID::Document as u16,
4434 },
4435 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4436 _bitfield_align_1: [],
4437 _bitfield_1: __BindgenBitfieldUnit::new(
4438 new_jsjitinfo_bitfield_1!(
4439 JSJitInfo_OpType::Getter as u8,
4440 JSJitInfo_AliasSet::AliasEverything as u8,
4441 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4442 true,
4443 false,
4444 false,
4445 false,
4446 false,
4447 false,
4448 0,
4449 ).to_ne_bytes()
4450 ),
4451});
4452}
4453unsafe extern "C" fn get_fullscreen<D: DomTypes>
4454(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4455 let mut result = false;
4456 wrap_panic(&mut || result = (|| {
4457 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4458 let this = &*(this as *const D::Document);
4459 let result: bool = this.Fullscreen();
4460
4461 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4462 return true;
4463 })());
4464 result
4465}
4466
4467
4468static fullscreen_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4469
4470pub(crate) fn init_fullscreen_getterinfo<D: DomTypes>() {
4471 fullscreen_getterinfo.set(JSJitInfo {
4472 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4473 getter: Some(get_fullscreen::<D>)
4474 },
4475 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4476 protoID: PrototypeList::ID::Document as u16,
4477 },
4478 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4479 _bitfield_align_1: [],
4480 _bitfield_1: __BindgenBitfieldUnit::new(
4481 new_jsjitinfo_bitfield_1!(
4482 JSJitInfo_OpType::Getter as u8,
4483 JSJitInfo_AliasSet::AliasEverything as u8,
4484 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
4485 true,
4486 false,
4487 false,
4488 false,
4489 false,
4490 false,
4491 0,
4492 ).to_ne_bytes()
4493 ),
4494});
4495}
4496unsafe extern "C" fn exitFullscreen<D: DomTypes>
4497(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4498 let mut result = false;
4499 wrap_panic(&mut || result = (|| {
4500 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4501 let this = &*(this as *const D::Document);
4502 let args = &*args;
4503 let argc = args.argc_;
4504 let result: Rc<D::Promise> = this.ExitFullscreen(CanGc::note());
4505
4506 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4507 return true;
4508 })());
4509 result
4510}
4511
4512unsafe extern "C" fn exitFullscreen_promise_wrapper<D: DomTypes>
4513(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4514 let mut result = false;
4515 wrap_panic(&mut || result = (|| {
4516 let ok = exitFullscreen::<D>(cx, _obj, this, args);
4517 if ok {
4518 return true;
4519 }
4520 return exception_to_promise(cx, (*args).rval(), CanGc::note());
4521
4522 })());
4523 result
4524}
4525
4526
4527static exitFullscreen_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4528
4529pub(crate) fn init_exitFullscreen_methodinfo<D: DomTypes>() {
4530 exitFullscreen_methodinfo.set(JSJitInfo {
4531 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4532 method: Some(exitFullscreen_promise_wrapper::<D>)
4533 },
4534 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4535 protoID: PrototypeList::ID::Document as u16,
4536 },
4537 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4538 _bitfield_align_1: [],
4539 _bitfield_1: __BindgenBitfieldUnit::new(
4540 new_jsjitinfo_bitfield_1!(
4541 JSJitInfo_OpType::Method as u8,
4542 JSJitInfo_AliasSet::AliasEverything as u8,
4543 JSValueType::JSVAL_TYPE_OBJECT as u8,
4544 true,
4545 false,
4546 false,
4547 false,
4548 false,
4549 false,
4550 0,
4551 ).to_ne_bytes()
4552 ),
4553});
4554}
4555unsafe extern "C" fn get_onfullscreenchange<D: DomTypes>
4556(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4557 let mut result = false;
4558 wrap_panic(&mut || result = (|| {
4559 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4560 let this = &*(this as *const D::Document);
4561 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnfullscreenchange();
4562
4563 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4564 return true;
4565 })());
4566 result
4567}
4568
4569unsafe extern "C" fn set_onfullscreenchange<D: DomTypes>
4570(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4571 let mut result = false;
4572 wrap_panic(&mut || result = {
4573 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4574 let this = &*(this as *const D::Document);
4575 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4576 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
4577 } else {
4578 None
4579 };
4580 let result: () = this.SetOnfullscreenchange(arg0);
4581
4582 true
4583 });
4584 result
4585}
4586
4587
4588static onfullscreenchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4589
4590pub(crate) fn init_onfullscreenchange_getterinfo<D: DomTypes>() {
4591 onfullscreenchange_getterinfo.set(JSJitInfo {
4592 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4593 getter: Some(get_onfullscreenchange::<D>)
4594 },
4595 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4596 protoID: PrototypeList::ID::Document as u16,
4597 },
4598 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4599 _bitfield_align_1: [],
4600 _bitfield_1: __BindgenBitfieldUnit::new(
4601 new_jsjitinfo_bitfield_1!(
4602 JSJitInfo_OpType::Getter as u8,
4603 JSJitInfo_AliasSet::AliasEverything as u8,
4604 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4605 true,
4606 false,
4607 false,
4608 false,
4609 false,
4610 false,
4611 0,
4612 ).to_ne_bytes()
4613 ),
4614});
4615}
4616static onfullscreenchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4617
4618pub(crate) fn init_onfullscreenchange_setterinfo<D: DomTypes>() {
4619 onfullscreenchange_setterinfo.set(JSJitInfo {
4620 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4621 setter: Some(set_onfullscreenchange::<D>)
4622 },
4623 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4624 protoID: PrototypeList::ID::Document as u16,
4625 },
4626 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4627 _bitfield_align_1: [],
4628 _bitfield_1: __BindgenBitfieldUnit::new(
4629 new_jsjitinfo_bitfield_1!(
4630 JSJitInfo_OpType::Setter as u8,
4631 JSJitInfo_AliasSet::AliasEverything as u8,
4632 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4633 false,
4634 false,
4635 false,
4636 false,
4637 false,
4638 false,
4639 0,
4640 ).to_ne_bytes()
4641 ),
4642});
4643}
4644unsafe extern "C" fn get_onfullscreenerror<D: DomTypes>
4645(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4646 let mut result = false;
4647 wrap_panic(&mut || result = (|| {
4648 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4649 let this = &*(this as *const D::Document);
4650 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnfullscreenerror();
4651
4652 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4653 return true;
4654 })());
4655 result
4656}
4657
4658unsafe extern "C" fn set_onfullscreenerror<D: DomTypes>
4659(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4660 let mut result = false;
4661 wrap_panic(&mut || result = {
4662 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4663 let this = &*(this as *const D::Document);
4664 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4665 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
4666 } else {
4667 None
4668 };
4669 let result: () = this.SetOnfullscreenerror(arg0);
4670
4671 true
4672 });
4673 result
4674}
4675
4676
4677static onfullscreenerror_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4678
4679pub(crate) fn init_onfullscreenerror_getterinfo<D: DomTypes>() {
4680 onfullscreenerror_getterinfo.set(JSJitInfo {
4681 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4682 getter: Some(get_onfullscreenerror::<D>)
4683 },
4684 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4685 protoID: PrototypeList::ID::Document as u16,
4686 },
4687 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4688 _bitfield_align_1: [],
4689 _bitfield_1: __BindgenBitfieldUnit::new(
4690 new_jsjitinfo_bitfield_1!(
4691 JSJitInfo_OpType::Getter as u8,
4692 JSJitInfo_AliasSet::AliasEverything as u8,
4693 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4694 true,
4695 false,
4696 false,
4697 false,
4698 false,
4699 false,
4700 0,
4701 ).to_ne_bytes()
4702 ),
4703});
4704}
4705static onfullscreenerror_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4706
4707pub(crate) fn init_onfullscreenerror_setterinfo<D: DomTypes>() {
4708 onfullscreenerror_setterinfo.set(JSJitInfo {
4709 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4710 setter: Some(set_onfullscreenerror::<D>)
4711 },
4712 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4713 protoID: PrototypeList::ID::Document as u16,
4714 },
4715 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4716 _bitfield_align_1: [],
4717 _bitfield_1: __BindgenBitfieldUnit::new(
4718 new_jsjitinfo_bitfield_1!(
4719 JSJitInfo_OpType::Setter as u8,
4720 JSJitInfo_AliasSet::AliasEverything as u8,
4721 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4722 false,
4723 false,
4724 false,
4725 false,
4726 false,
4727 false,
4728 0,
4729 ).to_ne_bytes()
4730 ),
4731});
4732}
4733unsafe extern "C" fn get_scrollingElement<D: DomTypes>
4734(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4735 let mut result = false;
4736 wrap_panic(&mut || result = (|| {
4737 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4738 let this = &*(this as *const D::Document);
4739 let result: Option<DomRoot<D::Element>> = this.GetScrollingElement();
4740
4741 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4742 return true;
4743 })());
4744 result
4745}
4746
4747
4748static scrollingElement_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4749
4750pub(crate) fn init_scrollingElement_getterinfo<D: DomTypes>() {
4751 scrollingElement_getterinfo.set(JSJitInfo {
4752 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4753 getter: Some(get_scrollingElement::<D>)
4754 },
4755 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4756 protoID: PrototypeList::ID::Document as u16,
4757 },
4758 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4759 _bitfield_align_1: [],
4760 _bitfield_1: __BindgenBitfieldUnit::new(
4761 new_jsjitinfo_bitfield_1!(
4762 JSJitInfo_OpType::Getter as u8,
4763 JSJitInfo_AliasSet::AliasEverything as u8,
4764 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4765 true,
4766 false,
4767 false,
4768 false,
4769 false,
4770 false,
4771 0,
4772 ).to_ne_bytes()
4773 ),
4774});
4775}
4776unsafe extern "C" fn getSelection<D: DomTypes>
4777(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4778 let mut result = false;
4779 wrap_panic(&mut || result = (|| {
4780 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4781 let this = &*(this as *const D::Document);
4782 let args = &*args;
4783 let argc = args.argc_;
4784 let result: Option<DomRoot<D::Selection>> = this.GetSelection(CanGc::note());
4785
4786 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4787 return true;
4788 })());
4789 result
4790}
4791
4792
4793static getSelection_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4794
4795pub(crate) fn init_getSelection_methodinfo<D: DomTypes>() {
4796 getSelection_methodinfo.set(JSJitInfo {
4797 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4798 method: Some(getSelection::<D>)
4799 },
4800 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4801 protoID: PrototypeList::ID::Document as u16,
4802 },
4803 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4804 _bitfield_align_1: [],
4805 _bitfield_1: __BindgenBitfieldUnit::new(
4806 new_jsjitinfo_bitfield_1!(
4807 JSJitInfo_OpType::Method as u8,
4808 JSJitInfo_AliasSet::AliasEverything as u8,
4809 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4810 true,
4811 false,
4812 false,
4813 false,
4814 false,
4815 false,
4816 0,
4817 ).to_ne_bytes()
4818 ),
4819});
4820}
4821unsafe extern "C" fn servoGetMediaControls<D: DomTypes>
4822(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4823 let mut result = false;
4824 wrap_panic(&mut || result = (|| {
4825 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4826 let this = &*(this as *const D::Document);
4827 let args = &*args;
4828 let argc = args.argc_;
4829
4830 if argc < 1 {
4831 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.servoGetMediaControls\".");
4832 return false;
4833 }
4834 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4835 Ok(ConversionResult::Success(value)) => value,
4836 Ok(ConversionResult::Failure(error)) => {
4837 throw_type_error(cx.raw_cx(), &error);
4838 return false;
4839
4840 }
4841 _ => {
4842 return false;
4843
4844 },
4845 }
4846 ;
4847 let result: Result<DomRoot<D::ShadowRoot>, Error> = this.ServoGetMediaControls(arg0);
4848 let result = match result {
4849 Ok(result) => result,
4850 Err(e) => {
4851 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
4852 return false;
4853 },
4854 };
4855
4856 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4857 return true;
4858 })());
4859 result
4860}
4861
4862
4863static servoGetMediaControls_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4864
4865pub(crate) fn init_servoGetMediaControls_methodinfo<D: DomTypes>() {
4866 servoGetMediaControls_methodinfo.set(JSJitInfo {
4867 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4868 method: Some(servoGetMediaControls::<D>)
4869 },
4870 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4871 protoID: PrototypeList::ID::Document as u16,
4872 },
4873 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4874 _bitfield_align_1: [],
4875 _bitfield_1: __BindgenBitfieldUnit::new(
4876 new_jsjitinfo_bitfield_1!(
4877 JSJitInfo_OpType::Method as u8,
4878 JSJitInfo_AliasSet::AliasEverything as u8,
4879 JSValueType::JSVAL_TYPE_OBJECT as u8,
4880 false,
4881 false,
4882 false,
4883 false,
4884 false,
4885 false,
4886 0,
4887 ).to_ne_bytes()
4888 ),
4889});
4890}
4891unsafe extern "C" fn elementFromPoint<D: DomTypes>
4892(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4893 let mut result = false;
4894 wrap_panic(&mut || result = (|| {
4895 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4896 let this = &*(this as *const D::Document);
4897 let args = &*args;
4898 let argc = args.argc_;
4899
4900 if argc < 2 {
4901 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.elementFromPoint\".");
4902 return false;
4903 }
4904 let arg0: Finite<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4905 Ok(ConversionResult::Success(value)) => value,
4906 Ok(ConversionResult::Failure(error)) => {
4907 throw_type_error(cx.raw_cx(), &error);
4908 return false;
4909
4910 }
4911 _ => {
4912 return false;
4913
4914 },
4915 }
4916 ;
4917 let arg1: Finite<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
4918 Ok(ConversionResult::Success(value)) => value,
4919 Ok(ConversionResult::Failure(error)) => {
4920 throw_type_error(cx.raw_cx(), &error);
4921 return false;
4922
4923 }
4924 _ => {
4925 return false;
4926
4927 },
4928 }
4929 ;
4930 let result: Option<DomRoot<D::Element>> = this.ElementFromPoint(arg0, arg1);
4931
4932 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4933 return true;
4934 })());
4935 result
4936}
4937
4938
4939static elementFromPoint_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4940
4941pub(crate) fn init_elementFromPoint_methodinfo<D: DomTypes>() {
4942 elementFromPoint_methodinfo.set(JSJitInfo {
4943 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4944 method: Some(elementFromPoint::<D>)
4945 },
4946 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4947 protoID: PrototypeList::ID::Document as u16,
4948 },
4949 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
4950 _bitfield_align_1: [],
4951 _bitfield_1: __BindgenBitfieldUnit::new(
4952 new_jsjitinfo_bitfield_1!(
4953 JSJitInfo_OpType::Method as u8,
4954 JSJitInfo_AliasSet::AliasEverything as u8,
4955 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4956 false,
4957 false,
4958 false,
4959 false,
4960 false,
4961 false,
4962 0,
4963 ).to_ne_bytes()
4964 ),
4965});
4966}
4967unsafe extern "C" fn elementsFromPoint<D: DomTypes>
4968(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4969 let mut result = false;
4970 wrap_panic(&mut || result = (|| {
4971 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4972 let this = &*(this as *const D::Document);
4973 let args = &*args;
4974 let argc = args.argc_;
4975
4976 if argc < 2 {
4977 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.elementsFromPoint\".");
4978 return false;
4979 }
4980 let arg0: Finite<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4981 Ok(ConversionResult::Success(value)) => value,
4982 Ok(ConversionResult::Failure(error)) => {
4983 throw_type_error(cx.raw_cx(), &error);
4984 return false;
4985
4986 }
4987 _ => {
4988 return false;
4989
4990 },
4991 }
4992 ;
4993 let arg1: Finite<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
4994 Ok(ConversionResult::Success(value)) => value,
4995 Ok(ConversionResult::Failure(error)) => {
4996 throw_type_error(cx.raw_cx(), &error);
4997 return false;
4998
4999 }
5000 _ => {
5001 return false;
5002
5003 },
5004 }
5005 ;
5006 let result: Vec<DomRoot<D::Element>> = this.ElementsFromPoint(arg0, arg1);
5007
5008 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5009 return true;
5010 })());
5011 result
5012}
5013
5014
5015static elementsFromPoint_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5016
5017pub(crate) fn init_elementsFromPoint_methodinfo<D: DomTypes>() {
5018 elementsFromPoint_methodinfo.set(JSJitInfo {
5019 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5020 method: Some(elementsFromPoint::<D>)
5021 },
5022 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5023 protoID: PrototypeList::ID::Document as u16,
5024 },
5025 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5026 _bitfield_align_1: [],
5027 _bitfield_1: __BindgenBitfieldUnit::new(
5028 new_jsjitinfo_bitfield_1!(
5029 JSJitInfo_OpType::Method as u8,
5030 JSJitInfo_AliasSet::AliasEverything as u8,
5031 JSValueType::JSVAL_TYPE_OBJECT as u8,
5032 false,
5033 false,
5034 false,
5035 false,
5036 false,
5037 false,
5038 0,
5039 ).to_ne_bytes()
5040 ),
5041});
5042}
5043unsafe extern "C" fn get_activeElement<D: DomTypes>
5044(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5045 let mut result = false;
5046 wrap_panic(&mut || result = (|| {
5047 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5048 let this = &*(this as *const D::Document);
5049 let result: Option<DomRoot<D::Element>> = this.GetActiveElement();
5050
5051 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5052 return true;
5053 })());
5054 result
5055}
5056
5057
5058static activeElement_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5059
5060pub(crate) fn init_activeElement_getterinfo<D: DomTypes>() {
5061 activeElement_getterinfo.set(JSJitInfo {
5062 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5063 getter: Some(get_activeElement::<D>)
5064 },
5065 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5066 protoID: PrototypeList::ID::Document as u16,
5067 },
5068 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5069 _bitfield_align_1: [],
5070 _bitfield_1: __BindgenBitfieldUnit::new(
5071 new_jsjitinfo_bitfield_1!(
5072 JSJitInfo_OpType::Getter as u8,
5073 JSJitInfo_AliasSet::AliasEverything as u8,
5074 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5075 true,
5076 false,
5077 false,
5078 false,
5079 false,
5080 false,
5081 0,
5082 ).to_ne_bytes()
5083 ),
5084});
5085}
5086unsafe extern "C" fn get_styleSheets<D: DomTypes>
5087(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5088 let mut result = false;
5089 wrap_panic(&mut || result = (|| {
5090 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5091 let this = &*(this as *const D::Document);
5092 let result: DomRoot<D::StyleSheetList> = this.StyleSheets(CanGc::note());
5093
5094 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5095 return true;
5096 })());
5097 result
5098}
5099
5100
5101static styleSheets_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5102
5103pub(crate) fn init_styleSheets_getterinfo<D: DomTypes>() {
5104 styleSheets_getterinfo.set(JSJitInfo {
5105 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5106 getter: Some(get_styleSheets::<D>)
5107 },
5108 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5109 protoID: PrototypeList::ID::Document as u16,
5110 },
5111 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5112 _bitfield_align_1: [],
5113 _bitfield_1: __BindgenBitfieldUnit::new(
5114 new_jsjitinfo_bitfield_1!(
5115 JSJitInfo_OpType::Getter as u8,
5116 JSJitInfo_AliasSet::AliasEverything as u8,
5117 JSValueType::JSVAL_TYPE_OBJECT as u8,
5118 true,
5119 false,
5120 false,
5121 false,
5122 false,
5123 false,
5124 0,
5125 ).to_ne_bytes()
5126 ),
5127});
5128}
5129unsafe extern "C" fn get_adoptedStyleSheets<D: DomTypes>
5130(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5131 let mut result = false;
5132 wrap_panic(&mut || result = (|| {
5133 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5134 let this = &*(this as *const D::Document);
5135 rooted!(&in(cx) let mut retval: JSVal);
5136 let result: () = this.AdoptedStyleSheets(SafeJSContext::from_ptr(cx.raw_cx()), CanGc::note(), retval.handle_mut());
5137
5138 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5139 return true;
5140 })());
5141 result
5142}
5143
5144unsafe extern "C" fn set_adoptedStyleSheets<D: DomTypes>
5145(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5146 let mut result = false;
5147 wrap_panic(&mut || result = (|| {
5148 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5149 let this = &*(this as *const D::Document);
5150 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
5151 let result: Result<(), Error> = this.SetAdoptedStyleSheets(SafeJSContext::from_ptr(cx.raw_cx()), arg0, CanGc::note());
5152 let result = match result {
5153 Ok(result) => result,
5154 Err(e) => {
5155 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
5156 return false;
5157 },
5158 };
5159
5160 true
5161 })());
5162 result
5163}
5164
5165
5166static adoptedStyleSheets_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5167
5168pub(crate) fn init_adoptedStyleSheets_getterinfo<D: DomTypes>() {
5169 adoptedStyleSheets_getterinfo.set(JSJitInfo {
5170 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5171 getter: Some(get_adoptedStyleSheets::<D>)
5172 },
5173 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5174 protoID: PrototypeList::ID::Document as u16,
5175 },
5176 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5177 _bitfield_align_1: [],
5178 _bitfield_1: __BindgenBitfieldUnit::new(
5179 new_jsjitinfo_bitfield_1!(
5180 JSJitInfo_OpType::Getter as u8,
5181 JSJitInfo_AliasSet::AliasEverything as u8,
5182 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5183 true,
5184 false,
5185 false,
5186 false,
5187 false,
5188 false,
5189 0,
5190 ).to_ne_bytes()
5191 ),
5192});
5193}
5194static adoptedStyleSheets_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5195
5196pub(crate) fn init_adoptedStyleSheets_setterinfo<D: DomTypes>() {
5197 adoptedStyleSheets_setterinfo.set(JSJitInfo {
5198 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5199 setter: Some(set_adoptedStyleSheets::<D>)
5200 },
5201 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5202 protoID: PrototypeList::ID::Document as u16,
5203 },
5204 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5205 _bitfield_align_1: [],
5206 _bitfield_1: __BindgenBitfieldUnit::new(
5207 new_jsjitinfo_bitfield_1!(
5208 JSJitInfo_OpType::Setter as u8,
5209 JSJitInfo_AliasSet::AliasEverything as u8,
5210 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5211 false,
5212 false,
5213 false,
5214 false,
5215 false,
5216 false,
5217 0,
5218 ).to_ne_bytes()
5219 ),
5220});
5221}
5222unsafe extern "C" fn get_fonts<D: DomTypes>
5223(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5224 let mut result = false;
5225 wrap_panic(&mut || result = (|| {
5226 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5227 let this = &*(this as *const D::Document);
5228 let result: DomRoot<D::FontFaceSet> = this.Fonts(CanGc::note());
5229
5230 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5231 return true;
5232 })());
5233 result
5234}
5235
5236
5237static fonts_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5238
5239pub(crate) fn init_fonts_getterinfo<D: DomTypes>() {
5240 fonts_getterinfo.set(JSJitInfo {
5241 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5242 getter: Some(get_fonts::<D>)
5243 },
5244 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5245 protoID: PrototypeList::ID::Document as u16,
5246 },
5247 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5248 _bitfield_align_1: [],
5249 _bitfield_1: __BindgenBitfieldUnit::new(
5250 new_jsjitinfo_bitfield_1!(
5251 JSJitInfo_OpType::Getter as u8,
5252 JSJitInfo_AliasSet::AliasEverything as u8,
5253 JSValueType::JSVAL_TYPE_OBJECT as u8,
5254 true,
5255 false,
5256 false,
5257 false,
5258 false,
5259 false,
5260 0,
5261 ).to_ne_bytes()
5262 ),
5263});
5264}
5265unsafe extern "C" fn get_onabort<D: DomTypes>
5266(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5267 let mut result = false;
5268 wrap_panic(&mut || result = (|| {
5269 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5270 let this = &*(this as *const D::Document);
5271 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnabort();
5272
5273 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5274 return true;
5275 })());
5276 result
5277}
5278
5279unsafe extern "C" fn set_onabort<D: DomTypes>
5280(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5281 let mut result = false;
5282 wrap_panic(&mut || result = {
5283 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5284 let this = &*(this as *const D::Document);
5285 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5286 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5287 } else {
5288 None
5289 };
5290 let result: () = this.SetOnabort(arg0);
5291
5292 true
5293 });
5294 result
5295}
5296
5297
5298static onabort_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5299
5300pub(crate) fn init_onabort_getterinfo<D: DomTypes>() {
5301 onabort_getterinfo.set(JSJitInfo {
5302 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5303 getter: Some(get_onabort::<D>)
5304 },
5305 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5306 protoID: PrototypeList::ID::Document as u16,
5307 },
5308 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5309 _bitfield_align_1: [],
5310 _bitfield_1: __BindgenBitfieldUnit::new(
5311 new_jsjitinfo_bitfield_1!(
5312 JSJitInfo_OpType::Getter as u8,
5313 JSJitInfo_AliasSet::AliasEverything as u8,
5314 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5315 true,
5316 false,
5317 false,
5318 false,
5319 false,
5320 false,
5321 0,
5322 ).to_ne_bytes()
5323 ),
5324});
5325}
5326static onabort_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5327
5328pub(crate) fn init_onabort_setterinfo<D: DomTypes>() {
5329 onabort_setterinfo.set(JSJitInfo {
5330 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5331 setter: Some(set_onabort::<D>)
5332 },
5333 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5334 protoID: PrototypeList::ID::Document as u16,
5335 },
5336 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5337 _bitfield_align_1: [],
5338 _bitfield_1: __BindgenBitfieldUnit::new(
5339 new_jsjitinfo_bitfield_1!(
5340 JSJitInfo_OpType::Setter as u8,
5341 JSJitInfo_AliasSet::AliasEverything as u8,
5342 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5343 false,
5344 false,
5345 false,
5346 false,
5347 false,
5348 false,
5349 0,
5350 ).to_ne_bytes()
5351 ),
5352});
5353}
5354unsafe extern "C" fn get_onauxclick<D: DomTypes>
5355(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5356 let mut result = false;
5357 wrap_panic(&mut || result = (|| {
5358 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5359 let this = &*(this as *const D::Document);
5360 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnauxclick();
5361
5362 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5363 return true;
5364 })());
5365 result
5366}
5367
5368unsafe extern "C" fn set_onauxclick<D: DomTypes>
5369(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5370 let mut result = false;
5371 wrap_panic(&mut || result = {
5372 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5373 let this = &*(this as *const D::Document);
5374 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5375 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5376 } else {
5377 None
5378 };
5379 let result: () = this.SetOnauxclick(arg0);
5380
5381 true
5382 });
5383 result
5384}
5385
5386
5387static onauxclick_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5388
5389pub(crate) fn init_onauxclick_getterinfo<D: DomTypes>() {
5390 onauxclick_getterinfo.set(JSJitInfo {
5391 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5392 getter: Some(get_onauxclick::<D>)
5393 },
5394 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5395 protoID: PrototypeList::ID::Document as u16,
5396 },
5397 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5398 _bitfield_align_1: [],
5399 _bitfield_1: __BindgenBitfieldUnit::new(
5400 new_jsjitinfo_bitfield_1!(
5401 JSJitInfo_OpType::Getter as u8,
5402 JSJitInfo_AliasSet::AliasEverything as u8,
5403 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5404 true,
5405 false,
5406 false,
5407 false,
5408 false,
5409 false,
5410 0,
5411 ).to_ne_bytes()
5412 ),
5413});
5414}
5415static onauxclick_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5416
5417pub(crate) fn init_onauxclick_setterinfo<D: DomTypes>() {
5418 onauxclick_setterinfo.set(JSJitInfo {
5419 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5420 setter: Some(set_onauxclick::<D>)
5421 },
5422 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5423 protoID: PrototypeList::ID::Document as u16,
5424 },
5425 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5426 _bitfield_align_1: [],
5427 _bitfield_1: __BindgenBitfieldUnit::new(
5428 new_jsjitinfo_bitfield_1!(
5429 JSJitInfo_OpType::Setter as u8,
5430 JSJitInfo_AliasSet::AliasEverything as u8,
5431 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5432 false,
5433 false,
5434 false,
5435 false,
5436 false,
5437 false,
5438 0,
5439 ).to_ne_bytes()
5440 ),
5441});
5442}
5443unsafe extern "C" fn get_onbeforeinput<D: DomTypes>
5444(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5445 let mut result = false;
5446 wrap_panic(&mut || result = (|| {
5447 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5448 let this = &*(this as *const D::Document);
5449 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnbeforeinput();
5450
5451 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5452 return true;
5453 })());
5454 result
5455}
5456
5457unsafe extern "C" fn set_onbeforeinput<D: DomTypes>
5458(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5459 let mut result = false;
5460 wrap_panic(&mut || result = {
5461 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5462 let this = &*(this as *const D::Document);
5463 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5464 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5465 } else {
5466 None
5467 };
5468 let result: () = this.SetOnbeforeinput(arg0);
5469
5470 true
5471 });
5472 result
5473}
5474
5475
5476static onbeforeinput_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5477
5478pub(crate) fn init_onbeforeinput_getterinfo<D: DomTypes>() {
5479 onbeforeinput_getterinfo.set(JSJitInfo {
5480 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5481 getter: Some(get_onbeforeinput::<D>)
5482 },
5483 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5484 protoID: PrototypeList::ID::Document as u16,
5485 },
5486 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5487 _bitfield_align_1: [],
5488 _bitfield_1: __BindgenBitfieldUnit::new(
5489 new_jsjitinfo_bitfield_1!(
5490 JSJitInfo_OpType::Getter as u8,
5491 JSJitInfo_AliasSet::AliasEverything as u8,
5492 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5493 true,
5494 false,
5495 false,
5496 false,
5497 false,
5498 false,
5499 0,
5500 ).to_ne_bytes()
5501 ),
5502});
5503}
5504static onbeforeinput_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5505
5506pub(crate) fn init_onbeforeinput_setterinfo<D: DomTypes>() {
5507 onbeforeinput_setterinfo.set(JSJitInfo {
5508 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5509 setter: Some(set_onbeforeinput::<D>)
5510 },
5511 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5512 protoID: PrototypeList::ID::Document as u16,
5513 },
5514 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5515 _bitfield_align_1: [],
5516 _bitfield_1: __BindgenBitfieldUnit::new(
5517 new_jsjitinfo_bitfield_1!(
5518 JSJitInfo_OpType::Setter as u8,
5519 JSJitInfo_AliasSet::AliasEverything as u8,
5520 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5521 false,
5522 false,
5523 false,
5524 false,
5525 false,
5526 false,
5527 0,
5528 ).to_ne_bytes()
5529 ),
5530});
5531}
5532unsafe extern "C" fn get_onbeforematch<D: DomTypes>
5533(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5534 let mut result = false;
5535 wrap_panic(&mut || result = (|| {
5536 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5537 let this = &*(this as *const D::Document);
5538 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnbeforematch();
5539
5540 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5541 return true;
5542 })());
5543 result
5544}
5545
5546unsafe extern "C" fn set_onbeforematch<D: DomTypes>
5547(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5548 let mut result = false;
5549 wrap_panic(&mut || result = {
5550 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5551 let this = &*(this as *const D::Document);
5552 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5553 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5554 } else {
5555 None
5556 };
5557 let result: () = this.SetOnbeforematch(arg0);
5558
5559 true
5560 });
5561 result
5562}
5563
5564
5565static onbeforematch_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5566
5567pub(crate) fn init_onbeforematch_getterinfo<D: DomTypes>() {
5568 onbeforematch_getterinfo.set(JSJitInfo {
5569 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5570 getter: Some(get_onbeforematch::<D>)
5571 },
5572 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5573 protoID: PrototypeList::ID::Document as u16,
5574 },
5575 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5576 _bitfield_align_1: [],
5577 _bitfield_1: __BindgenBitfieldUnit::new(
5578 new_jsjitinfo_bitfield_1!(
5579 JSJitInfo_OpType::Getter as u8,
5580 JSJitInfo_AliasSet::AliasEverything as u8,
5581 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5582 true,
5583 false,
5584 false,
5585 false,
5586 false,
5587 false,
5588 0,
5589 ).to_ne_bytes()
5590 ),
5591});
5592}
5593static onbeforematch_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5594
5595pub(crate) fn init_onbeforematch_setterinfo<D: DomTypes>() {
5596 onbeforematch_setterinfo.set(JSJitInfo {
5597 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5598 setter: Some(set_onbeforematch::<D>)
5599 },
5600 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5601 protoID: PrototypeList::ID::Document as u16,
5602 },
5603 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5604 _bitfield_align_1: [],
5605 _bitfield_1: __BindgenBitfieldUnit::new(
5606 new_jsjitinfo_bitfield_1!(
5607 JSJitInfo_OpType::Setter as u8,
5608 JSJitInfo_AliasSet::AliasEverything as u8,
5609 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5610 false,
5611 false,
5612 false,
5613 false,
5614 false,
5615 false,
5616 0,
5617 ).to_ne_bytes()
5618 ),
5619});
5620}
5621unsafe extern "C" fn get_onbeforetoggle<D: DomTypes>
5622(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5623 let mut result = false;
5624 wrap_panic(&mut || result = (|| {
5625 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5626 let this = &*(this as *const D::Document);
5627 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnbeforetoggle();
5628
5629 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5630 return true;
5631 })());
5632 result
5633}
5634
5635unsafe extern "C" fn set_onbeforetoggle<D: DomTypes>
5636(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5637 let mut result = false;
5638 wrap_panic(&mut || result = {
5639 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5640 let this = &*(this as *const D::Document);
5641 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5642 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5643 } else {
5644 None
5645 };
5646 let result: () = this.SetOnbeforetoggle(arg0);
5647
5648 true
5649 });
5650 result
5651}
5652
5653
5654static onbeforetoggle_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5655
5656pub(crate) fn init_onbeforetoggle_getterinfo<D: DomTypes>() {
5657 onbeforetoggle_getterinfo.set(JSJitInfo {
5658 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5659 getter: Some(get_onbeforetoggle::<D>)
5660 },
5661 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5662 protoID: PrototypeList::ID::Document as u16,
5663 },
5664 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5665 _bitfield_align_1: [],
5666 _bitfield_1: __BindgenBitfieldUnit::new(
5667 new_jsjitinfo_bitfield_1!(
5668 JSJitInfo_OpType::Getter as u8,
5669 JSJitInfo_AliasSet::AliasEverything as u8,
5670 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5671 true,
5672 false,
5673 false,
5674 false,
5675 false,
5676 false,
5677 0,
5678 ).to_ne_bytes()
5679 ),
5680});
5681}
5682static onbeforetoggle_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5683
5684pub(crate) fn init_onbeforetoggle_setterinfo<D: DomTypes>() {
5685 onbeforetoggle_setterinfo.set(JSJitInfo {
5686 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5687 setter: Some(set_onbeforetoggle::<D>)
5688 },
5689 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5690 protoID: PrototypeList::ID::Document as u16,
5691 },
5692 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5693 _bitfield_align_1: [],
5694 _bitfield_1: __BindgenBitfieldUnit::new(
5695 new_jsjitinfo_bitfield_1!(
5696 JSJitInfo_OpType::Setter as u8,
5697 JSJitInfo_AliasSet::AliasEverything as u8,
5698 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5699 false,
5700 false,
5701 false,
5702 false,
5703 false,
5704 false,
5705 0,
5706 ).to_ne_bytes()
5707 ),
5708});
5709}
5710unsafe extern "C" fn get_onblur<D: DomTypes>
5711(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5712 let mut result = false;
5713 wrap_panic(&mut || result = (|| {
5714 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5715 let this = &*(this as *const D::Document);
5716 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnblur();
5717
5718 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5719 return true;
5720 })());
5721 result
5722}
5723
5724unsafe extern "C" fn set_onblur<D: DomTypes>
5725(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5726 let mut result = false;
5727 wrap_panic(&mut || result = {
5728 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5729 let this = &*(this as *const D::Document);
5730 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5731 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5732 } else {
5733 None
5734 };
5735 let result: () = this.SetOnblur(arg0);
5736
5737 true
5738 });
5739 result
5740}
5741
5742
5743static onblur_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5744
5745pub(crate) fn init_onblur_getterinfo<D: DomTypes>() {
5746 onblur_getterinfo.set(JSJitInfo {
5747 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5748 getter: Some(get_onblur::<D>)
5749 },
5750 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5751 protoID: PrototypeList::ID::Document as u16,
5752 },
5753 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5754 _bitfield_align_1: [],
5755 _bitfield_1: __BindgenBitfieldUnit::new(
5756 new_jsjitinfo_bitfield_1!(
5757 JSJitInfo_OpType::Getter as u8,
5758 JSJitInfo_AliasSet::AliasEverything as u8,
5759 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5760 true,
5761 false,
5762 false,
5763 false,
5764 false,
5765 false,
5766 0,
5767 ).to_ne_bytes()
5768 ),
5769});
5770}
5771static onblur_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5772
5773pub(crate) fn init_onblur_setterinfo<D: DomTypes>() {
5774 onblur_setterinfo.set(JSJitInfo {
5775 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5776 setter: Some(set_onblur::<D>)
5777 },
5778 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5779 protoID: PrototypeList::ID::Document as u16,
5780 },
5781 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5782 _bitfield_align_1: [],
5783 _bitfield_1: __BindgenBitfieldUnit::new(
5784 new_jsjitinfo_bitfield_1!(
5785 JSJitInfo_OpType::Setter as u8,
5786 JSJitInfo_AliasSet::AliasEverything as u8,
5787 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5788 false,
5789 false,
5790 false,
5791 false,
5792 false,
5793 false,
5794 0,
5795 ).to_ne_bytes()
5796 ),
5797});
5798}
5799unsafe extern "C" fn get_oncancel<D: DomTypes>
5800(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5801 let mut result = false;
5802 wrap_panic(&mut || result = (|| {
5803 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5804 let this = &*(this as *const D::Document);
5805 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncancel();
5806
5807 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5808 return true;
5809 })());
5810 result
5811}
5812
5813unsafe extern "C" fn set_oncancel<D: DomTypes>
5814(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5815 let mut result = false;
5816 wrap_panic(&mut || result = {
5817 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5818 let this = &*(this as *const D::Document);
5819 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5820 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5821 } else {
5822 None
5823 };
5824 let result: () = this.SetOncancel(arg0);
5825
5826 true
5827 });
5828 result
5829}
5830
5831
5832static oncancel_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5833
5834pub(crate) fn init_oncancel_getterinfo<D: DomTypes>() {
5835 oncancel_getterinfo.set(JSJitInfo {
5836 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5837 getter: Some(get_oncancel::<D>)
5838 },
5839 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5840 protoID: PrototypeList::ID::Document as u16,
5841 },
5842 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5843 _bitfield_align_1: [],
5844 _bitfield_1: __BindgenBitfieldUnit::new(
5845 new_jsjitinfo_bitfield_1!(
5846 JSJitInfo_OpType::Getter as u8,
5847 JSJitInfo_AliasSet::AliasEverything as u8,
5848 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5849 true,
5850 false,
5851 false,
5852 false,
5853 false,
5854 false,
5855 0,
5856 ).to_ne_bytes()
5857 ),
5858});
5859}
5860static oncancel_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5861
5862pub(crate) fn init_oncancel_setterinfo<D: DomTypes>() {
5863 oncancel_setterinfo.set(JSJitInfo {
5864 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5865 setter: Some(set_oncancel::<D>)
5866 },
5867 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5868 protoID: PrototypeList::ID::Document as u16,
5869 },
5870 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5871 _bitfield_align_1: [],
5872 _bitfield_1: __BindgenBitfieldUnit::new(
5873 new_jsjitinfo_bitfield_1!(
5874 JSJitInfo_OpType::Setter as u8,
5875 JSJitInfo_AliasSet::AliasEverything as u8,
5876 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5877 false,
5878 false,
5879 false,
5880 false,
5881 false,
5882 false,
5883 0,
5884 ).to_ne_bytes()
5885 ),
5886});
5887}
5888unsafe extern "C" fn get_oncanplay<D: DomTypes>
5889(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5890 let mut result = false;
5891 wrap_panic(&mut || result = (|| {
5892 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5893 let this = &*(this as *const D::Document);
5894 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncanplay();
5895
5896 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5897 return true;
5898 })());
5899 result
5900}
5901
5902unsafe extern "C" fn set_oncanplay<D: DomTypes>
5903(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5904 let mut result = false;
5905 wrap_panic(&mut || result = {
5906 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5907 let this = &*(this as *const D::Document);
5908 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5909 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5910 } else {
5911 None
5912 };
5913 let result: () = this.SetOncanplay(arg0);
5914
5915 true
5916 });
5917 result
5918}
5919
5920
5921static oncanplay_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5922
5923pub(crate) fn init_oncanplay_getterinfo<D: DomTypes>() {
5924 oncanplay_getterinfo.set(JSJitInfo {
5925 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5926 getter: Some(get_oncanplay::<D>)
5927 },
5928 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5929 protoID: PrototypeList::ID::Document as u16,
5930 },
5931 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5932 _bitfield_align_1: [],
5933 _bitfield_1: __BindgenBitfieldUnit::new(
5934 new_jsjitinfo_bitfield_1!(
5935 JSJitInfo_OpType::Getter as u8,
5936 JSJitInfo_AliasSet::AliasEverything as u8,
5937 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5938 true,
5939 false,
5940 false,
5941 false,
5942 false,
5943 false,
5944 0,
5945 ).to_ne_bytes()
5946 ),
5947});
5948}
5949static oncanplay_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5950
5951pub(crate) fn init_oncanplay_setterinfo<D: DomTypes>() {
5952 oncanplay_setterinfo.set(JSJitInfo {
5953 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5954 setter: Some(set_oncanplay::<D>)
5955 },
5956 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5957 protoID: PrototypeList::ID::Document as u16,
5958 },
5959 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
5960 _bitfield_align_1: [],
5961 _bitfield_1: __BindgenBitfieldUnit::new(
5962 new_jsjitinfo_bitfield_1!(
5963 JSJitInfo_OpType::Setter as u8,
5964 JSJitInfo_AliasSet::AliasEverything as u8,
5965 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5966 false,
5967 false,
5968 false,
5969 false,
5970 false,
5971 false,
5972 0,
5973 ).to_ne_bytes()
5974 ),
5975});
5976}
5977unsafe extern "C" fn get_oncanplaythrough<D: DomTypes>
5978(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5979 let mut result = false;
5980 wrap_panic(&mut || result = (|| {
5981 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5982 let this = &*(this as *const D::Document);
5983 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncanplaythrough();
5984
5985 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5986 return true;
5987 })());
5988 result
5989}
5990
5991unsafe extern "C" fn set_oncanplaythrough<D: DomTypes>
5992(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5993 let mut result = false;
5994 wrap_panic(&mut || result = {
5995 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5996 let this = &*(this as *const D::Document);
5997 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5998 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
5999 } else {
6000 None
6001 };
6002 let result: () = this.SetOncanplaythrough(arg0);
6003
6004 true
6005 });
6006 result
6007}
6008
6009
6010static oncanplaythrough_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6011
6012pub(crate) fn init_oncanplaythrough_getterinfo<D: DomTypes>() {
6013 oncanplaythrough_getterinfo.set(JSJitInfo {
6014 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6015 getter: Some(get_oncanplaythrough::<D>)
6016 },
6017 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6018 protoID: PrototypeList::ID::Document as u16,
6019 },
6020 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6021 _bitfield_align_1: [],
6022 _bitfield_1: __BindgenBitfieldUnit::new(
6023 new_jsjitinfo_bitfield_1!(
6024 JSJitInfo_OpType::Getter as u8,
6025 JSJitInfo_AliasSet::AliasEverything as u8,
6026 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6027 true,
6028 false,
6029 false,
6030 false,
6031 false,
6032 false,
6033 0,
6034 ).to_ne_bytes()
6035 ),
6036});
6037}
6038static oncanplaythrough_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6039
6040pub(crate) fn init_oncanplaythrough_setterinfo<D: DomTypes>() {
6041 oncanplaythrough_setterinfo.set(JSJitInfo {
6042 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6043 setter: Some(set_oncanplaythrough::<D>)
6044 },
6045 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6046 protoID: PrototypeList::ID::Document as u16,
6047 },
6048 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6049 _bitfield_align_1: [],
6050 _bitfield_1: __BindgenBitfieldUnit::new(
6051 new_jsjitinfo_bitfield_1!(
6052 JSJitInfo_OpType::Setter as u8,
6053 JSJitInfo_AliasSet::AliasEverything as u8,
6054 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6055 false,
6056 false,
6057 false,
6058 false,
6059 false,
6060 false,
6061 0,
6062 ).to_ne_bytes()
6063 ),
6064});
6065}
6066unsafe extern "C" fn get_onchange<D: DomTypes>
6067(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6068 let mut result = false;
6069 wrap_panic(&mut || result = (|| {
6070 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6071 let this = &*(this as *const D::Document);
6072 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnchange();
6073
6074 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6075 return true;
6076 })());
6077 result
6078}
6079
6080unsafe extern "C" fn set_onchange<D: DomTypes>
6081(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6082 let mut result = false;
6083 wrap_panic(&mut || result = {
6084 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6085 let this = &*(this as *const D::Document);
6086 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6087 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6088 } else {
6089 None
6090 };
6091 let result: () = this.SetOnchange(arg0);
6092
6093 true
6094 });
6095 result
6096}
6097
6098
6099static onchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6100
6101pub(crate) fn init_onchange_getterinfo<D: DomTypes>() {
6102 onchange_getterinfo.set(JSJitInfo {
6103 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6104 getter: Some(get_onchange::<D>)
6105 },
6106 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6107 protoID: PrototypeList::ID::Document as u16,
6108 },
6109 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6110 _bitfield_align_1: [],
6111 _bitfield_1: __BindgenBitfieldUnit::new(
6112 new_jsjitinfo_bitfield_1!(
6113 JSJitInfo_OpType::Getter as u8,
6114 JSJitInfo_AliasSet::AliasEverything as u8,
6115 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6116 true,
6117 false,
6118 false,
6119 false,
6120 false,
6121 false,
6122 0,
6123 ).to_ne_bytes()
6124 ),
6125});
6126}
6127static onchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6128
6129pub(crate) fn init_onchange_setterinfo<D: DomTypes>() {
6130 onchange_setterinfo.set(JSJitInfo {
6131 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6132 setter: Some(set_onchange::<D>)
6133 },
6134 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6135 protoID: PrototypeList::ID::Document as u16,
6136 },
6137 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6138 _bitfield_align_1: [],
6139 _bitfield_1: __BindgenBitfieldUnit::new(
6140 new_jsjitinfo_bitfield_1!(
6141 JSJitInfo_OpType::Setter as u8,
6142 JSJitInfo_AliasSet::AliasEverything as u8,
6143 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6144 false,
6145 false,
6146 false,
6147 false,
6148 false,
6149 false,
6150 0,
6151 ).to_ne_bytes()
6152 ),
6153});
6154}
6155unsafe extern "C" fn get_onclick<D: DomTypes>
6156(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6157 let mut result = false;
6158 wrap_panic(&mut || result = (|| {
6159 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6160 let this = &*(this as *const D::Document);
6161 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnclick();
6162
6163 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6164 return true;
6165 })());
6166 result
6167}
6168
6169unsafe extern "C" fn set_onclick<D: DomTypes>
6170(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6171 let mut result = false;
6172 wrap_panic(&mut || result = {
6173 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6174 let this = &*(this as *const D::Document);
6175 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6176 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6177 } else {
6178 None
6179 };
6180 let result: () = this.SetOnclick(arg0);
6181
6182 true
6183 });
6184 result
6185}
6186
6187
6188static onclick_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6189
6190pub(crate) fn init_onclick_getterinfo<D: DomTypes>() {
6191 onclick_getterinfo.set(JSJitInfo {
6192 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6193 getter: Some(get_onclick::<D>)
6194 },
6195 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6196 protoID: PrototypeList::ID::Document as u16,
6197 },
6198 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6199 _bitfield_align_1: [],
6200 _bitfield_1: __BindgenBitfieldUnit::new(
6201 new_jsjitinfo_bitfield_1!(
6202 JSJitInfo_OpType::Getter as u8,
6203 JSJitInfo_AliasSet::AliasEverything as u8,
6204 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6205 true,
6206 false,
6207 false,
6208 false,
6209 false,
6210 false,
6211 0,
6212 ).to_ne_bytes()
6213 ),
6214});
6215}
6216static onclick_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6217
6218pub(crate) fn init_onclick_setterinfo<D: DomTypes>() {
6219 onclick_setterinfo.set(JSJitInfo {
6220 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6221 setter: Some(set_onclick::<D>)
6222 },
6223 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6224 protoID: PrototypeList::ID::Document as u16,
6225 },
6226 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6227 _bitfield_align_1: [],
6228 _bitfield_1: __BindgenBitfieldUnit::new(
6229 new_jsjitinfo_bitfield_1!(
6230 JSJitInfo_OpType::Setter as u8,
6231 JSJitInfo_AliasSet::AliasEverything as u8,
6232 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6233 false,
6234 false,
6235 false,
6236 false,
6237 false,
6238 false,
6239 0,
6240 ).to_ne_bytes()
6241 ),
6242});
6243}
6244unsafe extern "C" fn get_onclose<D: DomTypes>
6245(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6246 let mut result = false;
6247 wrap_panic(&mut || result = (|| {
6248 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6249 let this = &*(this as *const D::Document);
6250 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnclose();
6251
6252 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6253 return true;
6254 })());
6255 result
6256}
6257
6258unsafe extern "C" fn set_onclose<D: DomTypes>
6259(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6260 let mut result = false;
6261 wrap_panic(&mut || result = {
6262 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6263 let this = &*(this as *const D::Document);
6264 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6265 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6266 } else {
6267 None
6268 };
6269 let result: () = this.SetOnclose(arg0);
6270
6271 true
6272 });
6273 result
6274}
6275
6276
6277static onclose_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6278
6279pub(crate) fn init_onclose_getterinfo<D: DomTypes>() {
6280 onclose_getterinfo.set(JSJitInfo {
6281 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6282 getter: Some(get_onclose::<D>)
6283 },
6284 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6285 protoID: PrototypeList::ID::Document as u16,
6286 },
6287 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6288 _bitfield_align_1: [],
6289 _bitfield_1: __BindgenBitfieldUnit::new(
6290 new_jsjitinfo_bitfield_1!(
6291 JSJitInfo_OpType::Getter as u8,
6292 JSJitInfo_AliasSet::AliasEverything as u8,
6293 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6294 true,
6295 false,
6296 false,
6297 false,
6298 false,
6299 false,
6300 0,
6301 ).to_ne_bytes()
6302 ),
6303});
6304}
6305static onclose_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6306
6307pub(crate) fn init_onclose_setterinfo<D: DomTypes>() {
6308 onclose_setterinfo.set(JSJitInfo {
6309 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6310 setter: Some(set_onclose::<D>)
6311 },
6312 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6313 protoID: PrototypeList::ID::Document as u16,
6314 },
6315 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6316 _bitfield_align_1: [],
6317 _bitfield_1: __BindgenBitfieldUnit::new(
6318 new_jsjitinfo_bitfield_1!(
6319 JSJitInfo_OpType::Setter as u8,
6320 JSJitInfo_AliasSet::AliasEverything as u8,
6321 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6322 false,
6323 false,
6324 false,
6325 false,
6326 false,
6327 false,
6328 0,
6329 ).to_ne_bytes()
6330 ),
6331});
6332}
6333unsafe extern "C" fn get_oncommand<D: DomTypes>
6334(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6335 let mut result = false;
6336 wrap_panic(&mut || result = (|| {
6337 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6338 let this = &*(this as *const D::Document);
6339 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncommand();
6340
6341 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6342 return true;
6343 })());
6344 result
6345}
6346
6347unsafe extern "C" fn set_oncommand<D: DomTypes>
6348(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6349 let mut result = false;
6350 wrap_panic(&mut || result = {
6351 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6352 let this = &*(this as *const D::Document);
6353 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6354 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6355 } else {
6356 None
6357 };
6358 let result: () = this.SetOncommand(arg0);
6359
6360 true
6361 });
6362 result
6363}
6364
6365
6366static oncommand_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6367
6368pub(crate) fn init_oncommand_getterinfo<D: DomTypes>() {
6369 oncommand_getterinfo.set(JSJitInfo {
6370 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6371 getter: Some(get_oncommand::<D>)
6372 },
6373 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6374 protoID: PrototypeList::ID::Document as u16,
6375 },
6376 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6377 _bitfield_align_1: [],
6378 _bitfield_1: __BindgenBitfieldUnit::new(
6379 new_jsjitinfo_bitfield_1!(
6380 JSJitInfo_OpType::Getter as u8,
6381 JSJitInfo_AliasSet::AliasEverything as u8,
6382 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6383 true,
6384 false,
6385 false,
6386 false,
6387 false,
6388 false,
6389 0,
6390 ).to_ne_bytes()
6391 ),
6392});
6393}
6394static oncommand_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6395
6396pub(crate) fn init_oncommand_setterinfo<D: DomTypes>() {
6397 oncommand_setterinfo.set(JSJitInfo {
6398 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6399 setter: Some(set_oncommand::<D>)
6400 },
6401 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6402 protoID: PrototypeList::ID::Document as u16,
6403 },
6404 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6405 _bitfield_align_1: [],
6406 _bitfield_1: __BindgenBitfieldUnit::new(
6407 new_jsjitinfo_bitfield_1!(
6408 JSJitInfo_OpType::Setter as u8,
6409 JSJitInfo_AliasSet::AliasEverything as u8,
6410 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6411 false,
6412 false,
6413 false,
6414 false,
6415 false,
6416 false,
6417 0,
6418 ).to_ne_bytes()
6419 ),
6420});
6421}
6422unsafe extern "C" fn get_oncontextlost<D: DomTypes>
6423(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6424 let mut result = false;
6425 wrap_panic(&mut || result = (|| {
6426 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6427 let this = &*(this as *const D::Document);
6428 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncontextlost();
6429
6430 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6431 return true;
6432 })());
6433 result
6434}
6435
6436unsafe extern "C" fn set_oncontextlost<D: DomTypes>
6437(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6438 let mut result = false;
6439 wrap_panic(&mut || result = {
6440 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6441 let this = &*(this as *const D::Document);
6442 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6443 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6444 } else {
6445 None
6446 };
6447 let result: () = this.SetOncontextlost(arg0);
6448
6449 true
6450 });
6451 result
6452}
6453
6454
6455static oncontextlost_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6456
6457pub(crate) fn init_oncontextlost_getterinfo<D: DomTypes>() {
6458 oncontextlost_getterinfo.set(JSJitInfo {
6459 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6460 getter: Some(get_oncontextlost::<D>)
6461 },
6462 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6463 protoID: PrototypeList::ID::Document as u16,
6464 },
6465 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6466 _bitfield_align_1: [],
6467 _bitfield_1: __BindgenBitfieldUnit::new(
6468 new_jsjitinfo_bitfield_1!(
6469 JSJitInfo_OpType::Getter as u8,
6470 JSJitInfo_AliasSet::AliasEverything as u8,
6471 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6472 true,
6473 false,
6474 false,
6475 false,
6476 false,
6477 false,
6478 0,
6479 ).to_ne_bytes()
6480 ),
6481});
6482}
6483static oncontextlost_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6484
6485pub(crate) fn init_oncontextlost_setterinfo<D: DomTypes>() {
6486 oncontextlost_setterinfo.set(JSJitInfo {
6487 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6488 setter: Some(set_oncontextlost::<D>)
6489 },
6490 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6491 protoID: PrototypeList::ID::Document as u16,
6492 },
6493 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6494 _bitfield_align_1: [],
6495 _bitfield_1: __BindgenBitfieldUnit::new(
6496 new_jsjitinfo_bitfield_1!(
6497 JSJitInfo_OpType::Setter as u8,
6498 JSJitInfo_AliasSet::AliasEverything as u8,
6499 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6500 false,
6501 false,
6502 false,
6503 false,
6504 false,
6505 false,
6506 0,
6507 ).to_ne_bytes()
6508 ),
6509});
6510}
6511unsafe extern "C" fn get_oncontextmenu<D: DomTypes>
6512(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6513 let mut result = false;
6514 wrap_panic(&mut || result = (|| {
6515 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6516 let this = &*(this as *const D::Document);
6517 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncontextmenu();
6518
6519 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6520 return true;
6521 })());
6522 result
6523}
6524
6525unsafe extern "C" fn set_oncontextmenu<D: DomTypes>
6526(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6527 let mut result = false;
6528 wrap_panic(&mut || result = {
6529 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6530 let this = &*(this as *const D::Document);
6531 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6532 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6533 } else {
6534 None
6535 };
6536 let result: () = this.SetOncontextmenu(arg0);
6537
6538 true
6539 });
6540 result
6541}
6542
6543
6544static oncontextmenu_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6545
6546pub(crate) fn init_oncontextmenu_getterinfo<D: DomTypes>() {
6547 oncontextmenu_getterinfo.set(JSJitInfo {
6548 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6549 getter: Some(get_oncontextmenu::<D>)
6550 },
6551 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6552 protoID: PrototypeList::ID::Document as u16,
6553 },
6554 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6555 _bitfield_align_1: [],
6556 _bitfield_1: __BindgenBitfieldUnit::new(
6557 new_jsjitinfo_bitfield_1!(
6558 JSJitInfo_OpType::Getter as u8,
6559 JSJitInfo_AliasSet::AliasEverything as u8,
6560 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6561 true,
6562 false,
6563 false,
6564 false,
6565 false,
6566 false,
6567 0,
6568 ).to_ne_bytes()
6569 ),
6570});
6571}
6572static oncontextmenu_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6573
6574pub(crate) fn init_oncontextmenu_setterinfo<D: DomTypes>() {
6575 oncontextmenu_setterinfo.set(JSJitInfo {
6576 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6577 setter: Some(set_oncontextmenu::<D>)
6578 },
6579 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6580 protoID: PrototypeList::ID::Document as u16,
6581 },
6582 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6583 _bitfield_align_1: [],
6584 _bitfield_1: __BindgenBitfieldUnit::new(
6585 new_jsjitinfo_bitfield_1!(
6586 JSJitInfo_OpType::Setter as u8,
6587 JSJitInfo_AliasSet::AliasEverything as u8,
6588 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6589 false,
6590 false,
6591 false,
6592 false,
6593 false,
6594 false,
6595 0,
6596 ).to_ne_bytes()
6597 ),
6598});
6599}
6600unsafe extern "C" fn get_oncontextrestored<D: DomTypes>
6601(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6602 let mut result = false;
6603 wrap_panic(&mut || result = (|| {
6604 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6605 let this = &*(this as *const D::Document);
6606 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncontextrestored();
6607
6608 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6609 return true;
6610 })());
6611 result
6612}
6613
6614unsafe extern "C" fn set_oncontextrestored<D: DomTypes>
6615(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6616 let mut result = false;
6617 wrap_panic(&mut || result = {
6618 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6619 let this = &*(this as *const D::Document);
6620 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6621 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6622 } else {
6623 None
6624 };
6625 let result: () = this.SetOncontextrestored(arg0);
6626
6627 true
6628 });
6629 result
6630}
6631
6632
6633static oncontextrestored_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6634
6635pub(crate) fn init_oncontextrestored_getterinfo<D: DomTypes>() {
6636 oncontextrestored_getterinfo.set(JSJitInfo {
6637 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6638 getter: Some(get_oncontextrestored::<D>)
6639 },
6640 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6641 protoID: PrototypeList::ID::Document as u16,
6642 },
6643 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6644 _bitfield_align_1: [],
6645 _bitfield_1: __BindgenBitfieldUnit::new(
6646 new_jsjitinfo_bitfield_1!(
6647 JSJitInfo_OpType::Getter as u8,
6648 JSJitInfo_AliasSet::AliasEverything as u8,
6649 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6650 true,
6651 false,
6652 false,
6653 false,
6654 false,
6655 false,
6656 0,
6657 ).to_ne_bytes()
6658 ),
6659});
6660}
6661static oncontextrestored_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6662
6663pub(crate) fn init_oncontextrestored_setterinfo<D: DomTypes>() {
6664 oncontextrestored_setterinfo.set(JSJitInfo {
6665 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6666 setter: Some(set_oncontextrestored::<D>)
6667 },
6668 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6669 protoID: PrototypeList::ID::Document as u16,
6670 },
6671 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6672 _bitfield_align_1: [],
6673 _bitfield_1: __BindgenBitfieldUnit::new(
6674 new_jsjitinfo_bitfield_1!(
6675 JSJitInfo_OpType::Setter as u8,
6676 JSJitInfo_AliasSet::AliasEverything as u8,
6677 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6678 false,
6679 false,
6680 false,
6681 false,
6682 false,
6683 false,
6684 0,
6685 ).to_ne_bytes()
6686 ),
6687});
6688}
6689unsafe extern "C" fn get_oncopy<D: DomTypes>
6690(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6691 let mut result = false;
6692 wrap_panic(&mut || result = (|| {
6693 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6694 let this = &*(this as *const D::Document);
6695 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncopy();
6696
6697 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6698 return true;
6699 })());
6700 result
6701}
6702
6703unsafe extern "C" fn set_oncopy<D: DomTypes>
6704(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6705 let mut result = false;
6706 wrap_panic(&mut || result = {
6707 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6708 let this = &*(this as *const D::Document);
6709 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6710 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6711 } else {
6712 None
6713 };
6714 let result: () = this.SetOncopy(arg0);
6715
6716 true
6717 });
6718 result
6719}
6720
6721
6722static oncopy_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6723
6724pub(crate) fn init_oncopy_getterinfo<D: DomTypes>() {
6725 oncopy_getterinfo.set(JSJitInfo {
6726 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6727 getter: Some(get_oncopy::<D>)
6728 },
6729 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6730 protoID: PrototypeList::ID::Document as u16,
6731 },
6732 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6733 _bitfield_align_1: [],
6734 _bitfield_1: __BindgenBitfieldUnit::new(
6735 new_jsjitinfo_bitfield_1!(
6736 JSJitInfo_OpType::Getter as u8,
6737 JSJitInfo_AliasSet::AliasEverything as u8,
6738 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6739 true,
6740 false,
6741 false,
6742 false,
6743 false,
6744 false,
6745 0,
6746 ).to_ne_bytes()
6747 ),
6748});
6749}
6750static oncopy_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6751
6752pub(crate) fn init_oncopy_setterinfo<D: DomTypes>() {
6753 oncopy_setterinfo.set(JSJitInfo {
6754 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6755 setter: Some(set_oncopy::<D>)
6756 },
6757 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6758 protoID: PrototypeList::ID::Document as u16,
6759 },
6760 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6761 _bitfield_align_1: [],
6762 _bitfield_1: __BindgenBitfieldUnit::new(
6763 new_jsjitinfo_bitfield_1!(
6764 JSJitInfo_OpType::Setter as u8,
6765 JSJitInfo_AliasSet::AliasEverything as u8,
6766 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6767 false,
6768 false,
6769 false,
6770 false,
6771 false,
6772 false,
6773 0,
6774 ).to_ne_bytes()
6775 ),
6776});
6777}
6778unsafe extern "C" fn get_oncuechange<D: DomTypes>
6779(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6780 let mut result = false;
6781 wrap_panic(&mut || result = (|| {
6782 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6783 let this = &*(this as *const D::Document);
6784 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncuechange();
6785
6786 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6787 return true;
6788 })());
6789 result
6790}
6791
6792unsafe extern "C" fn set_oncuechange<D: DomTypes>
6793(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6794 let mut result = false;
6795 wrap_panic(&mut || result = {
6796 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6797 let this = &*(this as *const D::Document);
6798 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6799 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6800 } else {
6801 None
6802 };
6803 let result: () = this.SetOncuechange(arg0);
6804
6805 true
6806 });
6807 result
6808}
6809
6810
6811static oncuechange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6812
6813pub(crate) fn init_oncuechange_getterinfo<D: DomTypes>() {
6814 oncuechange_getterinfo.set(JSJitInfo {
6815 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6816 getter: Some(get_oncuechange::<D>)
6817 },
6818 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6819 protoID: PrototypeList::ID::Document as u16,
6820 },
6821 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6822 _bitfield_align_1: [],
6823 _bitfield_1: __BindgenBitfieldUnit::new(
6824 new_jsjitinfo_bitfield_1!(
6825 JSJitInfo_OpType::Getter as u8,
6826 JSJitInfo_AliasSet::AliasEverything as u8,
6827 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6828 true,
6829 false,
6830 false,
6831 false,
6832 false,
6833 false,
6834 0,
6835 ).to_ne_bytes()
6836 ),
6837});
6838}
6839static oncuechange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6840
6841pub(crate) fn init_oncuechange_setterinfo<D: DomTypes>() {
6842 oncuechange_setterinfo.set(JSJitInfo {
6843 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6844 setter: Some(set_oncuechange::<D>)
6845 },
6846 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6847 protoID: PrototypeList::ID::Document as u16,
6848 },
6849 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6850 _bitfield_align_1: [],
6851 _bitfield_1: __BindgenBitfieldUnit::new(
6852 new_jsjitinfo_bitfield_1!(
6853 JSJitInfo_OpType::Setter as u8,
6854 JSJitInfo_AliasSet::AliasEverything as u8,
6855 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6856 false,
6857 false,
6858 false,
6859 false,
6860 false,
6861 false,
6862 0,
6863 ).to_ne_bytes()
6864 ),
6865});
6866}
6867unsafe extern "C" fn get_oncut<D: DomTypes>
6868(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6869 let mut result = false;
6870 wrap_panic(&mut || result = (|| {
6871 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6872 let this = &*(this as *const D::Document);
6873 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOncut();
6874
6875 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6876 return true;
6877 })());
6878 result
6879}
6880
6881unsafe extern "C" fn set_oncut<D: DomTypes>
6882(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6883 let mut result = false;
6884 wrap_panic(&mut || result = {
6885 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6886 let this = &*(this as *const D::Document);
6887 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6888 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6889 } else {
6890 None
6891 };
6892 let result: () = this.SetOncut(arg0);
6893
6894 true
6895 });
6896 result
6897}
6898
6899
6900static oncut_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6901
6902pub(crate) fn init_oncut_getterinfo<D: DomTypes>() {
6903 oncut_getterinfo.set(JSJitInfo {
6904 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6905 getter: Some(get_oncut::<D>)
6906 },
6907 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6908 protoID: PrototypeList::ID::Document as u16,
6909 },
6910 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6911 _bitfield_align_1: [],
6912 _bitfield_1: __BindgenBitfieldUnit::new(
6913 new_jsjitinfo_bitfield_1!(
6914 JSJitInfo_OpType::Getter as u8,
6915 JSJitInfo_AliasSet::AliasEverything as u8,
6916 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6917 true,
6918 false,
6919 false,
6920 false,
6921 false,
6922 false,
6923 0,
6924 ).to_ne_bytes()
6925 ),
6926});
6927}
6928static oncut_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6929
6930pub(crate) fn init_oncut_setterinfo<D: DomTypes>() {
6931 oncut_setterinfo.set(JSJitInfo {
6932 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6933 setter: Some(set_oncut::<D>)
6934 },
6935 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6936 protoID: PrototypeList::ID::Document as u16,
6937 },
6938 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
6939 _bitfield_align_1: [],
6940 _bitfield_1: __BindgenBitfieldUnit::new(
6941 new_jsjitinfo_bitfield_1!(
6942 JSJitInfo_OpType::Setter as u8,
6943 JSJitInfo_AliasSet::AliasEverything as u8,
6944 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6945 false,
6946 false,
6947 false,
6948 false,
6949 false,
6950 false,
6951 0,
6952 ).to_ne_bytes()
6953 ),
6954});
6955}
6956unsafe extern "C" fn get_ondblclick<D: DomTypes>
6957(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6958 let mut result = false;
6959 wrap_panic(&mut || result = (|| {
6960 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6961 let this = &*(this as *const D::Document);
6962 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndblclick();
6963
6964 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6965 return true;
6966 })());
6967 result
6968}
6969
6970unsafe extern "C" fn set_ondblclick<D: DomTypes>
6971(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6972 let mut result = false;
6973 wrap_panic(&mut || result = {
6974 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6975 let this = &*(this as *const D::Document);
6976 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6977 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
6978 } else {
6979 None
6980 };
6981 let result: () = this.SetOndblclick(arg0);
6982
6983 true
6984 });
6985 result
6986}
6987
6988
6989static ondblclick_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6990
6991pub(crate) fn init_ondblclick_getterinfo<D: DomTypes>() {
6992 ondblclick_getterinfo.set(JSJitInfo {
6993 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6994 getter: Some(get_ondblclick::<D>)
6995 },
6996 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6997 protoID: PrototypeList::ID::Document as u16,
6998 },
6999 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7000 _bitfield_align_1: [],
7001 _bitfield_1: __BindgenBitfieldUnit::new(
7002 new_jsjitinfo_bitfield_1!(
7003 JSJitInfo_OpType::Getter as u8,
7004 JSJitInfo_AliasSet::AliasEverything as u8,
7005 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7006 true,
7007 false,
7008 false,
7009 false,
7010 false,
7011 false,
7012 0,
7013 ).to_ne_bytes()
7014 ),
7015});
7016}
7017static ondblclick_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7018
7019pub(crate) fn init_ondblclick_setterinfo<D: DomTypes>() {
7020 ondblclick_setterinfo.set(JSJitInfo {
7021 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7022 setter: Some(set_ondblclick::<D>)
7023 },
7024 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7025 protoID: PrototypeList::ID::Document as u16,
7026 },
7027 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7028 _bitfield_align_1: [],
7029 _bitfield_1: __BindgenBitfieldUnit::new(
7030 new_jsjitinfo_bitfield_1!(
7031 JSJitInfo_OpType::Setter as u8,
7032 JSJitInfo_AliasSet::AliasEverything as u8,
7033 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7034 false,
7035 false,
7036 false,
7037 false,
7038 false,
7039 false,
7040 0,
7041 ).to_ne_bytes()
7042 ),
7043});
7044}
7045unsafe extern "C" fn get_ondrag<D: DomTypes>
7046(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7047 let mut result = false;
7048 wrap_panic(&mut || result = (|| {
7049 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7050 let this = &*(this as *const D::Document);
7051 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndrag();
7052
7053 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7054 return true;
7055 })());
7056 result
7057}
7058
7059unsafe extern "C" fn set_ondrag<D: DomTypes>
7060(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7061 let mut result = false;
7062 wrap_panic(&mut || result = {
7063 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7064 let this = &*(this as *const D::Document);
7065 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7066 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7067 } else {
7068 None
7069 };
7070 let result: () = this.SetOndrag(arg0);
7071
7072 true
7073 });
7074 result
7075}
7076
7077
7078static ondrag_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7079
7080pub(crate) fn init_ondrag_getterinfo<D: DomTypes>() {
7081 ondrag_getterinfo.set(JSJitInfo {
7082 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7083 getter: Some(get_ondrag::<D>)
7084 },
7085 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7086 protoID: PrototypeList::ID::Document as u16,
7087 },
7088 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7089 _bitfield_align_1: [],
7090 _bitfield_1: __BindgenBitfieldUnit::new(
7091 new_jsjitinfo_bitfield_1!(
7092 JSJitInfo_OpType::Getter as u8,
7093 JSJitInfo_AliasSet::AliasEverything as u8,
7094 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7095 true,
7096 false,
7097 false,
7098 false,
7099 false,
7100 false,
7101 0,
7102 ).to_ne_bytes()
7103 ),
7104});
7105}
7106static ondrag_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7107
7108pub(crate) fn init_ondrag_setterinfo<D: DomTypes>() {
7109 ondrag_setterinfo.set(JSJitInfo {
7110 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7111 setter: Some(set_ondrag::<D>)
7112 },
7113 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7114 protoID: PrototypeList::ID::Document as u16,
7115 },
7116 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7117 _bitfield_align_1: [],
7118 _bitfield_1: __BindgenBitfieldUnit::new(
7119 new_jsjitinfo_bitfield_1!(
7120 JSJitInfo_OpType::Setter as u8,
7121 JSJitInfo_AliasSet::AliasEverything as u8,
7122 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7123 false,
7124 false,
7125 false,
7126 false,
7127 false,
7128 false,
7129 0,
7130 ).to_ne_bytes()
7131 ),
7132});
7133}
7134unsafe extern "C" fn get_ondragend<D: DomTypes>
7135(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7136 let mut result = false;
7137 wrap_panic(&mut || result = (|| {
7138 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7139 let this = &*(this as *const D::Document);
7140 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragend();
7141
7142 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7143 return true;
7144 })());
7145 result
7146}
7147
7148unsafe extern "C" fn set_ondragend<D: DomTypes>
7149(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7150 let mut result = false;
7151 wrap_panic(&mut || result = {
7152 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7153 let this = &*(this as *const D::Document);
7154 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7155 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7156 } else {
7157 None
7158 };
7159 let result: () = this.SetOndragend(arg0);
7160
7161 true
7162 });
7163 result
7164}
7165
7166
7167static ondragend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7168
7169pub(crate) fn init_ondragend_getterinfo<D: DomTypes>() {
7170 ondragend_getterinfo.set(JSJitInfo {
7171 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7172 getter: Some(get_ondragend::<D>)
7173 },
7174 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7175 protoID: PrototypeList::ID::Document as u16,
7176 },
7177 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7178 _bitfield_align_1: [],
7179 _bitfield_1: __BindgenBitfieldUnit::new(
7180 new_jsjitinfo_bitfield_1!(
7181 JSJitInfo_OpType::Getter as u8,
7182 JSJitInfo_AliasSet::AliasEverything as u8,
7183 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7184 true,
7185 false,
7186 false,
7187 false,
7188 false,
7189 false,
7190 0,
7191 ).to_ne_bytes()
7192 ),
7193});
7194}
7195static ondragend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7196
7197pub(crate) fn init_ondragend_setterinfo<D: DomTypes>() {
7198 ondragend_setterinfo.set(JSJitInfo {
7199 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7200 setter: Some(set_ondragend::<D>)
7201 },
7202 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7203 protoID: PrototypeList::ID::Document as u16,
7204 },
7205 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7206 _bitfield_align_1: [],
7207 _bitfield_1: __BindgenBitfieldUnit::new(
7208 new_jsjitinfo_bitfield_1!(
7209 JSJitInfo_OpType::Setter as u8,
7210 JSJitInfo_AliasSet::AliasEverything as u8,
7211 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7212 false,
7213 false,
7214 false,
7215 false,
7216 false,
7217 false,
7218 0,
7219 ).to_ne_bytes()
7220 ),
7221});
7222}
7223unsafe extern "C" fn get_ondragenter<D: DomTypes>
7224(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7225 let mut result = false;
7226 wrap_panic(&mut || result = (|| {
7227 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7228 let this = &*(this as *const D::Document);
7229 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragenter();
7230
7231 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7232 return true;
7233 })());
7234 result
7235}
7236
7237unsafe extern "C" fn set_ondragenter<D: DomTypes>
7238(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7239 let mut result = false;
7240 wrap_panic(&mut || result = {
7241 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7242 let this = &*(this as *const D::Document);
7243 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7244 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7245 } else {
7246 None
7247 };
7248 let result: () = this.SetOndragenter(arg0);
7249
7250 true
7251 });
7252 result
7253}
7254
7255
7256static ondragenter_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7257
7258pub(crate) fn init_ondragenter_getterinfo<D: DomTypes>() {
7259 ondragenter_getterinfo.set(JSJitInfo {
7260 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7261 getter: Some(get_ondragenter::<D>)
7262 },
7263 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7264 protoID: PrototypeList::ID::Document as u16,
7265 },
7266 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7267 _bitfield_align_1: [],
7268 _bitfield_1: __BindgenBitfieldUnit::new(
7269 new_jsjitinfo_bitfield_1!(
7270 JSJitInfo_OpType::Getter as u8,
7271 JSJitInfo_AliasSet::AliasEverything as u8,
7272 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7273 true,
7274 false,
7275 false,
7276 false,
7277 false,
7278 false,
7279 0,
7280 ).to_ne_bytes()
7281 ),
7282});
7283}
7284static ondragenter_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7285
7286pub(crate) fn init_ondragenter_setterinfo<D: DomTypes>() {
7287 ondragenter_setterinfo.set(JSJitInfo {
7288 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7289 setter: Some(set_ondragenter::<D>)
7290 },
7291 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7292 protoID: PrototypeList::ID::Document as u16,
7293 },
7294 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7295 _bitfield_align_1: [],
7296 _bitfield_1: __BindgenBitfieldUnit::new(
7297 new_jsjitinfo_bitfield_1!(
7298 JSJitInfo_OpType::Setter as u8,
7299 JSJitInfo_AliasSet::AliasEverything as u8,
7300 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7301 false,
7302 false,
7303 false,
7304 false,
7305 false,
7306 false,
7307 0,
7308 ).to_ne_bytes()
7309 ),
7310});
7311}
7312unsafe extern "C" fn get_ondragleave<D: DomTypes>
7313(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7314 let mut result = false;
7315 wrap_panic(&mut || result = (|| {
7316 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7317 let this = &*(this as *const D::Document);
7318 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragleave();
7319
7320 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7321 return true;
7322 })());
7323 result
7324}
7325
7326unsafe extern "C" fn set_ondragleave<D: DomTypes>
7327(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7328 let mut result = false;
7329 wrap_panic(&mut || result = {
7330 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7331 let this = &*(this as *const D::Document);
7332 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7333 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7334 } else {
7335 None
7336 };
7337 let result: () = this.SetOndragleave(arg0);
7338
7339 true
7340 });
7341 result
7342}
7343
7344
7345static ondragleave_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7346
7347pub(crate) fn init_ondragleave_getterinfo<D: DomTypes>() {
7348 ondragleave_getterinfo.set(JSJitInfo {
7349 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7350 getter: Some(get_ondragleave::<D>)
7351 },
7352 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7353 protoID: PrototypeList::ID::Document as u16,
7354 },
7355 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7356 _bitfield_align_1: [],
7357 _bitfield_1: __BindgenBitfieldUnit::new(
7358 new_jsjitinfo_bitfield_1!(
7359 JSJitInfo_OpType::Getter as u8,
7360 JSJitInfo_AliasSet::AliasEverything as u8,
7361 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7362 true,
7363 false,
7364 false,
7365 false,
7366 false,
7367 false,
7368 0,
7369 ).to_ne_bytes()
7370 ),
7371});
7372}
7373static ondragleave_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7374
7375pub(crate) fn init_ondragleave_setterinfo<D: DomTypes>() {
7376 ondragleave_setterinfo.set(JSJitInfo {
7377 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7378 setter: Some(set_ondragleave::<D>)
7379 },
7380 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7381 protoID: PrototypeList::ID::Document as u16,
7382 },
7383 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7384 _bitfield_align_1: [],
7385 _bitfield_1: __BindgenBitfieldUnit::new(
7386 new_jsjitinfo_bitfield_1!(
7387 JSJitInfo_OpType::Setter as u8,
7388 JSJitInfo_AliasSet::AliasEverything as u8,
7389 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7390 false,
7391 false,
7392 false,
7393 false,
7394 false,
7395 false,
7396 0,
7397 ).to_ne_bytes()
7398 ),
7399});
7400}
7401unsafe extern "C" fn get_ondragover<D: DomTypes>
7402(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7403 let mut result = false;
7404 wrap_panic(&mut || result = (|| {
7405 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7406 let this = &*(this as *const D::Document);
7407 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragover();
7408
7409 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7410 return true;
7411 })());
7412 result
7413}
7414
7415unsafe extern "C" fn set_ondragover<D: DomTypes>
7416(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7417 let mut result = false;
7418 wrap_panic(&mut || result = {
7419 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7420 let this = &*(this as *const D::Document);
7421 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7422 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7423 } else {
7424 None
7425 };
7426 let result: () = this.SetOndragover(arg0);
7427
7428 true
7429 });
7430 result
7431}
7432
7433
7434static ondragover_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7435
7436pub(crate) fn init_ondragover_getterinfo<D: DomTypes>() {
7437 ondragover_getterinfo.set(JSJitInfo {
7438 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7439 getter: Some(get_ondragover::<D>)
7440 },
7441 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7442 protoID: PrototypeList::ID::Document as u16,
7443 },
7444 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7445 _bitfield_align_1: [],
7446 _bitfield_1: __BindgenBitfieldUnit::new(
7447 new_jsjitinfo_bitfield_1!(
7448 JSJitInfo_OpType::Getter as u8,
7449 JSJitInfo_AliasSet::AliasEverything as u8,
7450 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7451 true,
7452 false,
7453 false,
7454 false,
7455 false,
7456 false,
7457 0,
7458 ).to_ne_bytes()
7459 ),
7460});
7461}
7462static ondragover_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7463
7464pub(crate) fn init_ondragover_setterinfo<D: DomTypes>() {
7465 ondragover_setterinfo.set(JSJitInfo {
7466 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7467 setter: Some(set_ondragover::<D>)
7468 },
7469 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7470 protoID: PrototypeList::ID::Document as u16,
7471 },
7472 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7473 _bitfield_align_1: [],
7474 _bitfield_1: __BindgenBitfieldUnit::new(
7475 new_jsjitinfo_bitfield_1!(
7476 JSJitInfo_OpType::Setter as u8,
7477 JSJitInfo_AliasSet::AliasEverything as u8,
7478 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7479 false,
7480 false,
7481 false,
7482 false,
7483 false,
7484 false,
7485 0,
7486 ).to_ne_bytes()
7487 ),
7488});
7489}
7490unsafe extern "C" fn get_ondragstart<D: DomTypes>
7491(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7492 let mut result = false;
7493 wrap_panic(&mut || result = (|| {
7494 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7495 let this = &*(this as *const D::Document);
7496 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndragstart();
7497
7498 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7499 return true;
7500 })());
7501 result
7502}
7503
7504unsafe extern "C" fn set_ondragstart<D: DomTypes>
7505(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7506 let mut result = false;
7507 wrap_panic(&mut || result = {
7508 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7509 let this = &*(this as *const D::Document);
7510 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7511 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7512 } else {
7513 None
7514 };
7515 let result: () = this.SetOndragstart(arg0);
7516
7517 true
7518 });
7519 result
7520}
7521
7522
7523static ondragstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7524
7525pub(crate) fn init_ondragstart_getterinfo<D: DomTypes>() {
7526 ondragstart_getterinfo.set(JSJitInfo {
7527 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7528 getter: Some(get_ondragstart::<D>)
7529 },
7530 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7531 protoID: PrototypeList::ID::Document as u16,
7532 },
7533 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7534 _bitfield_align_1: [],
7535 _bitfield_1: __BindgenBitfieldUnit::new(
7536 new_jsjitinfo_bitfield_1!(
7537 JSJitInfo_OpType::Getter as u8,
7538 JSJitInfo_AliasSet::AliasEverything as u8,
7539 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7540 true,
7541 false,
7542 false,
7543 false,
7544 false,
7545 false,
7546 0,
7547 ).to_ne_bytes()
7548 ),
7549});
7550}
7551static ondragstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7552
7553pub(crate) fn init_ondragstart_setterinfo<D: DomTypes>() {
7554 ondragstart_setterinfo.set(JSJitInfo {
7555 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7556 setter: Some(set_ondragstart::<D>)
7557 },
7558 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7559 protoID: PrototypeList::ID::Document as u16,
7560 },
7561 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7562 _bitfield_align_1: [],
7563 _bitfield_1: __BindgenBitfieldUnit::new(
7564 new_jsjitinfo_bitfield_1!(
7565 JSJitInfo_OpType::Setter as u8,
7566 JSJitInfo_AliasSet::AliasEverything as u8,
7567 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7568 false,
7569 false,
7570 false,
7571 false,
7572 false,
7573 false,
7574 0,
7575 ).to_ne_bytes()
7576 ),
7577});
7578}
7579unsafe extern "C" fn get_ondrop<D: DomTypes>
7580(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7581 let mut result = false;
7582 wrap_panic(&mut || result = (|| {
7583 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7584 let this = &*(this as *const D::Document);
7585 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndrop();
7586
7587 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7588 return true;
7589 })());
7590 result
7591}
7592
7593unsafe extern "C" fn set_ondrop<D: DomTypes>
7594(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7595 let mut result = false;
7596 wrap_panic(&mut || result = {
7597 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7598 let this = &*(this as *const D::Document);
7599 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7600 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7601 } else {
7602 None
7603 };
7604 let result: () = this.SetOndrop(arg0);
7605
7606 true
7607 });
7608 result
7609}
7610
7611
7612static ondrop_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7613
7614pub(crate) fn init_ondrop_getterinfo<D: DomTypes>() {
7615 ondrop_getterinfo.set(JSJitInfo {
7616 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7617 getter: Some(get_ondrop::<D>)
7618 },
7619 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7620 protoID: PrototypeList::ID::Document as u16,
7621 },
7622 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7623 _bitfield_align_1: [],
7624 _bitfield_1: __BindgenBitfieldUnit::new(
7625 new_jsjitinfo_bitfield_1!(
7626 JSJitInfo_OpType::Getter as u8,
7627 JSJitInfo_AliasSet::AliasEverything as u8,
7628 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7629 true,
7630 false,
7631 false,
7632 false,
7633 false,
7634 false,
7635 0,
7636 ).to_ne_bytes()
7637 ),
7638});
7639}
7640static ondrop_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7641
7642pub(crate) fn init_ondrop_setterinfo<D: DomTypes>() {
7643 ondrop_setterinfo.set(JSJitInfo {
7644 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7645 setter: Some(set_ondrop::<D>)
7646 },
7647 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7648 protoID: PrototypeList::ID::Document as u16,
7649 },
7650 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7651 _bitfield_align_1: [],
7652 _bitfield_1: __BindgenBitfieldUnit::new(
7653 new_jsjitinfo_bitfield_1!(
7654 JSJitInfo_OpType::Setter as u8,
7655 JSJitInfo_AliasSet::AliasEverything as u8,
7656 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7657 false,
7658 false,
7659 false,
7660 false,
7661 false,
7662 false,
7663 0,
7664 ).to_ne_bytes()
7665 ),
7666});
7667}
7668unsafe extern "C" fn get_ondurationchange<D: DomTypes>
7669(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7670 let mut result = false;
7671 wrap_panic(&mut || result = (|| {
7672 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7673 let this = &*(this as *const D::Document);
7674 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOndurationchange();
7675
7676 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7677 return true;
7678 })());
7679 result
7680}
7681
7682unsafe extern "C" fn set_ondurationchange<D: DomTypes>
7683(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7684 let mut result = false;
7685 wrap_panic(&mut || result = {
7686 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7687 let this = &*(this as *const D::Document);
7688 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7689 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7690 } else {
7691 None
7692 };
7693 let result: () = this.SetOndurationchange(arg0);
7694
7695 true
7696 });
7697 result
7698}
7699
7700
7701static ondurationchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7702
7703pub(crate) fn init_ondurationchange_getterinfo<D: DomTypes>() {
7704 ondurationchange_getterinfo.set(JSJitInfo {
7705 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7706 getter: Some(get_ondurationchange::<D>)
7707 },
7708 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7709 protoID: PrototypeList::ID::Document as u16,
7710 },
7711 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7712 _bitfield_align_1: [],
7713 _bitfield_1: __BindgenBitfieldUnit::new(
7714 new_jsjitinfo_bitfield_1!(
7715 JSJitInfo_OpType::Getter as u8,
7716 JSJitInfo_AliasSet::AliasEverything as u8,
7717 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7718 true,
7719 false,
7720 false,
7721 false,
7722 false,
7723 false,
7724 0,
7725 ).to_ne_bytes()
7726 ),
7727});
7728}
7729static ondurationchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7730
7731pub(crate) fn init_ondurationchange_setterinfo<D: DomTypes>() {
7732 ondurationchange_setterinfo.set(JSJitInfo {
7733 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7734 setter: Some(set_ondurationchange::<D>)
7735 },
7736 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7737 protoID: PrototypeList::ID::Document as u16,
7738 },
7739 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7740 _bitfield_align_1: [],
7741 _bitfield_1: __BindgenBitfieldUnit::new(
7742 new_jsjitinfo_bitfield_1!(
7743 JSJitInfo_OpType::Setter as u8,
7744 JSJitInfo_AliasSet::AliasEverything as u8,
7745 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7746 false,
7747 false,
7748 false,
7749 false,
7750 false,
7751 false,
7752 0,
7753 ).to_ne_bytes()
7754 ),
7755});
7756}
7757unsafe extern "C" fn get_onemptied<D: DomTypes>
7758(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7759 let mut result = false;
7760 wrap_panic(&mut || result = (|| {
7761 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7762 let this = &*(this as *const D::Document);
7763 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnemptied();
7764
7765 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7766 return true;
7767 })());
7768 result
7769}
7770
7771unsafe extern "C" fn set_onemptied<D: DomTypes>
7772(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7773 let mut result = false;
7774 wrap_panic(&mut || result = {
7775 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7776 let this = &*(this as *const D::Document);
7777 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7778 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7779 } else {
7780 None
7781 };
7782 let result: () = this.SetOnemptied(arg0);
7783
7784 true
7785 });
7786 result
7787}
7788
7789
7790static onemptied_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7791
7792pub(crate) fn init_onemptied_getterinfo<D: DomTypes>() {
7793 onemptied_getterinfo.set(JSJitInfo {
7794 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7795 getter: Some(get_onemptied::<D>)
7796 },
7797 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7798 protoID: PrototypeList::ID::Document as u16,
7799 },
7800 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7801 _bitfield_align_1: [],
7802 _bitfield_1: __BindgenBitfieldUnit::new(
7803 new_jsjitinfo_bitfield_1!(
7804 JSJitInfo_OpType::Getter as u8,
7805 JSJitInfo_AliasSet::AliasEverything as u8,
7806 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7807 true,
7808 false,
7809 false,
7810 false,
7811 false,
7812 false,
7813 0,
7814 ).to_ne_bytes()
7815 ),
7816});
7817}
7818static onemptied_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7819
7820pub(crate) fn init_onemptied_setterinfo<D: DomTypes>() {
7821 onemptied_setterinfo.set(JSJitInfo {
7822 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7823 setter: Some(set_onemptied::<D>)
7824 },
7825 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7826 protoID: PrototypeList::ID::Document as u16,
7827 },
7828 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7829 _bitfield_align_1: [],
7830 _bitfield_1: __BindgenBitfieldUnit::new(
7831 new_jsjitinfo_bitfield_1!(
7832 JSJitInfo_OpType::Setter as u8,
7833 JSJitInfo_AliasSet::AliasEverything as u8,
7834 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7835 false,
7836 false,
7837 false,
7838 false,
7839 false,
7840 false,
7841 0,
7842 ).to_ne_bytes()
7843 ),
7844});
7845}
7846unsafe extern "C" fn get_onended<D: DomTypes>
7847(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7848 let mut result = false;
7849 wrap_panic(&mut || result = (|| {
7850 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7851 let this = &*(this as *const D::Document);
7852 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnended();
7853
7854 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7855 return true;
7856 })());
7857 result
7858}
7859
7860unsafe extern "C" fn set_onended<D: DomTypes>
7861(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7862 let mut result = false;
7863 wrap_panic(&mut || result = {
7864 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7865 let this = &*(this as *const D::Document);
7866 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7867 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7868 } else {
7869 None
7870 };
7871 let result: () = this.SetOnended(arg0);
7872
7873 true
7874 });
7875 result
7876}
7877
7878
7879static onended_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7880
7881pub(crate) fn init_onended_getterinfo<D: DomTypes>() {
7882 onended_getterinfo.set(JSJitInfo {
7883 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7884 getter: Some(get_onended::<D>)
7885 },
7886 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7887 protoID: PrototypeList::ID::Document as u16,
7888 },
7889 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7890 _bitfield_align_1: [],
7891 _bitfield_1: __BindgenBitfieldUnit::new(
7892 new_jsjitinfo_bitfield_1!(
7893 JSJitInfo_OpType::Getter as u8,
7894 JSJitInfo_AliasSet::AliasEverything as u8,
7895 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7896 true,
7897 false,
7898 false,
7899 false,
7900 false,
7901 false,
7902 0,
7903 ).to_ne_bytes()
7904 ),
7905});
7906}
7907static onended_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7908
7909pub(crate) fn init_onended_setterinfo<D: DomTypes>() {
7910 onended_setterinfo.set(JSJitInfo {
7911 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7912 setter: Some(set_onended::<D>)
7913 },
7914 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7915 protoID: PrototypeList::ID::Document as u16,
7916 },
7917 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7918 _bitfield_align_1: [],
7919 _bitfield_1: __BindgenBitfieldUnit::new(
7920 new_jsjitinfo_bitfield_1!(
7921 JSJitInfo_OpType::Setter as u8,
7922 JSJitInfo_AliasSet::AliasEverything as u8,
7923 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7924 false,
7925 false,
7926 false,
7927 false,
7928 false,
7929 false,
7930 0,
7931 ).to_ne_bytes()
7932 ),
7933});
7934}
7935unsafe extern "C" fn get_onerror<D: DomTypes>
7936(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7937 let mut result = false;
7938 wrap_panic(&mut || result = (|| {
7939 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7940 let this = &*(this as *const D::Document);
7941 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::OnErrorEventHandlerNonNull<D>>> = this.GetOnerror();
7942
7943 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7944 return true;
7945 })());
7946 result
7947}
7948
7949unsafe extern "C" fn set_onerror<D: DomTypes>
7950(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7951 let mut result = false;
7952 wrap_panic(&mut || result = {
7953 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7954 let this = &*(this as *const D::Document);
7955 let arg0: Option<Rc<OnErrorEventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7956 Some(OnErrorEventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
7957 } else {
7958 None
7959 };
7960 let result: () = this.SetOnerror(arg0);
7961
7962 true
7963 });
7964 result
7965}
7966
7967
7968static onerror_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7969
7970pub(crate) fn init_onerror_getterinfo<D: DomTypes>() {
7971 onerror_getterinfo.set(JSJitInfo {
7972 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7973 getter: Some(get_onerror::<D>)
7974 },
7975 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7976 protoID: PrototypeList::ID::Document as u16,
7977 },
7978 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
7979 _bitfield_align_1: [],
7980 _bitfield_1: __BindgenBitfieldUnit::new(
7981 new_jsjitinfo_bitfield_1!(
7982 JSJitInfo_OpType::Getter as u8,
7983 JSJitInfo_AliasSet::AliasEverything as u8,
7984 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7985 true,
7986 false,
7987 false,
7988 false,
7989 false,
7990 false,
7991 0,
7992 ).to_ne_bytes()
7993 ),
7994});
7995}
7996static onerror_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7997
7998pub(crate) fn init_onerror_setterinfo<D: DomTypes>() {
7999 onerror_setterinfo.set(JSJitInfo {
8000 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8001 setter: Some(set_onerror::<D>)
8002 },
8003 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8004 protoID: PrototypeList::ID::Document as u16,
8005 },
8006 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8007 _bitfield_align_1: [],
8008 _bitfield_1: __BindgenBitfieldUnit::new(
8009 new_jsjitinfo_bitfield_1!(
8010 JSJitInfo_OpType::Setter as u8,
8011 JSJitInfo_AliasSet::AliasEverything as u8,
8012 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8013 false,
8014 false,
8015 false,
8016 false,
8017 false,
8018 false,
8019 0,
8020 ).to_ne_bytes()
8021 ),
8022});
8023}
8024unsafe extern "C" fn get_onfocus<D: DomTypes>
8025(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8026 let mut result = false;
8027 wrap_panic(&mut || result = (|| {
8028 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8029 let this = &*(this as *const D::Document);
8030 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnfocus();
8031
8032 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8033 return true;
8034 })());
8035 result
8036}
8037
8038unsafe extern "C" fn set_onfocus<D: DomTypes>
8039(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8040 let mut result = false;
8041 wrap_panic(&mut || result = {
8042 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8043 let this = &*(this as *const D::Document);
8044 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8045 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8046 } else {
8047 None
8048 };
8049 let result: () = this.SetOnfocus(arg0);
8050
8051 true
8052 });
8053 result
8054}
8055
8056
8057static onfocus_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8058
8059pub(crate) fn init_onfocus_getterinfo<D: DomTypes>() {
8060 onfocus_getterinfo.set(JSJitInfo {
8061 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8062 getter: Some(get_onfocus::<D>)
8063 },
8064 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8065 protoID: PrototypeList::ID::Document as u16,
8066 },
8067 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8068 _bitfield_align_1: [],
8069 _bitfield_1: __BindgenBitfieldUnit::new(
8070 new_jsjitinfo_bitfield_1!(
8071 JSJitInfo_OpType::Getter as u8,
8072 JSJitInfo_AliasSet::AliasEverything as u8,
8073 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8074 true,
8075 false,
8076 false,
8077 false,
8078 false,
8079 false,
8080 0,
8081 ).to_ne_bytes()
8082 ),
8083});
8084}
8085static onfocus_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8086
8087pub(crate) fn init_onfocus_setterinfo<D: DomTypes>() {
8088 onfocus_setterinfo.set(JSJitInfo {
8089 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8090 setter: Some(set_onfocus::<D>)
8091 },
8092 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8093 protoID: PrototypeList::ID::Document as u16,
8094 },
8095 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8096 _bitfield_align_1: [],
8097 _bitfield_1: __BindgenBitfieldUnit::new(
8098 new_jsjitinfo_bitfield_1!(
8099 JSJitInfo_OpType::Setter as u8,
8100 JSJitInfo_AliasSet::AliasEverything as u8,
8101 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8102 false,
8103 false,
8104 false,
8105 false,
8106 false,
8107 false,
8108 0,
8109 ).to_ne_bytes()
8110 ),
8111});
8112}
8113unsafe extern "C" fn get_onformdata<D: DomTypes>
8114(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8115 let mut result = false;
8116 wrap_panic(&mut || result = (|| {
8117 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8118 let this = &*(this as *const D::Document);
8119 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnformdata();
8120
8121 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8122 return true;
8123 })());
8124 result
8125}
8126
8127unsafe extern "C" fn set_onformdata<D: DomTypes>
8128(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8129 let mut result = false;
8130 wrap_panic(&mut || result = {
8131 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8132 let this = &*(this as *const D::Document);
8133 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8134 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8135 } else {
8136 None
8137 };
8138 let result: () = this.SetOnformdata(arg0);
8139
8140 true
8141 });
8142 result
8143}
8144
8145
8146static onformdata_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8147
8148pub(crate) fn init_onformdata_getterinfo<D: DomTypes>() {
8149 onformdata_getterinfo.set(JSJitInfo {
8150 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8151 getter: Some(get_onformdata::<D>)
8152 },
8153 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8154 protoID: PrototypeList::ID::Document as u16,
8155 },
8156 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8157 _bitfield_align_1: [],
8158 _bitfield_1: __BindgenBitfieldUnit::new(
8159 new_jsjitinfo_bitfield_1!(
8160 JSJitInfo_OpType::Getter as u8,
8161 JSJitInfo_AliasSet::AliasEverything as u8,
8162 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8163 true,
8164 false,
8165 false,
8166 false,
8167 false,
8168 false,
8169 0,
8170 ).to_ne_bytes()
8171 ),
8172});
8173}
8174static onformdata_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8175
8176pub(crate) fn init_onformdata_setterinfo<D: DomTypes>() {
8177 onformdata_setterinfo.set(JSJitInfo {
8178 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8179 setter: Some(set_onformdata::<D>)
8180 },
8181 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8182 protoID: PrototypeList::ID::Document as u16,
8183 },
8184 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8185 _bitfield_align_1: [],
8186 _bitfield_1: __BindgenBitfieldUnit::new(
8187 new_jsjitinfo_bitfield_1!(
8188 JSJitInfo_OpType::Setter as u8,
8189 JSJitInfo_AliasSet::AliasEverything as u8,
8190 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8191 false,
8192 false,
8193 false,
8194 false,
8195 false,
8196 false,
8197 0,
8198 ).to_ne_bytes()
8199 ),
8200});
8201}
8202unsafe extern "C" fn get_oninput<D: DomTypes>
8203(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8204 let mut result = false;
8205 wrap_panic(&mut || result = (|| {
8206 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8207 let this = &*(this as *const D::Document);
8208 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOninput();
8209
8210 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8211 return true;
8212 })());
8213 result
8214}
8215
8216unsafe extern "C" fn set_oninput<D: DomTypes>
8217(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8218 let mut result = false;
8219 wrap_panic(&mut || result = {
8220 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8221 let this = &*(this as *const D::Document);
8222 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8223 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8224 } else {
8225 None
8226 };
8227 let result: () = this.SetOninput(arg0);
8228
8229 true
8230 });
8231 result
8232}
8233
8234
8235static oninput_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8236
8237pub(crate) fn init_oninput_getterinfo<D: DomTypes>() {
8238 oninput_getterinfo.set(JSJitInfo {
8239 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8240 getter: Some(get_oninput::<D>)
8241 },
8242 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8243 protoID: PrototypeList::ID::Document as u16,
8244 },
8245 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8246 _bitfield_align_1: [],
8247 _bitfield_1: __BindgenBitfieldUnit::new(
8248 new_jsjitinfo_bitfield_1!(
8249 JSJitInfo_OpType::Getter as u8,
8250 JSJitInfo_AliasSet::AliasEverything as u8,
8251 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8252 true,
8253 false,
8254 false,
8255 false,
8256 false,
8257 false,
8258 0,
8259 ).to_ne_bytes()
8260 ),
8261});
8262}
8263static oninput_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8264
8265pub(crate) fn init_oninput_setterinfo<D: DomTypes>() {
8266 oninput_setterinfo.set(JSJitInfo {
8267 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8268 setter: Some(set_oninput::<D>)
8269 },
8270 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8271 protoID: PrototypeList::ID::Document as u16,
8272 },
8273 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8274 _bitfield_align_1: [],
8275 _bitfield_1: __BindgenBitfieldUnit::new(
8276 new_jsjitinfo_bitfield_1!(
8277 JSJitInfo_OpType::Setter as u8,
8278 JSJitInfo_AliasSet::AliasEverything as u8,
8279 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8280 false,
8281 false,
8282 false,
8283 false,
8284 false,
8285 false,
8286 0,
8287 ).to_ne_bytes()
8288 ),
8289});
8290}
8291unsafe extern "C" fn get_oninvalid<D: DomTypes>
8292(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8293 let mut result = false;
8294 wrap_panic(&mut || result = (|| {
8295 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8296 let this = &*(this as *const D::Document);
8297 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOninvalid();
8298
8299 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8300 return true;
8301 })());
8302 result
8303}
8304
8305unsafe extern "C" fn set_oninvalid<D: DomTypes>
8306(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8307 let mut result = false;
8308 wrap_panic(&mut || result = {
8309 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8310 let this = &*(this as *const D::Document);
8311 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8312 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8313 } else {
8314 None
8315 };
8316 let result: () = this.SetOninvalid(arg0);
8317
8318 true
8319 });
8320 result
8321}
8322
8323
8324static oninvalid_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8325
8326pub(crate) fn init_oninvalid_getterinfo<D: DomTypes>() {
8327 oninvalid_getterinfo.set(JSJitInfo {
8328 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8329 getter: Some(get_oninvalid::<D>)
8330 },
8331 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8332 protoID: PrototypeList::ID::Document as u16,
8333 },
8334 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8335 _bitfield_align_1: [],
8336 _bitfield_1: __BindgenBitfieldUnit::new(
8337 new_jsjitinfo_bitfield_1!(
8338 JSJitInfo_OpType::Getter as u8,
8339 JSJitInfo_AliasSet::AliasEverything as u8,
8340 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8341 true,
8342 false,
8343 false,
8344 false,
8345 false,
8346 false,
8347 0,
8348 ).to_ne_bytes()
8349 ),
8350});
8351}
8352static oninvalid_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8353
8354pub(crate) fn init_oninvalid_setterinfo<D: DomTypes>() {
8355 oninvalid_setterinfo.set(JSJitInfo {
8356 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8357 setter: Some(set_oninvalid::<D>)
8358 },
8359 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8360 protoID: PrototypeList::ID::Document as u16,
8361 },
8362 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8363 _bitfield_align_1: [],
8364 _bitfield_1: __BindgenBitfieldUnit::new(
8365 new_jsjitinfo_bitfield_1!(
8366 JSJitInfo_OpType::Setter as u8,
8367 JSJitInfo_AliasSet::AliasEverything as u8,
8368 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8369 false,
8370 false,
8371 false,
8372 false,
8373 false,
8374 false,
8375 0,
8376 ).to_ne_bytes()
8377 ),
8378});
8379}
8380unsafe extern "C" fn get_onkeydown<D: DomTypes>
8381(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8382 let mut result = false;
8383 wrap_panic(&mut || result = (|| {
8384 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8385 let this = &*(this as *const D::Document);
8386 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnkeydown();
8387
8388 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8389 return true;
8390 })());
8391 result
8392}
8393
8394unsafe extern "C" fn set_onkeydown<D: DomTypes>
8395(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8396 let mut result = false;
8397 wrap_panic(&mut || result = {
8398 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8399 let this = &*(this as *const D::Document);
8400 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8401 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8402 } else {
8403 None
8404 };
8405 let result: () = this.SetOnkeydown(arg0);
8406
8407 true
8408 });
8409 result
8410}
8411
8412
8413static onkeydown_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8414
8415pub(crate) fn init_onkeydown_getterinfo<D: DomTypes>() {
8416 onkeydown_getterinfo.set(JSJitInfo {
8417 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8418 getter: Some(get_onkeydown::<D>)
8419 },
8420 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8421 protoID: PrototypeList::ID::Document as u16,
8422 },
8423 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8424 _bitfield_align_1: [],
8425 _bitfield_1: __BindgenBitfieldUnit::new(
8426 new_jsjitinfo_bitfield_1!(
8427 JSJitInfo_OpType::Getter as u8,
8428 JSJitInfo_AliasSet::AliasEverything as u8,
8429 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8430 true,
8431 false,
8432 false,
8433 false,
8434 false,
8435 false,
8436 0,
8437 ).to_ne_bytes()
8438 ),
8439});
8440}
8441static onkeydown_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8442
8443pub(crate) fn init_onkeydown_setterinfo<D: DomTypes>() {
8444 onkeydown_setterinfo.set(JSJitInfo {
8445 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8446 setter: Some(set_onkeydown::<D>)
8447 },
8448 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8449 protoID: PrototypeList::ID::Document as u16,
8450 },
8451 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8452 _bitfield_align_1: [],
8453 _bitfield_1: __BindgenBitfieldUnit::new(
8454 new_jsjitinfo_bitfield_1!(
8455 JSJitInfo_OpType::Setter as u8,
8456 JSJitInfo_AliasSet::AliasEverything as u8,
8457 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8458 false,
8459 false,
8460 false,
8461 false,
8462 false,
8463 false,
8464 0,
8465 ).to_ne_bytes()
8466 ),
8467});
8468}
8469unsafe extern "C" fn get_onkeypress<D: DomTypes>
8470(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8471 let mut result = false;
8472 wrap_panic(&mut || result = (|| {
8473 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8474 let this = &*(this as *const D::Document);
8475 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnkeypress();
8476
8477 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8478 return true;
8479 })());
8480 result
8481}
8482
8483unsafe extern "C" fn set_onkeypress<D: DomTypes>
8484(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8485 let mut result = false;
8486 wrap_panic(&mut || result = {
8487 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8488 let this = &*(this as *const D::Document);
8489 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8490 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8491 } else {
8492 None
8493 };
8494 let result: () = this.SetOnkeypress(arg0);
8495
8496 true
8497 });
8498 result
8499}
8500
8501
8502static onkeypress_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8503
8504pub(crate) fn init_onkeypress_getterinfo<D: DomTypes>() {
8505 onkeypress_getterinfo.set(JSJitInfo {
8506 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8507 getter: Some(get_onkeypress::<D>)
8508 },
8509 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8510 protoID: PrototypeList::ID::Document as u16,
8511 },
8512 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8513 _bitfield_align_1: [],
8514 _bitfield_1: __BindgenBitfieldUnit::new(
8515 new_jsjitinfo_bitfield_1!(
8516 JSJitInfo_OpType::Getter as u8,
8517 JSJitInfo_AliasSet::AliasEverything as u8,
8518 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8519 true,
8520 false,
8521 false,
8522 false,
8523 false,
8524 false,
8525 0,
8526 ).to_ne_bytes()
8527 ),
8528});
8529}
8530static onkeypress_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8531
8532pub(crate) fn init_onkeypress_setterinfo<D: DomTypes>() {
8533 onkeypress_setterinfo.set(JSJitInfo {
8534 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8535 setter: Some(set_onkeypress::<D>)
8536 },
8537 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8538 protoID: PrototypeList::ID::Document as u16,
8539 },
8540 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8541 _bitfield_align_1: [],
8542 _bitfield_1: __BindgenBitfieldUnit::new(
8543 new_jsjitinfo_bitfield_1!(
8544 JSJitInfo_OpType::Setter as u8,
8545 JSJitInfo_AliasSet::AliasEverything as u8,
8546 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8547 false,
8548 false,
8549 false,
8550 false,
8551 false,
8552 false,
8553 0,
8554 ).to_ne_bytes()
8555 ),
8556});
8557}
8558unsafe extern "C" fn get_onkeyup<D: DomTypes>
8559(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8560 let mut result = false;
8561 wrap_panic(&mut || result = (|| {
8562 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8563 let this = &*(this as *const D::Document);
8564 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnkeyup();
8565
8566 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8567 return true;
8568 })());
8569 result
8570}
8571
8572unsafe extern "C" fn set_onkeyup<D: DomTypes>
8573(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8574 let mut result = false;
8575 wrap_panic(&mut || result = {
8576 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8577 let this = &*(this as *const D::Document);
8578 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8579 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8580 } else {
8581 None
8582 };
8583 let result: () = this.SetOnkeyup(arg0);
8584
8585 true
8586 });
8587 result
8588}
8589
8590
8591static onkeyup_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8592
8593pub(crate) fn init_onkeyup_getterinfo<D: DomTypes>() {
8594 onkeyup_getterinfo.set(JSJitInfo {
8595 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8596 getter: Some(get_onkeyup::<D>)
8597 },
8598 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8599 protoID: PrototypeList::ID::Document as u16,
8600 },
8601 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8602 _bitfield_align_1: [],
8603 _bitfield_1: __BindgenBitfieldUnit::new(
8604 new_jsjitinfo_bitfield_1!(
8605 JSJitInfo_OpType::Getter as u8,
8606 JSJitInfo_AliasSet::AliasEverything as u8,
8607 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8608 true,
8609 false,
8610 false,
8611 false,
8612 false,
8613 false,
8614 0,
8615 ).to_ne_bytes()
8616 ),
8617});
8618}
8619static onkeyup_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8620
8621pub(crate) fn init_onkeyup_setterinfo<D: DomTypes>() {
8622 onkeyup_setterinfo.set(JSJitInfo {
8623 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8624 setter: Some(set_onkeyup::<D>)
8625 },
8626 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8627 protoID: PrototypeList::ID::Document as u16,
8628 },
8629 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8630 _bitfield_align_1: [],
8631 _bitfield_1: __BindgenBitfieldUnit::new(
8632 new_jsjitinfo_bitfield_1!(
8633 JSJitInfo_OpType::Setter as u8,
8634 JSJitInfo_AliasSet::AliasEverything as u8,
8635 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8636 false,
8637 false,
8638 false,
8639 false,
8640 false,
8641 false,
8642 0,
8643 ).to_ne_bytes()
8644 ),
8645});
8646}
8647unsafe extern "C" fn get_onload<D: DomTypes>
8648(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8649 let mut result = false;
8650 wrap_panic(&mut || result = (|| {
8651 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8652 let this = &*(this as *const D::Document);
8653 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnload();
8654
8655 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8656 return true;
8657 })());
8658 result
8659}
8660
8661unsafe extern "C" fn set_onload<D: DomTypes>
8662(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8663 let mut result = false;
8664 wrap_panic(&mut || result = {
8665 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8666 let this = &*(this as *const D::Document);
8667 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8668 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8669 } else {
8670 None
8671 };
8672 let result: () = this.SetOnload(arg0);
8673
8674 true
8675 });
8676 result
8677}
8678
8679
8680static onload_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8681
8682pub(crate) fn init_onload_getterinfo<D: DomTypes>() {
8683 onload_getterinfo.set(JSJitInfo {
8684 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8685 getter: Some(get_onload::<D>)
8686 },
8687 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8688 protoID: PrototypeList::ID::Document as u16,
8689 },
8690 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8691 _bitfield_align_1: [],
8692 _bitfield_1: __BindgenBitfieldUnit::new(
8693 new_jsjitinfo_bitfield_1!(
8694 JSJitInfo_OpType::Getter as u8,
8695 JSJitInfo_AliasSet::AliasEverything as u8,
8696 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8697 true,
8698 false,
8699 false,
8700 false,
8701 false,
8702 false,
8703 0,
8704 ).to_ne_bytes()
8705 ),
8706});
8707}
8708static onload_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8709
8710pub(crate) fn init_onload_setterinfo<D: DomTypes>() {
8711 onload_setterinfo.set(JSJitInfo {
8712 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8713 setter: Some(set_onload::<D>)
8714 },
8715 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8716 protoID: PrototypeList::ID::Document as u16,
8717 },
8718 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8719 _bitfield_align_1: [],
8720 _bitfield_1: __BindgenBitfieldUnit::new(
8721 new_jsjitinfo_bitfield_1!(
8722 JSJitInfo_OpType::Setter as u8,
8723 JSJitInfo_AliasSet::AliasEverything as u8,
8724 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8725 false,
8726 false,
8727 false,
8728 false,
8729 false,
8730 false,
8731 0,
8732 ).to_ne_bytes()
8733 ),
8734});
8735}
8736unsafe extern "C" fn get_onloadeddata<D: DomTypes>
8737(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8738 let mut result = false;
8739 wrap_panic(&mut || result = (|| {
8740 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8741 let this = &*(this as *const D::Document);
8742 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnloadeddata();
8743
8744 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8745 return true;
8746 })());
8747 result
8748}
8749
8750unsafe extern "C" fn set_onloadeddata<D: DomTypes>
8751(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8752 let mut result = false;
8753 wrap_panic(&mut || result = {
8754 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8755 let this = &*(this as *const D::Document);
8756 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8757 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8758 } else {
8759 None
8760 };
8761 let result: () = this.SetOnloadeddata(arg0);
8762
8763 true
8764 });
8765 result
8766}
8767
8768
8769static onloadeddata_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8770
8771pub(crate) fn init_onloadeddata_getterinfo<D: DomTypes>() {
8772 onloadeddata_getterinfo.set(JSJitInfo {
8773 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8774 getter: Some(get_onloadeddata::<D>)
8775 },
8776 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8777 protoID: PrototypeList::ID::Document as u16,
8778 },
8779 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8780 _bitfield_align_1: [],
8781 _bitfield_1: __BindgenBitfieldUnit::new(
8782 new_jsjitinfo_bitfield_1!(
8783 JSJitInfo_OpType::Getter as u8,
8784 JSJitInfo_AliasSet::AliasEverything as u8,
8785 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8786 true,
8787 false,
8788 false,
8789 false,
8790 false,
8791 false,
8792 0,
8793 ).to_ne_bytes()
8794 ),
8795});
8796}
8797static onloadeddata_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8798
8799pub(crate) fn init_onloadeddata_setterinfo<D: DomTypes>() {
8800 onloadeddata_setterinfo.set(JSJitInfo {
8801 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8802 setter: Some(set_onloadeddata::<D>)
8803 },
8804 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8805 protoID: PrototypeList::ID::Document as u16,
8806 },
8807 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8808 _bitfield_align_1: [],
8809 _bitfield_1: __BindgenBitfieldUnit::new(
8810 new_jsjitinfo_bitfield_1!(
8811 JSJitInfo_OpType::Setter as u8,
8812 JSJitInfo_AliasSet::AliasEverything as u8,
8813 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8814 false,
8815 false,
8816 false,
8817 false,
8818 false,
8819 false,
8820 0,
8821 ).to_ne_bytes()
8822 ),
8823});
8824}
8825unsafe extern "C" fn get_onloadedmetadata<D: DomTypes>
8826(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8827 let mut result = false;
8828 wrap_panic(&mut || result = (|| {
8829 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8830 let this = &*(this as *const D::Document);
8831 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnloadedmetadata();
8832
8833 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8834 return true;
8835 })());
8836 result
8837}
8838
8839unsafe extern "C" fn set_onloadedmetadata<D: DomTypes>
8840(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8841 let mut result = false;
8842 wrap_panic(&mut || result = {
8843 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8844 let this = &*(this as *const D::Document);
8845 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8846 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8847 } else {
8848 None
8849 };
8850 let result: () = this.SetOnloadedmetadata(arg0);
8851
8852 true
8853 });
8854 result
8855}
8856
8857
8858static onloadedmetadata_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8859
8860pub(crate) fn init_onloadedmetadata_getterinfo<D: DomTypes>() {
8861 onloadedmetadata_getterinfo.set(JSJitInfo {
8862 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8863 getter: Some(get_onloadedmetadata::<D>)
8864 },
8865 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8866 protoID: PrototypeList::ID::Document as u16,
8867 },
8868 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8869 _bitfield_align_1: [],
8870 _bitfield_1: __BindgenBitfieldUnit::new(
8871 new_jsjitinfo_bitfield_1!(
8872 JSJitInfo_OpType::Getter as u8,
8873 JSJitInfo_AliasSet::AliasEverything as u8,
8874 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8875 true,
8876 false,
8877 false,
8878 false,
8879 false,
8880 false,
8881 0,
8882 ).to_ne_bytes()
8883 ),
8884});
8885}
8886static onloadedmetadata_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8887
8888pub(crate) fn init_onloadedmetadata_setterinfo<D: DomTypes>() {
8889 onloadedmetadata_setterinfo.set(JSJitInfo {
8890 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8891 setter: Some(set_onloadedmetadata::<D>)
8892 },
8893 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8894 protoID: PrototypeList::ID::Document as u16,
8895 },
8896 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8897 _bitfield_align_1: [],
8898 _bitfield_1: __BindgenBitfieldUnit::new(
8899 new_jsjitinfo_bitfield_1!(
8900 JSJitInfo_OpType::Setter as u8,
8901 JSJitInfo_AliasSet::AliasEverything as u8,
8902 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8903 false,
8904 false,
8905 false,
8906 false,
8907 false,
8908 false,
8909 0,
8910 ).to_ne_bytes()
8911 ),
8912});
8913}
8914unsafe extern "C" fn get_onloadstart<D: DomTypes>
8915(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8916 let mut result = false;
8917 wrap_panic(&mut || result = (|| {
8918 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8919 let this = &*(this as *const D::Document);
8920 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnloadstart();
8921
8922 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8923 return true;
8924 })());
8925 result
8926}
8927
8928unsafe extern "C" fn set_onloadstart<D: DomTypes>
8929(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8930 let mut result = false;
8931 wrap_panic(&mut || result = {
8932 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8933 let this = &*(this as *const D::Document);
8934 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8935 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
8936 } else {
8937 None
8938 };
8939 let result: () = this.SetOnloadstart(arg0);
8940
8941 true
8942 });
8943 result
8944}
8945
8946
8947static onloadstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8948
8949pub(crate) fn init_onloadstart_getterinfo<D: DomTypes>() {
8950 onloadstart_getterinfo.set(JSJitInfo {
8951 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8952 getter: Some(get_onloadstart::<D>)
8953 },
8954 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8955 protoID: PrototypeList::ID::Document as u16,
8956 },
8957 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8958 _bitfield_align_1: [],
8959 _bitfield_1: __BindgenBitfieldUnit::new(
8960 new_jsjitinfo_bitfield_1!(
8961 JSJitInfo_OpType::Getter as u8,
8962 JSJitInfo_AliasSet::AliasEverything as u8,
8963 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
8964 true,
8965 false,
8966 false,
8967 false,
8968 false,
8969 false,
8970 0,
8971 ).to_ne_bytes()
8972 ),
8973});
8974}
8975static onloadstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8976
8977pub(crate) fn init_onloadstart_setterinfo<D: DomTypes>() {
8978 onloadstart_setterinfo.set(JSJitInfo {
8979 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8980 setter: Some(set_onloadstart::<D>)
8981 },
8982 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8983 protoID: PrototypeList::ID::Document as u16,
8984 },
8985 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
8986 _bitfield_align_1: [],
8987 _bitfield_1: __BindgenBitfieldUnit::new(
8988 new_jsjitinfo_bitfield_1!(
8989 JSJitInfo_OpType::Setter as u8,
8990 JSJitInfo_AliasSet::AliasEverything as u8,
8991 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8992 false,
8993 false,
8994 false,
8995 false,
8996 false,
8997 false,
8998 0,
8999 ).to_ne_bytes()
9000 ),
9001});
9002}
9003unsafe extern "C" fn get_onmousedown<D: DomTypes>
9004(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9005 let mut result = false;
9006 wrap_panic(&mut || result = (|| {
9007 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9008 let this = &*(this as *const D::Document);
9009 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmousedown();
9010
9011 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9012 return true;
9013 })());
9014 result
9015}
9016
9017unsafe extern "C" fn set_onmousedown<D: DomTypes>
9018(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9019 let mut result = false;
9020 wrap_panic(&mut || result = {
9021 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9022 let this = &*(this as *const D::Document);
9023 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9024 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9025 } else {
9026 None
9027 };
9028 let result: () = this.SetOnmousedown(arg0);
9029
9030 true
9031 });
9032 result
9033}
9034
9035
9036static onmousedown_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9037
9038pub(crate) fn init_onmousedown_getterinfo<D: DomTypes>() {
9039 onmousedown_getterinfo.set(JSJitInfo {
9040 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9041 getter: Some(get_onmousedown::<D>)
9042 },
9043 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9044 protoID: PrototypeList::ID::Document as u16,
9045 },
9046 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9047 _bitfield_align_1: [],
9048 _bitfield_1: __BindgenBitfieldUnit::new(
9049 new_jsjitinfo_bitfield_1!(
9050 JSJitInfo_OpType::Getter as u8,
9051 JSJitInfo_AliasSet::AliasEverything as u8,
9052 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9053 true,
9054 false,
9055 false,
9056 false,
9057 false,
9058 false,
9059 0,
9060 ).to_ne_bytes()
9061 ),
9062});
9063}
9064static onmousedown_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9065
9066pub(crate) fn init_onmousedown_setterinfo<D: DomTypes>() {
9067 onmousedown_setterinfo.set(JSJitInfo {
9068 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9069 setter: Some(set_onmousedown::<D>)
9070 },
9071 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9072 protoID: PrototypeList::ID::Document as u16,
9073 },
9074 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9075 _bitfield_align_1: [],
9076 _bitfield_1: __BindgenBitfieldUnit::new(
9077 new_jsjitinfo_bitfield_1!(
9078 JSJitInfo_OpType::Setter as u8,
9079 JSJitInfo_AliasSet::AliasEverything as u8,
9080 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9081 false,
9082 false,
9083 false,
9084 false,
9085 false,
9086 false,
9087 0,
9088 ).to_ne_bytes()
9089 ),
9090});
9091}
9092unsafe extern "C" fn get_onmouseenter<D: DomTypes>
9093(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9094 let mut result = false;
9095 wrap_panic(&mut || result = (|| {
9096 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9097 let this = &*(this as *const D::Document);
9098 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseenter();
9099
9100 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9101 return true;
9102 })());
9103 result
9104}
9105
9106unsafe extern "C" fn set_onmouseenter<D: DomTypes>
9107(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9108 let mut result = false;
9109 wrap_panic(&mut || result = {
9110 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9111 let this = &*(this as *const D::Document);
9112 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9113 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9114 } else {
9115 None
9116 };
9117 let result: () = this.SetOnmouseenter(arg0);
9118
9119 true
9120 });
9121 result
9122}
9123
9124
9125static onmouseenter_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9126
9127pub(crate) fn init_onmouseenter_getterinfo<D: DomTypes>() {
9128 onmouseenter_getterinfo.set(JSJitInfo {
9129 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9130 getter: Some(get_onmouseenter::<D>)
9131 },
9132 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9133 protoID: PrototypeList::ID::Document as u16,
9134 },
9135 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9136 _bitfield_align_1: [],
9137 _bitfield_1: __BindgenBitfieldUnit::new(
9138 new_jsjitinfo_bitfield_1!(
9139 JSJitInfo_OpType::Getter as u8,
9140 JSJitInfo_AliasSet::AliasEverything as u8,
9141 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9142 true,
9143 false,
9144 false,
9145 false,
9146 false,
9147 false,
9148 0,
9149 ).to_ne_bytes()
9150 ),
9151});
9152}
9153static onmouseenter_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9154
9155pub(crate) fn init_onmouseenter_setterinfo<D: DomTypes>() {
9156 onmouseenter_setterinfo.set(JSJitInfo {
9157 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9158 setter: Some(set_onmouseenter::<D>)
9159 },
9160 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9161 protoID: PrototypeList::ID::Document as u16,
9162 },
9163 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9164 _bitfield_align_1: [],
9165 _bitfield_1: __BindgenBitfieldUnit::new(
9166 new_jsjitinfo_bitfield_1!(
9167 JSJitInfo_OpType::Setter as u8,
9168 JSJitInfo_AliasSet::AliasEverything as u8,
9169 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9170 false,
9171 false,
9172 false,
9173 false,
9174 false,
9175 false,
9176 0,
9177 ).to_ne_bytes()
9178 ),
9179});
9180}
9181unsafe extern "C" fn get_onmouseleave<D: DomTypes>
9182(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9183 let mut result = false;
9184 wrap_panic(&mut || result = (|| {
9185 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9186 let this = &*(this as *const D::Document);
9187 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseleave();
9188
9189 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9190 return true;
9191 })());
9192 result
9193}
9194
9195unsafe extern "C" fn set_onmouseleave<D: DomTypes>
9196(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9197 let mut result = false;
9198 wrap_panic(&mut || result = {
9199 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9200 let this = &*(this as *const D::Document);
9201 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9202 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9203 } else {
9204 None
9205 };
9206 let result: () = this.SetOnmouseleave(arg0);
9207
9208 true
9209 });
9210 result
9211}
9212
9213
9214static onmouseleave_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9215
9216pub(crate) fn init_onmouseleave_getterinfo<D: DomTypes>() {
9217 onmouseleave_getterinfo.set(JSJitInfo {
9218 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9219 getter: Some(get_onmouseleave::<D>)
9220 },
9221 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9222 protoID: PrototypeList::ID::Document as u16,
9223 },
9224 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9225 _bitfield_align_1: [],
9226 _bitfield_1: __BindgenBitfieldUnit::new(
9227 new_jsjitinfo_bitfield_1!(
9228 JSJitInfo_OpType::Getter as u8,
9229 JSJitInfo_AliasSet::AliasEverything as u8,
9230 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9231 true,
9232 false,
9233 false,
9234 false,
9235 false,
9236 false,
9237 0,
9238 ).to_ne_bytes()
9239 ),
9240});
9241}
9242static onmouseleave_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9243
9244pub(crate) fn init_onmouseleave_setterinfo<D: DomTypes>() {
9245 onmouseleave_setterinfo.set(JSJitInfo {
9246 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9247 setter: Some(set_onmouseleave::<D>)
9248 },
9249 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9250 protoID: PrototypeList::ID::Document as u16,
9251 },
9252 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9253 _bitfield_align_1: [],
9254 _bitfield_1: __BindgenBitfieldUnit::new(
9255 new_jsjitinfo_bitfield_1!(
9256 JSJitInfo_OpType::Setter as u8,
9257 JSJitInfo_AliasSet::AliasEverything as u8,
9258 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9259 false,
9260 false,
9261 false,
9262 false,
9263 false,
9264 false,
9265 0,
9266 ).to_ne_bytes()
9267 ),
9268});
9269}
9270unsafe extern "C" fn get_onmousemove<D: DomTypes>
9271(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9272 let mut result = false;
9273 wrap_panic(&mut || result = (|| {
9274 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9275 let this = &*(this as *const D::Document);
9276 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmousemove();
9277
9278 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9279 return true;
9280 })());
9281 result
9282}
9283
9284unsafe extern "C" fn set_onmousemove<D: DomTypes>
9285(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9286 let mut result = false;
9287 wrap_panic(&mut || result = {
9288 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9289 let this = &*(this as *const D::Document);
9290 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9291 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9292 } else {
9293 None
9294 };
9295 let result: () = this.SetOnmousemove(arg0);
9296
9297 true
9298 });
9299 result
9300}
9301
9302
9303static onmousemove_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9304
9305pub(crate) fn init_onmousemove_getterinfo<D: DomTypes>() {
9306 onmousemove_getterinfo.set(JSJitInfo {
9307 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9308 getter: Some(get_onmousemove::<D>)
9309 },
9310 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9311 protoID: PrototypeList::ID::Document as u16,
9312 },
9313 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9314 _bitfield_align_1: [],
9315 _bitfield_1: __BindgenBitfieldUnit::new(
9316 new_jsjitinfo_bitfield_1!(
9317 JSJitInfo_OpType::Getter as u8,
9318 JSJitInfo_AliasSet::AliasEverything as u8,
9319 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9320 true,
9321 false,
9322 false,
9323 false,
9324 false,
9325 false,
9326 0,
9327 ).to_ne_bytes()
9328 ),
9329});
9330}
9331static onmousemove_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9332
9333pub(crate) fn init_onmousemove_setterinfo<D: DomTypes>() {
9334 onmousemove_setterinfo.set(JSJitInfo {
9335 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9336 setter: Some(set_onmousemove::<D>)
9337 },
9338 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9339 protoID: PrototypeList::ID::Document as u16,
9340 },
9341 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9342 _bitfield_align_1: [],
9343 _bitfield_1: __BindgenBitfieldUnit::new(
9344 new_jsjitinfo_bitfield_1!(
9345 JSJitInfo_OpType::Setter as u8,
9346 JSJitInfo_AliasSet::AliasEverything as u8,
9347 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9348 false,
9349 false,
9350 false,
9351 false,
9352 false,
9353 false,
9354 0,
9355 ).to_ne_bytes()
9356 ),
9357});
9358}
9359unsafe extern "C" fn get_onmouseout<D: DomTypes>
9360(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9361 let mut result = false;
9362 wrap_panic(&mut || result = (|| {
9363 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9364 let this = &*(this as *const D::Document);
9365 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseout();
9366
9367 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9368 return true;
9369 })());
9370 result
9371}
9372
9373unsafe extern "C" fn set_onmouseout<D: DomTypes>
9374(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9375 let mut result = false;
9376 wrap_panic(&mut || result = {
9377 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9378 let this = &*(this as *const D::Document);
9379 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9380 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9381 } else {
9382 None
9383 };
9384 let result: () = this.SetOnmouseout(arg0);
9385
9386 true
9387 });
9388 result
9389}
9390
9391
9392static onmouseout_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9393
9394pub(crate) fn init_onmouseout_getterinfo<D: DomTypes>() {
9395 onmouseout_getterinfo.set(JSJitInfo {
9396 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9397 getter: Some(get_onmouseout::<D>)
9398 },
9399 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9400 protoID: PrototypeList::ID::Document as u16,
9401 },
9402 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9403 _bitfield_align_1: [],
9404 _bitfield_1: __BindgenBitfieldUnit::new(
9405 new_jsjitinfo_bitfield_1!(
9406 JSJitInfo_OpType::Getter as u8,
9407 JSJitInfo_AliasSet::AliasEverything as u8,
9408 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9409 true,
9410 false,
9411 false,
9412 false,
9413 false,
9414 false,
9415 0,
9416 ).to_ne_bytes()
9417 ),
9418});
9419}
9420static onmouseout_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9421
9422pub(crate) fn init_onmouseout_setterinfo<D: DomTypes>() {
9423 onmouseout_setterinfo.set(JSJitInfo {
9424 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9425 setter: Some(set_onmouseout::<D>)
9426 },
9427 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9428 protoID: PrototypeList::ID::Document as u16,
9429 },
9430 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9431 _bitfield_align_1: [],
9432 _bitfield_1: __BindgenBitfieldUnit::new(
9433 new_jsjitinfo_bitfield_1!(
9434 JSJitInfo_OpType::Setter as u8,
9435 JSJitInfo_AliasSet::AliasEverything as u8,
9436 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9437 false,
9438 false,
9439 false,
9440 false,
9441 false,
9442 false,
9443 0,
9444 ).to_ne_bytes()
9445 ),
9446});
9447}
9448unsafe extern "C" fn get_onmouseover<D: DomTypes>
9449(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9450 let mut result = false;
9451 wrap_panic(&mut || result = (|| {
9452 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9453 let this = &*(this as *const D::Document);
9454 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseover();
9455
9456 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9457 return true;
9458 })());
9459 result
9460}
9461
9462unsafe extern "C" fn set_onmouseover<D: DomTypes>
9463(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9464 let mut result = false;
9465 wrap_panic(&mut || result = {
9466 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9467 let this = &*(this as *const D::Document);
9468 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9469 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9470 } else {
9471 None
9472 };
9473 let result: () = this.SetOnmouseover(arg0);
9474
9475 true
9476 });
9477 result
9478}
9479
9480
9481static onmouseover_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9482
9483pub(crate) fn init_onmouseover_getterinfo<D: DomTypes>() {
9484 onmouseover_getterinfo.set(JSJitInfo {
9485 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9486 getter: Some(get_onmouseover::<D>)
9487 },
9488 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9489 protoID: PrototypeList::ID::Document as u16,
9490 },
9491 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9492 _bitfield_align_1: [],
9493 _bitfield_1: __BindgenBitfieldUnit::new(
9494 new_jsjitinfo_bitfield_1!(
9495 JSJitInfo_OpType::Getter as u8,
9496 JSJitInfo_AliasSet::AliasEverything as u8,
9497 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9498 true,
9499 false,
9500 false,
9501 false,
9502 false,
9503 false,
9504 0,
9505 ).to_ne_bytes()
9506 ),
9507});
9508}
9509static onmouseover_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9510
9511pub(crate) fn init_onmouseover_setterinfo<D: DomTypes>() {
9512 onmouseover_setterinfo.set(JSJitInfo {
9513 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9514 setter: Some(set_onmouseover::<D>)
9515 },
9516 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9517 protoID: PrototypeList::ID::Document as u16,
9518 },
9519 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9520 _bitfield_align_1: [],
9521 _bitfield_1: __BindgenBitfieldUnit::new(
9522 new_jsjitinfo_bitfield_1!(
9523 JSJitInfo_OpType::Setter as u8,
9524 JSJitInfo_AliasSet::AliasEverything as u8,
9525 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9526 false,
9527 false,
9528 false,
9529 false,
9530 false,
9531 false,
9532 0,
9533 ).to_ne_bytes()
9534 ),
9535});
9536}
9537unsafe extern "C" fn get_onmouseup<D: DomTypes>
9538(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9539 let mut result = false;
9540 wrap_panic(&mut || result = (|| {
9541 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9542 let this = &*(this as *const D::Document);
9543 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnmouseup();
9544
9545 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9546 return true;
9547 })());
9548 result
9549}
9550
9551unsafe extern "C" fn set_onmouseup<D: DomTypes>
9552(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9553 let mut result = false;
9554 wrap_panic(&mut || result = {
9555 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9556 let this = &*(this as *const D::Document);
9557 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9558 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9559 } else {
9560 None
9561 };
9562 let result: () = this.SetOnmouseup(arg0);
9563
9564 true
9565 });
9566 result
9567}
9568
9569
9570static onmouseup_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9571
9572pub(crate) fn init_onmouseup_getterinfo<D: DomTypes>() {
9573 onmouseup_getterinfo.set(JSJitInfo {
9574 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9575 getter: Some(get_onmouseup::<D>)
9576 },
9577 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9578 protoID: PrototypeList::ID::Document as u16,
9579 },
9580 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9581 _bitfield_align_1: [],
9582 _bitfield_1: __BindgenBitfieldUnit::new(
9583 new_jsjitinfo_bitfield_1!(
9584 JSJitInfo_OpType::Getter as u8,
9585 JSJitInfo_AliasSet::AliasEverything as u8,
9586 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9587 true,
9588 false,
9589 false,
9590 false,
9591 false,
9592 false,
9593 0,
9594 ).to_ne_bytes()
9595 ),
9596});
9597}
9598static onmouseup_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9599
9600pub(crate) fn init_onmouseup_setterinfo<D: DomTypes>() {
9601 onmouseup_setterinfo.set(JSJitInfo {
9602 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9603 setter: Some(set_onmouseup::<D>)
9604 },
9605 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9606 protoID: PrototypeList::ID::Document as u16,
9607 },
9608 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9609 _bitfield_align_1: [],
9610 _bitfield_1: __BindgenBitfieldUnit::new(
9611 new_jsjitinfo_bitfield_1!(
9612 JSJitInfo_OpType::Setter as u8,
9613 JSJitInfo_AliasSet::AliasEverything as u8,
9614 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9615 false,
9616 false,
9617 false,
9618 false,
9619 false,
9620 false,
9621 0,
9622 ).to_ne_bytes()
9623 ),
9624});
9625}
9626unsafe extern "C" fn get_onpaste<D: DomTypes>
9627(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9628 let mut result = false;
9629 wrap_panic(&mut || result = (|| {
9630 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9631 let this = &*(this as *const D::Document);
9632 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnpaste();
9633
9634 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9635 return true;
9636 })());
9637 result
9638}
9639
9640unsafe extern "C" fn set_onpaste<D: DomTypes>
9641(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9642 let mut result = false;
9643 wrap_panic(&mut || result = {
9644 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9645 let this = &*(this as *const D::Document);
9646 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9647 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9648 } else {
9649 None
9650 };
9651 let result: () = this.SetOnpaste(arg0);
9652
9653 true
9654 });
9655 result
9656}
9657
9658
9659static onpaste_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9660
9661pub(crate) fn init_onpaste_getterinfo<D: DomTypes>() {
9662 onpaste_getterinfo.set(JSJitInfo {
9663 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9664 getter: Some(get_onpaste::<D>)
9665 },
9666 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9667 protoID: PrototypeList::ID::Document as u16,
9668 },
9669 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9670 _bitfield_align_1: [],
9671 _bitfield_1: __BindgenBitfieldUnit::new(
9672 new_jsjitinfo_bitfield_1!(
9673 JSJitInfo_OpType::Getter as u8,
9674 JSJitInfo_AliasSet::AliasEverything as u8,
9675 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9676 true,
9677 false,
9678 false,
9679 false,
9680 false,
9681 false,
9682 0,
9683 ).to_ne_bytes()
9684 ),
9685});
9686}
9687static onpaste_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9688
9689pub(crate) fn init_onpaste_setterinfo<D: DomTypes>() {
9690 onpaste_setterinfo.set(JSJitInfo {
9691 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9692 setter: Some(set_onpaste::<D>)
9693 },
9694 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9695 protoID: PrototypeList::ID::Document as u16,
9696 },
9697 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9698 _bitfield_align_1: [],
9699 _bitfield_1: __BindgenBitfieldUnit::new(
9700 new_jsjitinfo_bitfield_1!(
9701 JSJitInfo_OpType::Setter as u8,
9702 JSJitInfo_AliasSet::AliasEverything as u8,
9703 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9704 false,
9705 false,
9706 false,
9707 false,
9708 false,
9709 false,
9710 0,
9711 ).to_ne_bytes()
9712 ),
9713});
9714}
9715unsafe extern "C" fn get_onpause<D: DomTypes>
9716(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9717 let mut result = false;
9718 wrap_panic(&mut || result = (|| {
9719 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9720 let this = &*(this as *const D::Document);
9721 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnpause();
9722
9723 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9724 return true;
9725 })());
9726 result
9727}
9728
9729unsafe extern "C" fn set_onpause<D: DomTypes>
9730(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9731 let mut result = false;
9732 wrap_panic(&mut || result = {
9733 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9734 let this = &*(this as *const D::Document);
9735 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9736 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9737 } else {
9738 None
9739 };
9740 let result: () = this.SetOnpause(arg0);
9741
9742 true
9743 });
9744 result
9745}
9746
9747
9748static onpause_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9749
9750pub(crate) fn init_onpause_getterinfo<D: DomTypes>() {
9751 onpause_getterinfo.set(JSJitInfo {
9752 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9753 getter: Some(get_onpause::<D>)
9754 },
9755 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9756 protoID: PrototypeList::ID::Document as u16,
9757 },
9758 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9759 _bitfield_align_1: [],
9760 _bitfield_1: __BindgenBitfieldUnit::new(
9761 new_jsjitinfo_bitfield_1!(
9762 JSJitInfo_OpType::Getter as u8,
9763 JSJitInfo_AliasSet::AliasEverything as u8,
9764 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9765 true,
9766 false,
9767 false,
9768 false,
9769 false,
9770 false,
9771 0,
9772 ).to_ne_bytes()
9773 ),
9774});
9775}
9776static onpause_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9777
9778pub(crate) fn init_onpause_setterinfo<D: DomTypes>() {
9779 onpause_setterinfo.set(JSJitInfo {
9780 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9781 setter: Some(set_onpause::<D>)
9782 },
9783 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9784 protoID: PrototypeList::ID::Document as u16,
9785 },
9786 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9787 _bitfield_align_1: [],
9788 _bitfield_1: __BindgenBitfieldUnit::new(
9789 new_jsjitinfo_bitfield_1!(
9790 JSJitInfo_OpType::Setter as u8,
9791 JSJitInfo_AliasSet::AliasEverything as u8,
9792 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9793 false,
9794 false,
9795 false,
9796 false,
9797 false,
9798 false,
9799 0,
9800 ).to_ne_bytes()
9801 ),
9802});
9803}
9804unsafe extern "C" fn get_onplay<D: DomTypes>
9805(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9806 let mut result = false;
9807 wrap_panic(&mut || result = (|| {
9808 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9809 let this = &*(this as *const D::Document);
9810 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnplay();
9811
9812 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9813 return true;
9814 })());
9815 result
9816}
9817
9818unsafe extern "C" fn set_onplay<D: DomTypes>
9819(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9820 let mut result = false;
9821 wrap_panic(&mut || result = {
9822 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9823 let this = &*(this as *const D::Document);
9824 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9825 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9826 } else {
9827 None
9828 };
9829 let result: () = this.SetOnplay(arg0);
9830
9831 true
9832 });
9833 result
9834}
9835
9836
9837static onplay_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9838
9839pub(crate) fn init_onplay_getterinfo<D: DomTypes>() {
9840 onplay_getterinfo.set(JSJitInfo {
9841 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9842 getter: Some(get_onplay::<D>)
9843 },
9844 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9845 protoID: PrototypeList::ID::Document as u16,
9846 },
9847 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9848 _bitfield_align_1: [],
9849 _bitfield_1: __BindgenBitfieldUnit::new(
9850 new_jsjitinfo_bitfield_1!(
9851 JSJitInfo_OpType::Getter as u8,
9852 JSJitInfo_AliasSet::AliasEverything as u8,
9853 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9854 true,
9855 false,
9856 false,
9857 false,
9858 false,
9859 false,
9860 0,
9861 ).to_ne_bytes()
9862 ),
9863});
9864}
9865static onplay_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9866
9867pub(crate) fn init_onplay_setterinfo<D: DomTypes>() {
9868 onplay_setterinfo.set(JSJitInfo {
9869 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9870 setter: Some(set_onplay::<D>)
9871 },
9872 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9873 protoID: PrototypeList::ID::Document as u16,
9874 },
9875 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9876 _bitfield_align_1: [],
9877 _bitfield_1: __BindgenBitfieldUnit::new(
9878 new_jsjitinfo_bitfield_1!(
9879 JSJitInfo_OpType::Setter as u8,
9880 JSJitInfo_AliasSet::AliasEverything as u8,
9881 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9882 false,
9883 false,
9884 false,
9885 false,
9886 false,
9887 false,
9888 0,
9889 ).to_ne_bytes()
9890 ),
9891});
9892}
9893unsafe extern "C" fn get_onplaying<D: DomTypes>
9894(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9895 let mut result = false;
9896 wrap_panic(&mut || result = (|| {
9897 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9898 let this = &*(this as *const D::Document);
9899 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnplaying();
9900
9901 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9902 return true;
9903 })());
9904 result
9905}
9906
9907unsafe extern "C" fn set_onplaying<D: DomTypes>
9908(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9909 let mut result = false;
9910 wrap_panic(&mut || result = {
9911 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9912 let this = &*(this as *const D::Document);
9913 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9914 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
9915 } else {
9916 None
9917 };
9918 let result: () = this.SetOnplaying(arg0);
9919
9920 true
9921 });
9922 result
9923}
9924
9925
9926static onplaying_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9927
9928pub(crate) fn init_onplaying_getterinfo<D: DomTypes>() {
9929 onplaying_getterinfo.set(JSJitInfo {
9930 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9931 getter: Some(get_onplaying::<D>)
9932 },
9933 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9934 protoID: PrototypeList::ID::Document as u16,
9935 },
9936 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9937 _bitfield_align_1: [],
9938 _bitfield_1: __BindgenBitfieldUnit::new(
9939 new_jsjitinfo_bitfield_1!(
9940 JSJitInfo_OpType::Getter as u8,
9941 JSJitInfo_AliasSet::AliasEverything as u8,
9942 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9943 true,
9944 false,
9945 false,
9946 false,
9947 false,
9948 false,
9949 0,
9950 ).to_ne_bytes()
9951 ),
9952});
9953}
9954static onplaying_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9955
9956pub(crate) fn init_onplaying_setterinfo<D: DomTypes>() {
9957 onplaying_setterinfo.set(JSJitInfo {
9958 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9959 setter: Some(set_onplaying::<D>)
9960 },
9961 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9962 protoID: PrototypeList::ID::Document as u16,
9963 },
9964 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
9965 _bitfield_align_1: [],
9966 _bitfield_1: __BindgenBitfieldUnit::new(
9967 new_jsjitinfo_bitfield_1!(
9968 JSJitInfo_OpType::Setter as u8,
9969 JSJitInfo_AliasSet::AliasEverything as u8,
9970 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9971 false,
9972 false,
9973 false,
9974 false,
9975 false,
9976 false,
9977 0,
9978 ).to_ne_bytes()
9979 ),
9980});
9981}
9982unsafe extern "C" fn get_onprogress<D: DomTypes>
9983(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
9984 let mut result = false;
9985 wrap_panic(&mut || result = (|| {
9986 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9987 let this = &*(this as *const D::Document);
9988 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnprogress();
9989
9990 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9991 return true;
9992 })());
9993 result
9994}
9995
9996unsafe extern "C" fn set_onprogress<D: DomTypes>
9997(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
9998 let mut result = false;
9999 wrap_panic(&mut || result = {
10000 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10001 let this = &*(this as *const D::Document);
10002 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10003 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10004 } else {
10005 None
10006 };
10007 let result: () = this.SetOnprogress(arg0);
10008
10009 true
10010 });
10011 result
10012}
10013
10014
10015static onprogress_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10016
10017pub(crate) fn init_onprogress_getterinfo<D: DomTypes>() {
10018 onprogress_getterinfo.set(JSJitInfo {
10019 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10020 getter: Some(get_onprogress::<D>)
10021 },
10022 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10023 protoID: PrototypeList::ID::Document as u16,
10024 },
10025 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10026 _bitfield_align_1: [],
10027 _bitfield_1: __BindgenBitfieldUnit::new(
10028 new_jsjitinfo_bitfield_1!(
10029 JSJitInfo_OpType::Getter as u8,
10030 JSJitInfo_AliasSet::AliasEverything as u8,
10031 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10032 true,
10033 false,
10034 false,
10035 false,
10036 false,
10037 false,
10038 0,
10039 ).to_ne_bytes()
10040 ),
10041});
10042}
10043static onprogress_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10044
10045pub(crate) fn init_onprogress_setterinfo<D: DomTypes>() {
10046 onprogress_setterinfo.set(JSJitInfo {
10047 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10048 setter: Some(set_onprogress::<D>)
10049 },
10050 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10051 protoID: PrototypeList::ID::Document as u16,
10052 },
10053 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10054 _bitfield_align_1: [],
10055 _bitfield_1: __BindgenBitfieldUnit::new(
10056 new_jsjitinfo_bitfield_1!(
10057 JSJitInfo_OpType::Setter as u8,
10058 JSJitInfo_AliasSet::AliasEverything as u8,
10059 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10060 false,
10061 false,
10062 false,
10063 false,
10064 false,
10065 false,
10066 0,
10067 ).to_ne_bytes()
10068 ),
10069});
10070}
10071unsafe extern "C" fn get_onratechange<D: DomTypes>
10072(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10073 let mut result = false;
10074 wrap_panic(&mut || result = (|| {
10075 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10076 let this = &*(this as *const D::Document);
10077 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnratechange();
10078
10079 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10080 return true;
10081 })());
10082 result
10083}
10084
10085unsafe extern "C" fn set_onratechange<D: DomTypes>
10086(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10087 let mut result = false;
10088 wrap_panic(&mut || result = {
10089 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10090 let this = &*(this as *const D::Document);
10091 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10092 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10093 } else {
10094 None
10095 };
10096 let result: () = this.SetOnratechange(arg0);
10097
10098 true
10099 });
10100 result
10101}
10102
10103
10104static onratechange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10105
10106pub(crate) fn init_onratechange_getterinfo<D: DomTypes>() {
10107 onratechange_getterinfo.set(JSJitInfo {
10108 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10109 getter: Some(get_onratechange::<D>)
10110 },
10111 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10112 protoID: PrototypeList::ID::Document as u16,
10113 },
10114 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10115 _bitfield_align_1: [],
10116 _bitfield_1: __BindgenBitfieldUnit::new(
10117 new_jsjitinfo_bitfield_1!(
10118 JSJitInfo_OpType::Getter as u8,
10119 JSJitInfo_AliasSet::AliasEverything as u8,
10120 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10121 true,
10122 false,
10123 false,
10124 false,
10125 false,
10126 false,
10127 0,
10128 ).to_ne_bytes()
10129 ),
10130});
10131}
10132static onratechange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10133
10134pub(crate) fn init_onratechange_setterinfo<D: DomTypes>() {
10135 onratechange_setterinfo.set(JSJitInfo {
10136 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10137 setter: Some(set_onratechange::<D>)
10138 },
10139 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10140 protoID: PrototypeList::ID::Document as u16,
10141 },
10142 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10143 _bitfield_align_1: [],
10144 _bitfield_1: __BindgenBitfieldUnit::new(
10145 new_jsjitinfo_bitfield_1!(
10146 JSJitInfo_OpType::Setter as u8,
10147 JSJitInfo_AliasSet::AliasEverything as u8,
10148 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10149 false,
10150 false,
10151 false,
10152 false,
10153 false,
10154 false,
10155 0,
10156 ).to_ne_bytes()
10157 ),
10158});
10159}
10160unsafe extern "C" fn get_onreset<D: DomTypes>
10161(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10162 let mut result = false;
10163 wrap_panic(&mut || result = (|| {
10164 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10165 let this = &*(this as *const D::Document);
10166 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnreset();
10167
10168 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10169 return true;
10170 })());
10171 result
10172}
10173
10174unsafe extern "C" fn set_onreset<D: DomTypes>
10175(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10176 let mut result = false;
10177 wrap_panic(&mut || result = {
10178 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10179 let this = &*(this as *const D::Document);
10180 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10181 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10182 } else {
10183 None
10184 };
10185 let result: () = this.SetOnreset(arg0);
10186
10187 true
10188 });
10189 result
10190}
10191
10192
10193static onreset_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10194
10195pub(crate) fn init_onreset_getterinfo<D: DomTypes>() {
10196 onreset_getterinfo.set(JSJitInfo {
10197 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10198 getter: Some(get_onreset::<D>)
10199 },
10200 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10201 protoID: PrototypeList::ID::Document as u16,
10202 },
10203 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10204 _bitfield_align_1: [],
10205 _bitfield_1: __BindgenBitfieldUnit::new(
10206 new_jsjitinfo_bitfield_1!(
10207 JSJitInfo_OpType::Getter as u8,
10208 JSJitInfo_AliasSet::AliasEverything as u8,
10209 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10210 true,
10211 false,
10212 false,
10213 false,
10214 false,
10215 false,
10216 0,
10217 ).to_ne_bytes()
10218 ),
10219});
10220}
10221static onreset_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10222
10223pub(crate) fn init_onreset_setterinfo<D: DomTypes>() {
10224 onreset_setterinfo.set(JSJitInfo {
10225 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10226 setter: Some(set_onreset::<D>)
10227 },
10228 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10229 protoID: PrototypeList::ID::Document as u16,
10230 },
10231 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10232 _bitfield_align_1: [],
10233 _bitfield_1: __BindgenBitfieldUnit::new(
10234 new_jsjitinfo_bitfield_1!(
10235 JSJitInfo_OpType::Setter as u8,
10236 JSJitInfo_AliasSet::AliasEverything as u8,
10237 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10238 false,
10239 false,
10240 false,
10241 false,
10242 false,
10243 false,
10244 0,
10245 ).to_ne_bytes()
10246 ),
10247});
10248}
10249unsafe extern "C" fn get_onresize<D: DomTypes>
10250(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10251 let mut result = false;
10252 wrap_panic(&mut || result = (|| {
10253 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10254 let this = &*(this as *const D::Document);
10255 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnresize();
10256
10257 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10258 return true;
10259 })());
10260 result
10261}
10262
10263unsafe extern "C" fn set_onresize<D: DomTypes>
10264(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10265 let mut result = false;
10266 wrap_panic(&mut || result = {
10267 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10268 let this = &*(this as *const D::Document);
10269 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10270 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10271 } else {
10272 None
10273 };
10274 let result: () = this.SetOnresize(arg0);
10275
10276 true
10277 });
10278 result
10279}
10280
10281
10282static onresize_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10283
10284pub(crate) fn init_onresize_getterinfo<D: DomTypes>() {
10285 onresize_getterinfo.set(JSJitInfo {
10286 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10287 getter: Some(get_onresize::<D>)
10288 },
10289 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10290 protoID: PrototypeList::ID::Document as u16,
10291 },
10292 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10293 _bitfield_align_1: [],
10294 _bitfield_1: __BindgenBitfieldUnit::new(
10295 new_jsjitinfo_bitfield_1!(
10296 JSJitInfo_OpType::Getter as u8,
10297 JSJitInfo_AliasSet::AliasEverything as u8,
10298 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10299 true,
10300 false,
10301 false,
10302 false,
10303 false,
10304 false,
10305 0,
10306 ).to_ne_bytes()
10307 ),
10308});
10309}
10310static onresize_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10311
10312pub(crate) fn init_onresize_setterinfo<D: DomTypes>() {
10313 onresize_setterinfo.set(JSJitInfo {
10314 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10315 setter: Some(set_onresize::<D>)
10316 },
10317 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10318 protoID: PrototypeList::ID::Document as u16,
10319 },
10320 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10321 _bitfield_align_1: [],
10322 _bitfield_1: __BindgenBitfieldUnit::new(
10323 new_jsjitinfo_bitfield_1!(
10324 JSJitInfo_OpType::Setter as u8,
10325 JSJitInfo_AliasSet::AliasEverything as u8,
10326 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10327 false,
10328 false,
10329 false,
10330 false,
10331 false,
10332 false,
10333 0,
10334 ).to_ne_bytes()
10335 ),
10336});
10337}
10338unsafe extern "C" fn get_onscroll<D: DomTypes>
10339(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10340 let mut result = false;
10341 wrap_panic(&mut || result = (|| {
10342 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10343 let this = &*(this as *const D::Document);
10344 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnscroll();
10345
10346 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10347 return true;
10348 })());
10349 result
10350}
10351
10352unsafe extern "C" fn set_onscroll<D: DomTypes>
10353(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10354 let mut result = false;
10355 wrap_panic(&mut || result = {
10356 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10357 let this = &*(this as *const D::Document);
10358 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10359 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10360 } else {
10361 None
10362 };
10363 let result: () = this.SetOnscroll(arg0);
10364
10365 true
10366 });
10367 result
10368}
10369
10370
10371static onscroll_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10372
10373pub(crate) fn init_onscroll_getterinfo<D: DomTypes>() {
10374 onscroll_getterinfo.set(JSJitInfo {
10375 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10376 getter: Some(get_onscroll::<D>)
10377 },
10378 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10379 protoID: PrototypeList::ID::Document as u16,
10380 },
10381 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10382 _bitfield_align_1: [],
10383 _bitfield_1: __BindgenBitfieldUnit::new(
10384 new_jsjitinfo_bitfield_1!(
10385 JSJitInfo_OpType::Getter as u8,
10386 JSJitInfo_AliasSet::AliasEverything as u8,
10387 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10388 true,
10389 false,
10390 false,
10391 false,
10392 false,
10393 false,
10394 0,
10395 ).to_ne_bytes()
10396 ),
10397});
10398}
10399static onscroll_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10400
10401pub(crate) fn init_onscroll_setterinfo<D: DomTypes>() {
10402 onscroll_setterinfo.set(JSJitInfo {
10403 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10404 setter: Some(set_onscroll::<D>)
10405 },
10406 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10407 protoID: PrototypeList::ID::Document as u16,
10408 },
10409 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10410 _bitfield_align_1: [],
10411 _bitfield_1: __BindgenBitfieldUnit::new(
10412 new_jsjitinfo_bitfield_1!(
10413 JSJitInfo_OpType::Setter as u8,
10414 JSJitInfo_AliasSet::AliasEverything as u8,
10415 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10416 false,
10417 false,
10418 false,
10419 false,
10420 false,
10421 false,
10422 0,
10423 ).to_ne_bytes()
10424 ),
10425});
10426}
10427unsafe extern "C" fn get_onscrollend<D: DomTypes>
10428(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10429 let mut result = false;
10430 wrap_panic(&mut || result = (|| {
10431 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10432 let this = &*(this as *const D::Document);
10433 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnscrollend();
10434
10435 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10436 return true;
10437 })());
10438 result
10439}
10440
10441unsafe extern "C" fn set_onscrollend<D: DomTypes>
10442(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10443 let mut result = false;
10444 wrap_panic(&mut || result = {
10445 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10446 let this = &*(this as *const D::Document);
10447 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10448 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10449 } else {
10450 None
10451 };
10452 let result: () = this.SetOnscrollend(arg0);
10453
10454 true
10455 });
10456 result
10457}
10458
10459
10460static onscrollend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10461
10462pub(crate) fn init_onscrollend_getterinfo<D: DomTypes>() {
10463 onscrollend_getterinfo.set(JSJitInfo {
10464 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10465 getter: Some(get_onscrollend::<D>)
10466 },
10467 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10468 protoID: PrototypeList::ID::Document as u16,
10469 },
10470 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10471 _bitfield_align_1: [],
10472 _bitfield_1: __BindgenBitfieldUnit::new(
10473 new_jsjitinfo_bitfield_1!(
10474 JSJitInfo_OpType::Getter as u8,
10475 JSJitInfo_AliasSet::AliasEverything as u8,
10476 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10477 true,
10478 false,
10479 false,
10480 false,
10481 false,
10482 false,
10483 0,
10484 ).to_ne_bytes()
10485 ),
10486});
10487}
10488static onscrollend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10489
10490pub(crate) fn init_onscrollend_setterinfo<D: DomTypes>() {
10491 onscrollend_setterinfo.set(JSJitInfo {
10492 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10493 setter: Some(set_onscrollend::<D>)
10494 },
10495 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10496 protoID: PrototypeList::ID::Document as u16,
10497 },
10498 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10499 _bitfield_align_1: [],
10500 _bitfield_1: __BindgenBitfieldUnit::new(
10501 new_jsjitinfo_bitfield_1!(
10502 JSJitInfo_OpType::Setter as u8,
10503 JSJitInfo_AliasSet::AliasEverything as u8,
10504 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10505 false,
10506 false,
10507 false,
10508 false,
10509 false,
10510 false,
10511 0,
10512 ).to_ne_bytes()
10513 ),
10514});
10515}
10516unsafe extern "C" fn get_onsecuritypolicyviolation<D: DomTypes>
10517(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10518 let mut result = false;
10519 wrap_panic(&mut || result = (|| {
10520 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10521 let this = &*(this as *const D::Document);
10522 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnsecuritypolicyviolation();
10523
10524 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10525 return true;
10526 })());
10527 result
10528}
10529
10530unsafe extern "C" fn set_onsecuritypolicyviolation<D: DomTypes>
10531(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10532 let mut result = false;
10533 wrap_panic(&mut || result = {
10534 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10535 let this = &*(this as *const D::Document);
10536 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10537 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10538 } else {
10539 None
10540 };
10541 let result: () = this.SetOnsecuritypolicyviolation(arg0);
10542
10543 true
10544 });
10545 result
10546}
10547
10548
10549static onsecuritypolicyviolation_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10550
10551pub(crate) fn init_onsecuritypolicyviolation_getterinfo<D: DomTypes>() {
10552 onsecuritypolicyviolation_getterinfo.set(JSJitInfo {
10553 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10554 getter: Some(get_onsecuritypolicyviolation::<D>)
10555 },
10556 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10557 protoID: PrototypeList::ID::Document as u16,
10558 },
10559 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10560 _bitfield_align_1: [],
10561 _bitfield_1: __BindgenBitfieldUnit::new(
10562 new_jsjitinfo_bitfield_1!(
10563 JSJitInfo_OpType::Getter as u8,
10564 JSJitInfo_AliasSet::AliasEverything as u8,
10565 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10566 true,
10567 false,
10568 false,
10569 false,
10570 false,
10571 false,
10572 0,
10573 ).to_ne_bytes()
10574 ),
10575});
10576}
10577static onsecuritypolicyviolation_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10578
10579pub(crate) fn init_onsecuritypolicyviolation_setterinfo<D: DomTypes>() {
10580 onsecuritypolicyviolation_setterinfo.set(JSJitInfo {
10581 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10582 setter: Some(set_onsecuritypolicyviolation::<D>)
10583 },
10584 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10585 protoID: PrototypeList::ID::Document as u16,
10586 },
10587 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10588 _bitfield_align_1: [],
10589 _bitfield_1: __BindgenBitfieldUnit::new(
10590 new_jsjitinfo_bitfield_1!(
10591 JSJitInfo_OpType::Setter as u8,
10592 JSJitInfo_AliasSet::AliasEverything as u8,
10593 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10594 false,
10595 false,
10596 false,
10597 false,
10598 false,
10599 false,
10600 0,
10601 ).to_ne_bytes()
10602 ),
10603});
10604}
10605unsafe extern "C" fn get_onseeked<D: DomTypes>
10606(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10607 let mut result = false;
10608 wrap_panic(&mut || result = (|| {
10609 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10610 let this = &*(this as *const D::Document);
10611 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnseeked();
10612
10613 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10614 return true;
10615 })());
10616 result
10617}
10618
10619unsafe extern "C" fn set_onseeked<D: DomTypes>
10620(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10621 let mut result = false;
10622 wrap_panic(&mut || result = {
10623 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10624 let this = &*(this as *const D::Document);
10625 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10626 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10627 } else {
10628 None
10629 };
10630 let result: () = this.SetOnseeked(arg0);
10631
10632 true
10633 });
10634 result
10635}
10636
10637
10638static onseeked_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10639
10640pub(crate) fn init_onseeked_getterinfo<D: DomTypes>() {
10641 onseeked_getterinfo.set(JSJitInfo {
10642 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10643 getter: Some(get_onseeked::<D>)
10644 },
10645 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10646 protoID: PrototypeList::ID::Document as u16,
10647 },
10648 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10649 _bitfield_align_1: [],
10650 _bitfield_1: __BindgenBitfieldUnit::new(
10651 new_jsjitinfo_bitfield_1!(
10652 JSJitInfo_OpType::Getter as u8,
10653 JSJitInfo_AliasSet::AliasEverything as u8,
10654 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10655 true,
10656 false,
10657 false,
10658 false,
10659 false,
10660 false,
10661 0,
10662 ).to_ne_bytes()
10663 ),
10664});
10665}
10666static onseeked_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10667
10668pub(crate) fn init_onseeked_setterinfo<D: DomTypes>() {
10669 onseeked_setterinfo.set(JSJitInfo {
10670 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10671 setter: Some(set_onseeked::<D>)
10672 },
10673 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10674 protoID: PrototypeList::ID::Document as u16,
10675 },
10676 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10677 _bitfield_align_1: [],
10678 _bitfield_1: __BindgenBitfieldUnit::new(
10679 new_jsjitinfo_bitfield_1!(
10680 JSJitInfo_OpType::Setter as u8,
10681 JSJitInfo_AliasSet::AliasEverything as u8,
10682 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10683 false,
10684 false,
10685 false,
10686 false,
10687 false,
10688 false,
10689 0,
10690 ).to_ne_bytes()
10691 ),
10692});
10693}
10694unsafe extern "C" fn get_onseeking<D: DomTypes>
10695(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10696 let mut result = false;
10697 wrap_panic(&mut || result = (|| {
10698 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10699 let this = &*(this as *const D::Document);
10700 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnseeking();
10701
10702 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10703 return true;
10704 })());
10705 result
10706}
10707
10708unsafe extern "C" fn set_onseeking<D: DomTypes>
10709(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10710 let mut result = false;
10711 wrap_panic(&mut || result = {
10712 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10713 let this = &*(this as *const D::Document);
10714 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10715 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10716 } else {
10717 None
10718 };
10719 let result: () = this.SetOnseeking(arg0);
10720
10721 true
10722 });
10723 result
10724}
10725
10726
10727static onseeking_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10728
10729pub(crate) fn init_onseeking_getterinfo<D: DomTypes>() {
10730 onseeking_getterinfo.set(JSJitInfo {
10731 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10732 getter: Some(get_onseeking::<D>)
10733 },
10734 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10735 protoID: PrototypeList::ID::Document as u16,
10736 },
10737 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10738 _bitfield_align_1: [],
10739 _bitfield_1: __BindgenBitfieldUnit::new(
10740 new_jsjitinfo_bitfield_1!(
10741 JSJitInfo_OpType::Getter as u8,
10742 JSJitInfo_AliasSet::AliasEverything as u8,
10743 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10744 true,
10745 false,
10746 false,
10747 false,
10748 false,
10749 false,
10750 0,
10751 ).to_ne_bytes()
10752 ),
10753});
10754}
10755static onseeking_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10756
10757pub(crate) fn init_onseeking_setterinfo<D: DomTypes>() {
10758 onseeking_setterinfo.set(JSJitInfo {
10759 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10760 setter: Some(set_onseeking::<D>)
10761 },
10762 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10763 protoID: PrototypeList::ID::Document as u16,
10764 },
10765 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10766 _bitfield_align_1: [],
10767 _bitfield_1: __BindgenBitfieldUnit::new(
10768 new_jsjitinfo_bitfield_1!(
10769 JSJitInfo_OpType::Setter as u8,
10770 JSJitInfo_AliasSet::AliasEverything as u8,
10771 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10772 false,
10773 false,
10774 false,
10775 false,
10776 false,
10777 false,
10778 0,
10779 ).to_ne_bytes()
10780 ),
10781});
10782}
10783unsafe extern "C" fn get_onselect<D: DomTypes>
10784(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10785 let mut result = false;
10786 wrap_panic(&mut || result = (|| {
10787 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10788 let this = &*(this as *const D::Document);
10789 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnselect();
10790
10791 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10792 return true;
10793 })());
10794 result
10795}
10796
10797unsafe extern "C" fn set_onselect<D: DomTypes>
10798(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10799 let mut result = false;
10800 wrap_panic(&mut || result = {
10801 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10802 let this = &*(this as *const D::Document);
10803 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10804 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10805 } else {
10806 None
10807 };
10808 let result: () = this.SetOnselect(arg0);
10809
10810 true
10811 });
10812 result
10813}
10814
10815
10816static onselect_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10817
10818pub(crate) fn init_onselect_getterinfo<D: DomTypes>() {
10819 onselect_getterinfo.set(JSJitInfo {
10820 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10821 getter: Some(get_onselect::<D>)
10822 },
10823 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10824 protoID: PrototypeList::ID::Document as u16,
10825 },
10826 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10827 _bitfield_align_1: [],
10828 _bitfield_1: __BindgenBitfieldUnit::new(
10829 new_jsjitinfo_bitfield_1!(
10830 JSJitInfo_OpType::Getter as u8,
10831 JSJitInfo_AliasSet::AliasEverything as u8,
10832 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10833 true,
10834 false,
10835 false,
10836 false,
10837 false,
10838 false,
10839 0,
10840 ).to_ne_bytes()
10841 ),
10842});
10843}
10844static onselect_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10845
10846pub(crate) fn init_onselect_setterinfo<D: DomTypes>() {
10847 onselect_setterinfo.set(JSJitInfo {
10848 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10849 setter: Some(set_onselect::<D>)
10850 },
10851 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10852 protoID: PrototypeList::ID::Document as u16,
10853 },
10854 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10855 _bitfield_align_1: [],
10856 _bitfield_1: __BindgenBitfieldUnit::new(
10857 new_jsjitinfo_bitfield_1!(
10858 JSJitInfo_OpType::Setter as u8,
10859 JSJitInfo_AliasSet::AliasEverything as u8,
10860 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10861 false,
10862 false,
10863 false,
10864 false,
10865 false,
10866 false,
10867 0,
10868 ).to_ne_bytes()
10869 ),
10870});
10871}
10872unsafe extern "C" fn get_onslotchange<D: DomTypes>
10873(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10874 let mut result = false;
10875 wrap_panic(&mut || result = (|| {
10876 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10877 let this = &*(this as *const D::Document);
10878 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnslotchange();
10879
10880 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10881 return true;
10882 })());
10883 result
10884}
10885
10886unsafe extern "C" fn set_onslotchange<D: DomTypes>
10887(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10888 let mut result = false;
10889 wrap_panic(&mut || result = {
10890 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10891 let this = &*(this as *const D::Document);
10892 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10893 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10894 } else {
10895 None
10896 };
10897 let result: () = this.SetOnslotchange(arg0);
10898
10899 true
10900 });
10901 result
10902}
10903
10904
10905static onslotchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10906
10907pub(crate) fn init_onslotchange_getterinfo<D: DomTypes>() {
10908 onslotchange_getterinfo.set(JSJitInfo {
10909 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10910 getter: Some(get_onslotchange::<D>)
10911 },
10912 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10913 protoID: PrototypeList::ID::Document as u16,
10914 },
10915 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10916 _bitfield_align_1: [],
10917 _bitfield_1: __BindgenBitfieldUnit::new(
10918 new_jsjitinfo_bitfield_1!(
10919 JSJitInfo_OpType::Getter as u8,
10920 JSJitInfo_AliasSet::AliasEverything as u8,
10921 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10922 true,
10923 false,
10924 false,
10925 false,
10926 false,
10927 false,
10928 0,
10929 ).to_ne_bytes()
10930 ),
10931});
10932}
10933static onslotchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10934
10935pub(crate) fn init_onslotchange_setterinfo<D: DomTypes>() {
10936 onslotchange_setterinfo.set(JSJitInfo {
10937 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10938 setter: Some(set_onslotchange::<D>)
10939 },
10940 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10941 protoID: PrototypeList::ID::Document as u16,
10942 },
10943 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
10944 _bitfield_align_1: [],
10945 _bitfield_1: __BindgenBitfieldUnit::new(
10946 new_jsjitinfo_bitfield_1!(
10947 JSJitInfo_OpType::Setter as u8,
10948 JSJitInfo_AliasSet::AliasEverything as u8,
10949 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10950 false,
10951 false,
10952 false,
10953 false,
10954 false,
10955 false,
10956 0,
10957 ).to_ne_bytes()
10958 ),
10959});
10960}
10961unsafe extern "C" fn get_onstalled<D: DomTypes>
10962(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
10963 let mut result = false;
10964 wrap_panic(&mut || result = (|| {
10965 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10966 let this = &*(this as *const D::Document);
10967 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnstalled();
10968
10969 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10970 return true;
10971 })());
10972 result
10973}
10974
10975unsafe extern "C" fn set_onstalled<D: DomTypes>
10976(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
10977 let mut result = false;
10978 wrap_panic(&mut || result = {
10979 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10980 let this = &*(this as *const D::Document);
10981 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10982 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
10983 } else {
10984 None
10985 };
10986 let result: () = this.SetOnstalled(arg0);
10987
10988 true
10989 });
10990 result
10991}
10992
10993
10994static onstalled_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10995
10996pub(crate) fn init_onstalled_getterinfo<D: DomTypes>() {
10997 onstalled_getterinfo.set(JSJitInfo {
10998 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10999 getter: Some(get_onstalled::<D>)
11000 },
11001 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11002 protoID: PrototypeList::ID::Document as u16,
11003 },
11004 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11005 _bitfield_align_1: [],
11006 _bitfield_1: __BindgenBitfieldUnit::new(
11007 new_jsjitinfo_bitfield_1!(
11008 JSJitInfo_OpType::Getter as u8,
11009 JSJitInfo_AliasSet::AliasEverything as u8,
11010 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11011 true,
11012 false,
11013 false,
11014 false,
11015 false,
11016 false,
11017 0,
11018 ).to_ne_bytes()
11019 ),
11020});
11021}
11022static onstalled_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11023
11024pub(crate) fn init_onstalled_setterinfo<D: DomTypes>() {
11025 onstalled_setterinfo.set(JSJitInfo {
11026 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11027 setter: Some(set_onstalled::<D>)
11028 },
11029 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11030 protoID: PrototypeList::ID::Document as u16,
11031 },
11032 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11033 _bitfield_align_1: [],
11034 _bitfield_1: __BindgenBitfieldUnit::new(
11035 new_jsjitinfo_bitfield_1!(
11036 JSJitInfo_OpType::Setter as u8,
11037 JSJitInfo_AliasSet::AliasEverything as u8,
11038 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11039 false,
11040 false,
11041 false,
11042 false,
11043 false,
11044 false,
11045 0,
11046 ).to_ne_bytes()
11047 ),
11048});
11049}
11050unsafe extern "C" fn get_onsubmit<D: DomTypes>
11051(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11052 let mut result = false;
11053 wrap_panic(&mut || result = (|| {
11054 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11055 let this = &*(this as *const D::Document);
11056 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnsubmit();
11057
11058 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11059 return true;
11060 })());
11061 result
11062}
11063
11064unsafe extern "C" fn set_onsubmit<D: DomTypes>
11065(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11066 let mut result = false;
11067 wrap_panic(&mut || result = {
11068 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11069 let this = &*(this as *const D::Document);
11070 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11071 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11072 } else {
11073 None
11074 };
11075 let result: () = this.SetOnsubmit(arg0);
11076
11077 true
11078 });
11079 result
11080}
11081
11082
11083static onsubmit_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11084
11085pub(crate) fn init_onsubmit_getterinfo<D: DomTypes>() {
11086 onsubmit_getterinfo.set(JSJitInfo {
11087 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11088 getter: Some(get_onsubmit::<D>)
11089 },
11090 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11091 protoID: PrototypeList::ID::Document as u16,
11092 },
11093 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11094 _bitfield_align_1: [],
11095 _bitfield_1: __BindgenBitfieldUnit::new(
11096 new_jsjitinfo_bitfield_1!(
11097 JSJitInfo_OpType::Getter as u8,
11098 JSJitInfo_AliasSet::AliasEverything as u8,
11099 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11100 true,
11101 false,
11102 false,
11103 false,
11104 false,
11105 false,
11106 0,
11107 ).to_ne_bytes()
11108 ),
11109});
11110}
11111static onsubmit_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11112
11113pub(crate) fn init_onsubmit_setterinfo<D: DomTypes>() {
11114 onsubmit_setterinfo.set(JSJitInfo {
11115 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11116 setter: Some(set_onsubmit::<D>)
11117 },
11118 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11119 protoID: PrototypeList::ID::Document as u16,
11120 },
11121 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11122 _bitfield_align_1: [],
11123 _bitfield_1: __BindgenBitfieldUnit::new(
11124 new_jsjitinfo_bitfield_1!(
11125 JSJitInfo_OpType::Setter as u8,
11126 JSJitInfo_AliasSet::AliasEverything as u8,
11127 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11128 false,
11129 false,
11130 false,
11131 false,
11132 false,
11133 false,
11134 0,
11135 ).to_ne_bytes()
11136 ),
11137});
11138}
11139unsafe extern "C" fn get_onsuspend<D: DomTypes>
11140(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11141 let mut result = false;
11142 wrap_panic(&mut || result = (|| {
11143 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11144 let this = &*(this as *const D::Document);
11145 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnsuspend();
11146
11147 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11148 return true;
11149 })());
11150 result
11151}
11152
11153unsafe extern "C" fn set_onsuspend<D: DomTypes>
11154(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11155 let mut result = false;
11156 wrap_panic(&mut || result = {
11157 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11158 let this = &*(this as *const D::Document);
11159 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11160 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11161 } else {
11162 None
11163 };
11164 let result: () = this.SetOnsuspend(arg0);
11165
11166 true
11167 });
11168 result
11169}
11170
11171
11172static onsuspend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11173
11174pub(crate) fn init_onsuspend_getterinfo<D: DomTypes>() {
11175 onsuspend_getterinfo.set(JSJitInfo {
11176 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11177 getter: Some(get_onsuspend::<D>)
11178 },
11179 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11180 protoID: PrototypeList::ID::Document as u16,
11181 },
11182 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11183 _bitfield_align_1: [],
11184 _bitfield_1: __BindgenBitfieldUnit::new(
11185 new_jsjitinfo_bitfield_1!(
11186 JSJitInfo_OpType::Getter as u8,
11187 JSJitInfo_AliasSet::AliasEverything as u8,
11188 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11189 true,
11190 false,
11191 false,
11192 false,
11193 false,
11194 false,
11195 0,
11196 ).to_ne_bytes()
11197 ),
11198});
11199}
11200static onsuspend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11201
11202pub(crate) fn init_onsuspend_setterinfo<D: DomTypes>() {
11203 onsuspend_setterinfo.set(JSJitInfo {
11204 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11205 setter: Some(set_onsuspend::<D>)
11206 },
11207 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11208 protoID: PrototypeList::ID::Document as u16,
11209 },
11210 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11211 _bitfield_align_1: [],
11212 _bitfield_1: __BindgenBitfieldUnit::new(
11213 new_jsjitinfo_bitfield_1!(
11214 JSJitInfo_OpType::Setter as u8,
11215 JSJitInfo_AliasSet::AliasEverything as u8,
11216 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11217 false,
11218 false,
11219 false,
11220 false,
11221 false,
11222 false,
11223 0,
11224 ).to_ne_bytes()
11225 ),
11226});
11227}
11228unsafe extern "C" fn get_ontimeupdate<D: DomTypes>
11229(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11230 let mut result = false;
11231 wrap_panic(&mut || result = (|| {
11232 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11233 let this = &*(this as *const D::Document);
11234 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntimeupdate();
11235
11236 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11237 return true;
11238 })());
11239 result
11240}
11241
11242unsafe extern "C" fn set_ontimeupdate<D: DomTypes>
11243(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11244 let mut result = false;
11245 wrap_panic(&mut || result = {
11246 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11247 let this = &*(this as *const D::Document);
11248 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11249 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11250 } else {
11251 None
11252 };
11253 let result: () = this.SetOntimeupdate(arg0);
11254
11255 true
11256 });
11257 result
11258}
11259
11260
11261static ontimeupdate_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11262
11263pub(crate) fn init_ontimeupdate_getterinfo<D: DomTypes>() {
11264 ontimeupdate_getterinfo.set(JSJitInfo {
11265 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11266 getter: Some(get_ontimeupdate::<D>)
11267 },
11268 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11269 protoID: PrototypeList::ID::Document as u16,
11270 },
11271 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11272 _bitfield_align_1: [],
11273 _bitfield_1: __BindgenBitfieldUnit::new(
11274 new_jsjitinfo_bitfield_1!(
11275 JSJitInfo_OpType::Getter as u8,
11276 JSJitInfo_AliasSet::AliasEverything as u8,
11277 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11278 true,
11279 false,
11280 false,
11281 false,
11282 false,
11283 false,
11284 0,
11285 ).to_ne_bytes()
11286 ),
11287});
11288}
11289static ontimeupdate_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11290
11291pub(crate) fn init_ontimeupdate_setterinfo<D: DomTypes>() {
11292 ontimeupdate_setterinfo.set(JSJitInfo {
11293 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11294 setter: Some(set_ontimeupdate::<D>)
11295 },
11296 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11297 protoID: PrototypeList::ID::Document as u16,
11298 },
11299 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11300 _bitfield_align_1: [],
11301 _bitfield_1: __BindgenBitfieldUnit::new(
11302 new_jsjitinfo_bitfield_1!(
11303 JSJitInfo_OpType::Setter as u8,
11304 JSJitInfo_AliasSet::AliasEverything as u8,
11305 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11306 false,
11307 false,
11308 false,
11309 false,
11310 false,
11311 false,
11312 0,
11313 ).to_ne_bytes()
11314 ),
11315});
11316}
11317unsafe extern "C" fn get_ontoggle<D: DomTypes>
11318(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11319 let mut result = false;
11320 wrap_panic(&mut || result = (|| {
11321 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11322 let this = &*(this as *const D::Document);
11323 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntoggle();
11324
11325 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11326 return true;
11327 })());
11328 result
11329}
11330
11331unsafe extern "C" fn set_ontoggle<D: DomTypes>
11332(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11333 let mut result = false;
11334 wrap_panic(&mut || result = {
11335 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11336 let this = &*(this as *const D::Document);
11337 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11338 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11339 } else {
11340 None
11341 };
11342 let result: () = this.SetOntoggle(arg0);
11343
11344 true
11345 });
11346 result
11347}
11348
11349
11350static ontoggle_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11351
11352pub(crate) fn init_ontoggle_getterinfo<D: DomTypes>() {
11353 ontoggle_getterinfo.set(JSJitInfo {
11354 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11355 getter: Some(get_ontoggle::<D>)
11356 },
11357 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11358 protoID: PrototypeList::ID::Document as u16,
11359 },
11360 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11361 _bitfield_align_1: [],
11362 _bitfield_1: __BindgenBitfieldUnit::new(
11363 new_jsjitinfo_bitfield_1!(
11364 JSJitInfo_OpType::Getter as u8,
11365 JSJitInfo_AliasSet::AliasEverything as u8,
11366 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11367 true,
11368 false,
11369 false,
11370 false,
11371 false,
11372 false,
11373 0,
11374 ).to_ne_bytes()
11375 ),
11376});
11377}
11378static ontoggle_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11379
11380pub(crate) fn init_ontoggle_setterinfo<D: DomTypes>() {
11381 ontoggle_setterinfo.set(JSJitInfo {
11382 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11383 setter: Some(set_ontoggle::<D>)
11384 },
11385 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11386 protoID: PrototypeList::ID::Document as u16,
11387 },
11388 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11389 _bitfield_align_1: [],
11390 _bitfield_1: __BindgenBitfieldUnit::new(
11391 new_jsjitinfo_bitfield_1!(
11392 JSJitInfo_OpType::Setter as u8,
11393 JSJitInfo_AliasSet::AliasEverything as u8,
11394 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11395 false,
11396 false,
11397 false,
11398 false,
11399 false,
11400 false,
11401 0,
11402 ).to_ne_bytes()
11403 ),
11404});
11405}
11406unsafe extern "C" fn get_onvolumechange<D: DomTypes>
11407(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11408 let mut result = false;
11409 wrap_panic(&mut || result = (|| {
11410 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11411 let this = &*(this as *const D::Document);
11412 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnvolumechange();
11413
11414 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11415 return true;
11416 })());
11417 result
11418}
11419
11420unsafe extern "C" fn set_onvolumechange<D: DomTypes>
11421(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11422 let mut result = false;
11423 wrap_panic(&mut || result = {
11424 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11425 let this = &*(this as *const D::Document);
11426 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11427 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11428 } else {
11429 None
11430 };
11431 let result: () = this.SetOnvolumechange(arg0);
11432
11433 true
11434 });
11435 result
11436}
11437
11438
11439static onvolumechange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11440
11441pub(crate) fn init_onvolumechange_getterinfo<D: DomTypes>() {
11442 onvolumechange_getterinfo.set(JSJitInfo {
11443 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11444 getter: Some(get_onvolumechange::<D>)
11445 },
11446 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11447 protoID: PrototypeList::ID::Document as u16,
11448 },
11449 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11450 _bitfield_align_1: [],
11451 _bitfield_1: __BindgenBitfieldUnit::new(
11452 new_jsjitinfo_bitfield_1!(
11453 JSJitInfo_OpType::Getter as u8,
11454 JSJitInfo_AliasSet::AliasEverything as u8,
11455 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11456 true,
11457 false,
11458 false,
11459 false,
11460 false,
11461 false,
11462 0,
11463 ).to_ne_bytes()
11464 ),
11465});
11466}
11467static onvolumechange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11468
11469pub(crate) fn init_onvolumechange_setterinfo<D: DomTypes>() {
11470 onvolumechange_setterinfo.set(JSJitInfo {
11471 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11472 setter: Some(set_onvolumechange::<D>)
11473 },
11474 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11475 protoID: PrototypeList::ID::Document as u16,
11476 },
11477 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11478 _bitfield_align_1: [],
11479 _bitfield_1: __BindgenBitfieldUnit::new(
11480 new_jsjitinfo_bitfield_1!(
11481 JSJitInfo_OpType::Setter as u8,
11482 JSJitInfo_AliasSet::AliasEverything as u8,
11483 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11484 false,
11485 false,
11486 false,
11487 false,
11488 false,
11489 false,
11490 0,
11491 ).to_ne_bytes()
11492 ),
11493});
11494}
11495unsafe extern "C" fn get_onwaiting<D: DomTypes>
11496(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11497 let mut result = false;
11498 wrap_panic(&mut || result = (|| {
11499 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11500 let this = &*(this as *const D::Document);
11501 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwaiting();
11502
11503 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11504 return true;
11505 })());
11506 result
11507}
11508
11509unsafe extern "C" fn set_onwaiting<D: DomTypes>
11510(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11511 let mut result = false;
11512 wrap_panic(&mut || result = {
11513 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11514 let this = &*(this as *const D::Document);
11515 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11516 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11517 } else {
11518 None
11519 };
11520 let result: () = this.SetOnwaiting(arg0);
11521
11522 true
11523 });
11524 result
11525}
11526
11527
11528static onwaiting_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11529
11530pub(crate) fn init_onwaiting_getterinfo<D: DomTypes>() {
11531 onwaiting_getterinfo.set(JSJitInfo {
11532 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11533 getter: Some(get_onwaiting::<D>)
11534 },
11535 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11536 protoID: PrototypeList::ID::Document as u16,
11537 },
11538 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11539 _bitfield_align_1: [],
11540 _bitfield_1: __BindgenBitfieldUnit::new(
11541 new_jsjitinfo_bitfield_1!(
11542 JSJitInfo_OpType::Getter as u8,
11543 JSJitInfo_AliasSet::AliasEverything as u8,
11544 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11545 true,
11546 false,
11547 false,
11548 false,
11549 false,
11550 false,
11551 0,
11552 ).to_ne_bytes()
11553 ),
11554});
11555}
11556static onwaiting_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11557
11558pub(crate) fn init_onwaiting_setterinfo<D: DomTypes>() {
11559 onwaiting_setterinfo.set(JSJitInfo {
11560 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11561 setter: Some(set_onwaiting::<D>)
11562 },
11563 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11564 protoID: PrototypeList::ID::Document as u16,
11565 },
11566 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11567 _bitfield_align_1: [],
11568 _bitfield_1: __BindgenBitfieldUnit::new(
11569 new_jsjitinfo_bitfield_1!(
11570 JSJitInfo_OpType::Setter as u8,
11571 JSJitInfo_AliasSet::AliasEverything as u8,
11572 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11573 false,
11574 false,
11575 false,
11576 false,
11577 false,
11578 false,
11579 0,
11580 ).to_ne_bytes()
11581 ),
11582});
11583}
11584unsafe extern "C" fn get_onwebkitanimationend<D: DomTypes>
11585(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11586 let mut result = false;
11587 wrap_panic(&mut || result = (|| {
11588 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11589 let this = &*(this as *const D::Document);
11590 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwebkitanimationend();
11591
11592 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11593 return true;
11594 })());
11595 result
11596}
11597
11598unsafe extern "C" fn set_onwebkitanimationend<D: DomTypes>
11599(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11600 let mut result = false;
11601 wrap_panic(&mut || result = {
11602 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11603 let this = &*(this as *const D::Document);
11604 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11605 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11606 } else {
11607 None
11608 };
11609 let result: () = this.SetOnwebkitanimationend(arg0);
11610
11611 true
11612 });
11613 result
11614}
11615
11616
11617static onwebkitanimationend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11618
11619pub(crate) fn init_onwebkitanimationend_getterinfo<D: DomTypes>() {
11620 onwebkitanimationend_getterinfo.set(JSJitInfo {
11621 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11622 getter: Some(get_onwebkitanimationend::<D>)
11623 },
11624 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11625 protoID: PrototypeList::ID::Document as u16,
11626 },
11627 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11628 _bitfield_align_1: [],
11629 _bitfield_1: __BindgenBitfieldUnit::new(
11630 new_jsjitinfo_bitfield_1!(
11631 JSJitInfo_OpType::Getter as u8,
11632 JSJitInfo_AliasSet::AliasEverything as u8,
11633 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11634 true,
11635 false,
11636 false,
11637 false,
11638 false,
11639 false,
11640 0,
11641 ).to_ne_bytes()
11642 ),
11643});
11644}
11645static onwebkitanimationend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11646
11647pub(crate) fn init_onwebkitanimationend_setterinfo<D: DomTypes>() {
11648 onwebkitanimationend_setterinfo.set(JSJitInfo {
11649 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11650 setter: Some(set_onwebkitanimationend::<D>)
11651 },
11652 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11653 protoID: PrototypeList::ID::Document as u16,
11654 },
11655 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11656 _bitfield_align_1: [],
11657 _bitfield_1: __BindgenBitfieldUnit::new(
11658 new_jsjitinfo_bitfield_1!(
11659 JSJitInfo_OpType::Setter as u8,
11660 JSJitInfo_AliasSet::AliasEverything as u8,
11661 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11662 false,
11663 false,
11664 false,
11665 false,
11666 false,
11667 false,
11668 0,
11669 ).to_ne_bytes()
11670 ),
11671});
11672}
11673unsafe extern "C" fn get_onwebkitanimationiteration<D: DomTypes>
11674(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11675 let mut result = false;
11676 wrap_panic(&mut || result = (|| {
11677 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11678 let this = &*(this as *const D::Document);
11679 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwebkitanimationiteration();
11680
11681 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11682 return true;
11683 })());
11684 result
11685}
11686
11687unsafe extern "C" fn set_onwebkitanimationiteration<D: DomTypes>
11688(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11689 let mut result = false;
11690 wrap_panic(&mut || result = {
11691 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11692 let this = &*(this as *const D::Document);
11693 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11694 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11695 } else {
11696 None
11697 };
11698 let result: () = this.SetOnwebkitanimationiteration(arg0);
11699
11700 true
11701 });
11702 result
11703}
11704
11705
11706static onwebkitanimationiteration_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11707
11708pub(crate) fn init_onwebkitanimationiteration_getterinfo<D: DomTypes>() {
11709 onwebkitanimationiteration_getterinfo.set(JSJitInfo {
11710 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11711 getter: Some(get_onwebkitanimationiteration::<D>)
11712 },
11713 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11714 protoID: PrototypeList::ID::Document as u16,
11715 },
11716 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11717 _bitfield_align_1: [],
11718 _bitfield_1: __BindgenBitfieldUnit::new(
11719 new_jsjitinfo_bitfield_1!(
11720 JSJitInfo_OpType::Getter as u8,
11721 JSJitInfo_AliasSet::AliasEverything as u8,
11722 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11723 true,
11724 false,
11725 false,
11726 false,
11727 false,
11728 false,
11729 0,
11730 ).to_ne_bytes()
11731 ),
11732});
11733}
11734static onwebkitanimationiteration_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11735
11736pub(crate) fn init_onwebkitanimationiteration_setterinfo<D: DomTypes>() {
11737 onwebkitanimationiteration_setterinfo.set(JSJitInfo {
11738 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11739 setter: Some(set_onwebkitanimationiteration::<D>)
11740 },
11741 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11742 protoID: PrototypeList::ID::Document as u16,
11743 },
11744 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11745 _bitfield_align_1: [],
11746 _bitfield_1: __BindgenBitfieldUnit::new(
11747 new_jsjitinfo_bitfield_1!(
11748 JSJitInfo_OpType::Setter as u8,
11749 JSJitInfo_AliasSet::AliasEverything as u8,
11750 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11751 false,
11752 false,
11753 false,
11754 false,
11755 false,
11756 false,
11757 0,
11758 ).to_ne_bytes()
11759 ),
11760});
11761}
11762unsafe extern "C" fn get_onwebkitanimationstart<D: DomTypes>
11763(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11764 let mut result = false;
11765 wrap_panic(&mut || result = (|| {
11766 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11767 let this = &*(this as *const D::Document);
11768 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwebkitanimationstart();
11769
11770 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11771 return true;
11772 })());
11773 result
11774}
11775
11776unsafe extern "C" fn set_onwebkitanimationstart<D: DomTypes>
11777(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11778 let mut result = false;
11779 wrap_panic(&mut || result = {
11780 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11781 let this = &*(this as *const D::Document);
11782 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11783 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11784 } else {
11785 None
11786 };
11787 let result: () = this.SetOnwebkitanimationstart(arg0);
11788
11789 true
11790 });
11791 result
11792}
11793
11794
11795static onwebkitanimationstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11796
11797pub(crate) fn init_onwebkitanimationstart_getterinfo<D: DomTypes>() {
11798 onwebkitanimationstart_getterinfo.set(JSJitInfo {
11799 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11800 getter: Some(get_onwebkitanimationstart::<D>)
11801 },
11802 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11803 protoID: PrototypeList::ID::Document as u16,
11804 },
11805 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11806 _bitfield_align_1: [],
11807 _bitfield_1: __BindgenBitfieldUnit::new(
11808 new_jsjitinfo_bitfield_1!(
11809 JSJitInfo_OpType::Getter as u8,
11810 JSJitInfo_AliasSet::AliasEverything as u8,
11811 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11812 true,
11813 false,
11814 false,
11815 false,
11816 false,
11817 false,
11818 0,
11819 ).to_ne_bytes()
11820 ),
11821});
11822}
11823static onwebkitanimationstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11824
11825pub(crate) fn init_onwebkitanimationstart_setterinfo<D: DomTypes>() {
11826 onwebkitanimationstart_setterinfo.set(JSJitInfo {
11827 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11828 setter: Some(set_onwebkitanimationstart::<D>)
11829 },
11830 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11831 protoID: PrototypeList::ID::Document as u16,
11832 },
11833 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11834 _bitfield_align_1: [],
11835 _bitfield_1: __BindgenBitfieldUnit::new(
11836 new_jsjitinfo_bitfield_1!(
11837 JSJitInfo_OpType::Setter as u8,
11838 JSJitInfo_AliasSet::AliasEverything as u8,
11839 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11840 false,
11841 false,
11842 false,
11843 false,
11844 false,
11845 false,
11846 0,
11847 ).to_ne_bytes()
11848 ),
11849});
11850}
11851unsafe extern "C" fn get_onwebkittransitionend<D: DomTypes>
11852(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11853 let mut result = false;
11854 wrap_panic(&mut || result = (|| {
11855 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11856 let this = &*(this as *const D::Document);
11857 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwebkittransitionend();
11858
11859 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11860 return true;
11861 })());
11862 result
11863}
11864
11865unsafe extern "C" fn set_onwebkittransitionend<D: DomTypes>
11866(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11867 let mut result = false;
11868 wrap_panic(&mut || result = {
11869 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11870 let this = &*(this as *const D::Document);
11871 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11872 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11873 } else {
11874 None
11875 };
11876 let result: () = this.SetOnwebkittransitionend(arg0);
11877
11878 true
11879 });
11880 result
11881}
11882
11883
11884static onwebkittransitionend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11885
11886pub(crate) fn init_onwebkittransitionend_getterinfo<D: DomTypes>() {
11887 onwebkittransitionend_getterinfo.set(JSJitInfo {
11888 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11889 getter: Some(get_onwebkittransitionend::<D>)
11890 },
11891 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11892 protoID: PrototypeList::ID::Document as u16,
11893 },
11894 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11895 _bitfield_align_1: [],
11896 _bitfield_1: __BindgenBitfieldUnit::new(
11897 new_jsjitinfo_bitfield_1!(
11898 JSJitInfo_OpType::Getter as u8,
11899 JSJitInfo_AliasSet::AliasEverything as u8,
11900 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11901 true,
11902 false,
11903 false,
11904 false,
11905 false,
11906 false,
11907 0,
11908 ).to_ne_bytes()
11909 ),
11910});
11911}
11912static onwebkittransitionend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11913
11914pub(crate) fn init_onwebkittransitionend_setterinfo<D: DomTypes>() {
11915 onwebkittransitionend_setterinfo.set(JSJitInfo {
11916 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11917 setter: Some(set_onwebkittransitionend::<D>)
11918 },
11919 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11920 protoID: PrototypeList::ID::Document as u16,
11921 },
11922 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11923 _bitfield_align_1: [],
11924 _bitfield_1: __BindgenBitfieldUnit::new(
11925 new_jsjitinfo_bitfield_1!(
11926 JSJitInfo_OpType::Setter as u8,
11927 JSJitInfo_AliasSet::AliasEverything as u8,
11928 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11929 false,
11930 false,
11931 false,
11932 false,
11933 false,
11934 false,
11935 0,
11936 ).to_ne_bytes()
11937 ),
11938});
11939}
11940unsafe extern "C" fn get_onwheel<D: DomTypes>
11941(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11942 let mut result = false;
11943 wrap_panic(&mut || result = (|| {
11944 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11945 let this = &*(this as *const D::Document);
11946 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnwheel();
11947
11948 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11949 return true;
11950 })());
11951 result
11952}
11953
11954unsafe extern "C" fn set_onwheel<D: DomTypes>
11955(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
11956 let mut result = false;
11957 wrap_panic(&mut || result = {
11958 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11959 let this = &*(this as *const D::Document);
11960 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11961 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
11962 } else {
11963 None
11964 };
11965 let result: () = this.SetOnwheel(arg0);
11966
11967 true
11968 });
11969 result
11970}
11971
11972
11973static onwheel_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11974
11975pub(crate) fn init_onwheel_getterinfo<D: DomTypes>() {
11976 onwheel_getterinfo.set(JSJitInfo {
11977 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11978 getter: Some(get_onwheel::<D>)
11979 },
11980 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11981 protoID: PrototypeList::ID::Document as u16,
11982 },
11983 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
11984 _bitfield_align_1: [],
11985 _bitfield_1: __BindgenBitfieldUnit::new(
11986 new_jsjitinfo_bitfield_1!(
11987 JSJitInfo_OpType::Getter as u8,
11988 JSJitInfo_AliasSet::AliasEverything as u8,
11989 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11990 true,
11991 false,
11992 false,
11993 false,
11994 false,
11995 false,
11996 0,
11997 ).to_ne_bytes()
11998 ),
11999});
12000}
12001static onwheel_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12002
12003pub(crate) fn init_onwheel_setterinfo<D: DomTypes>() {
12004 onwheel_setterinfo.set(JSJitInfo {
12005 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12006 setter: Some(set_onwheel::<D>)
12007 },
12008 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12009 protoID: PrototypeList::ID::Document as u16,
12010 },
12011 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12012 _bitfield_align_1: [],
12013 _bitfield_1: __BindgenBitfieldUnit::new(
12014 new_jsjitinfo_bitfield_1!(
12015 JSJitInfo_OpType::Setter as u8,
12016 JSJitInfo_AliasSet::AliasEverything as u8,
12017 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12018 false,
12019 false,
12020 false,
12021 false,
12022 false,
12023 false,
12024 0,
12025 ).to_ne_bytes()
12026 ),
12027});
12028}
12029unsafe extern "C" fn get_onanimationstart<D: DomTypes>
12030(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12031 let mut result = false;
12032 wrap_panic(&mut || result = (|| {
12033 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12034 let this = &*(this as *const D::Document);
12035 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnanimationstart();
12036
12037 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12038 return true;
12039 })());
12040 result
12041}
12042
12043unsafe extern "C" fn set_onanimationstart<D: DomTypes>
12044(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12045 let mut result = false;
12046 wrap_panic(&mut || result = {
12047 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12048 let this = &*(this as *const D::Document);
12049 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12050 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12051 } else {
12052 None
12053 };
12054 let result: () = this.SetOnanimationstart(arg0);
12055
12056 true
12057 });
12058 result
12059}
12060
12061
12062static onanimationstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12063
12064pub(crate) fn init_onanimationstart_getterinfo<D: DomTypes>() {
12065 onanimationstart_getterinfo.set(JSJitInfo {
12066 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12067 getter: Some(get_onanimationstart::<D>)
12068 },
12069 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12070 protoID: PrototypeList::ID::Document as u16,
12071 },
12072 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12073 _bitfield_align_1: [],
12074 _bitfield_1: __BindgenBitfieldUnit::new(
12075 new_jsjitinfo_bitfield_1!(
12076 JSJitInfo_OpType::Getter as u8,
12077 JSJitInfo_AliasSet::AliasEverything as u8,
12078 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12079 true,
12080 false,
12081 false,
12082 false,
12083 false,
12084 false,
12085 0,
12086 ).to_ne_bytes()
12087 ),
12088});
12089}
12090static onanimationstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12091
12092pub(crate) fn init_onanimationstart_setterinfo<D: DomTypes>() {
12093 onanimationstart_setterinfo.set(JSJitInfo {
12094 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12095 setter: Some(set_onanimationstart::<D>)
12096 },
12097 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12098 protoID: PrototypeList::ID::Document as u16,
12099 },
12100 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12101 _bitfield_align_1: [],
12102 _bitfield_1: __BindgenBitfieldUnit::new(
12103 new_jsjitinfo_bitfield_1!(
12104 JSJitInfo_OpType::Setter as u8,
12105 JSJitInfo_AliasSet::AliasEverything as u8,
12106 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12107 false,
12108 false,
12109 false,
12110 false,
12111 false,
12112 false,
12113 0,
12114 ).to_ne_bytes()
12115 ),
12116});
12117}
12118unsafe extern "C" fn get_onanimationiteration<D: DomTypes>
12119(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12120 let mut result = false;
12121 wrap_panic(&mut || result = (|| {
12122 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12123 let this = &*(this as *const D::Document);
12124 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnanimationiteration();
12125
12126 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12127 return true;
12128 })());
12129 result
12130}
12131
12132unsafe extern "C" fn set_onanimationiteration<D: DomTypes>
12133(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12134 let mut result = false;
12135 wrap_panic(&mut || result = {
12136 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12137 let this = &*(this as *const D::Document);
12138 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12139 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12140 } else {
12141 None
12142 };
12143 let result: () = this.SetOnanimationiteration(arg0);
12144
12145 true
12146 });
12147 result
12148}
12149
12150
12151static onanimationiteration_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12152
12153pub(crate) fn init_onanimationiteration_getterinfo<D: DomTypes>() {
12154 onanimationiteration_getterinfo.set(JSJitInfo {
12155 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12156 getter: Some(get_onanimationiteration::<D>)
12157 },
12158 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12159 protoID: PrototypeList::ID::Document as u16,
12160 },
12161 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12162 _bitfield_align_1: [],
12163 _bitfield_1: __BindgenBitfieldUnit::new(
12164 new_jsjitinfo_bitfield_1!(
12165 JSJitInfo_OpType::Getter as u8,
12166 JSJitInfo_AliasSet::AliasEverything as u8,
12167 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12168 true,
12169 false,
12170 false,
12171 false,
12172 false,
12173 false,
12174 0,
12175 ).to_ne_bytes()
12176 ),
12177});
12178}
12179static onanimationiteration_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12180
12181pub(crate) fn init_onanimationiteration_setterinfo<D: DomTypes>() {
12182 onanimationiteration_setterinfo.set(JSJitInfo {
12183 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12184 setter: Some(set_onanimationiteration::<D>)
12185 },
12186 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12187 protoID: PrototypeList::ID::Document as u16,
12188 },
12189 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12190 _bitfield_align_1: [],
12191 _bitfield_1: __BindgenBitfieldUnit::new(
12192 new_jsjitinfo_bitfield_1!(
12193 JSJitInfo_OpType::Setter as u8,
12194 JSJitInfo_AliasSet::AliasEverything as u8,
12195 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12196 false,
12197 false,
12198 false,
12199 false,
12200 false,
12201 false,
12202 0,
12203 ).to_ne_bytes()
12204 ),
12205});
12206}
12207unsafe extern "C" fn get_onanimationend<D: DomTypes>
12208(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12209 let mut result = false;
12210 wrap_panic(&mut || result = (|| {
12211 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12212 let this = &*(this as *const D::Document);
12213 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnanimationend();
12214
12215 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12216 return true;
12217 })());
12218 result
12219}
12220
12221unsafe extern "C" fn set_onanimationend<D: DomTypes>
12222(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12223 let mut result = false;
12224 wrap_panic(&mut || result = {
12225 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12226 let this = &*(this as *const D::Document);
12227 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12228 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12229 } else {
12230 None
12231 };
12232 let result: () = this.SetOnanimationend(arg0);
12233
12234 true
12235 });
12236 result
12237}
12238
12239
12240static onanimationend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12241
12242pub(crate) fn init_onanimationend_getterinfo<D: DomTypes>() {
12243 onanimationend_getterinfo.set(JSJitInfo {
12244 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12245 getter: Some(get_onanimationend::<D>)
12246 },
12247 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12248 protoID: PrototypeList::ID::Document as u16,
12249 },
12250 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12251 _bitfield_align_1: [],
12252 _bitfield_1: __BindgenBitfieldUnit::new(
12253 new_jsjitinfo_bitfield_1!(
12254 JSJitInfo_OpType::Getter as u8,
12255 JSJitInfo_AliasSet::AliasEverything as u8,
12256 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12257 true,
12258 false,
12259 false,
12260 false,
12261 false,
12262 false,
12263 0,
12264 ).to_ne_bytes()
12265 ),
12266});
12267}
12268static onanimationend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12269
12270pub(crate) fn init_onanimationend_setterinfo<D: DomTypes>() {
12271 onanimationend_setterinfo.set(JSJitInfo {
12272 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12273 setter: Some(set_onanimationend::<D>)
12274 },
12275 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12276 protoID: PrototypeList::ID::Document as u16,
12277 },
12278 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12279 _bitfield_align_1: [],
12280 _bitfield_1: __BindgenBitfieldUnit::new(
12281 new_jsjitinfo_bitfield_1!(
12282 JSJitInfo_OpType::Setter as u8,
12283 JSJitInfo_AliasSet::AliasEverything as u8,
12284 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12285 false,
12286 false,
12287 false,
12288 false,
12289 false,
12290 false,
12291 0,
12292 ).to_ne_bytes()
12293 ),
12294});
12295}
12296unsafe extern "C" fn get_onanimationcancel<D: DomTypes>
12297(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12298 let mut result = false;
12299 wrap_panic(&mut || result = (|| {
12300 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12301 let this = &*(this as *const D::Document);
12302 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnanimationcancel();
12303
12304 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12305 return true;
12306 })());
12307 result
12308}
12309
12310unsafe extern "C" fn set_onanimationcancel<D: DomTypes>
12311(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12312 let mut result = false;
12313 wrap_panic(&mut || result = {
12314 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12315 let this = &*(this as *const D::Document);
12316 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12317 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12318 } else {
12319 None
12320 };
12321 let result: () = this.SetOnanimationcancel(arg0);
12322
12323 true
12324 });
12325 result
12326}
12327
12328
12329static onanimationcancel_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12330
12331pub(crate) fn init_onanimationcancel_getterinfo<D: DomTypes>() {
12332 onanimationcancel_getterinfo.set(JSJitInfo {
12333 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12334 getter: Some(get_onanimationcancel::<D>)
12335 },
12336 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12337 protoID: PrototypeList::ID::Document as u16,
12338 },
12339 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12340 _bitfield_align_1: [],
12341 _bitfield_1: __BindgenBitfieldUnit::new(
12342 new_jsjitinfo_bitfield_1!(
12343 JSJitInfo_OpType::Getter as u8,
12344 JSJitInfo_AliasSet::AliasEverything as u8,
12345 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12346 true,
12347 false,
12348 false,
12349 false,
12350 false,
12351 false,
12352 0,
12353 ).to_ne_bytes()
12354 ),
12355});
12356}
12357static onanimationcancel_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12358
12359pub(crate) fn init_onanimationcancel_setterinfo<D: DomTypes>() {
12360 onanimationcancel_setterinfo.set(JSJitInfo {
12361 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12362 setter: Some(set_onanimationcancel::<D>)
12363 },
12364 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12365 protoID: PrototypeList::ID::Document as u16,
12366 },
12367 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12368 _bitfield_align_1: [],
12369 _bitfield_1: __BindgenBitfieldUnit::new(
12370 new_jsjitinfo_bitfield_1!(
12371 JSJitInfo_OpType::Setter as u8,
12372 JSJitInfo_AliasSet::AliasEverything as u8,
12373 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12374 false,
12375 false,
12376 false,
12377 false,
12378 false,
12379 false,
12380 0,
12381 ).to_ne_bytes()
12382 ),
12383});
12384}
12385unsafe extern "C" fn get_ontransitionrun<D: DomTypes>
12386(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12387 let mut result = false;
12388 wrap_panic(&mut || result = (|| {
12389 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12390 let this = &*(this as *const D::Document);
12391 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntransitionrun();
12392
12393 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12394 return true;
12395 })());
12396 result
12397}
12398
12399unsafe extern "C" fn set_ontransitionrun<D: DomTypes>
12400(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12401 let mut result = false;
12402 wrap_panic(&mut || result = {
12403 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12404 let this = &*(this as *const D::Document);
12405 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12406 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12407 } else {
12408 None
12409 };
12410 let result: () = this.SetOntransitionrun(arg0);
12411
12412 true
12413 });
12414 result
12415}
12416
12417
12418static ontransitionrun_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12419
12420pub(crate) fn init_ontransitionrun_getterinfo<D: DomTypes>() {
12421 ontransitionrun_getterinfo.set(JSJitInfo {
12422 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12423 getter: Some(get_ontransitionrun::<D>)
12424 },
12425 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12426 protoID: PrototypeList::ID::Document as u16,
12427 },
12428 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12429 _bitfield_align_1: [],
12430 _bitfield_1: __BindgenBitfieldUnit::new(
12431 new_jsjitinfo_bitfield_1!(
12432 JSJitInfo_OpType::Getter as u8,
12433 JSJitInfo_AliasSet::AliasEverything as u8,
12434 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12435 true,
12436 false,
12437 false,
12438 false,
12439 false,
12440 false,
12441 0,
12442 ).to_ne_bytes()
12443 ),
12444});
12445}
12446static ontransitionrun_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12447
12448pub(crate) fn init_ontransitionrun_setterinfo<D: DomTypes>() {
12449 ontransitionrun_setterinfo.set(JSJitInfo {
12450 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12451 setter: Some(set_ontransitionrun::<D>)
12452 },
12453 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12454 protoID: PrototypeList::ID::Document as u16,
12455 },
12456 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12457 _bitfield_align_1: [],
12458 _bitfield_1: __BindgenBitfieldUnit::new(
12459 new_jsjitinfo_bitfield_1!(
12460 JSJitInfo_OpType::Setter as u8,
12461 JSJitInfo_AliasSet::AliasEverything as u8,
12462 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12463 false,
12464 false,
12465 false,
12466 false,
12467 false,
12468 false,
12469 0,
12470 ).to_ne_bytes()
12471 ),
12472});
12473}
12474unsafe extern "C" fn get_ontransitionend<D: DomTypes>
12475(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12476 let mut result = false;
12477 wrap_panic(&mut || result = (|| {
12478 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12479 let this = &*(this as *const D::Document);
12480 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntransitionend();
12481
12482 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12483 return true;
12484 })());
12485 result
12486}
12487
12488unsafe extern "C" fn set_ontransitionend<D: DomTypes>
12489(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12490 let mut result = false;
12491 wrap_panic(&mut || result = {
12492 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12493 let this = &*(this as *const D::Document);
12494 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12495 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12496 } else {
12497 None
12498 };
12499 let result: () = this.SetOntransitionend(arg0);
12500
12501 true
12502 });
12503 result
12504}
12505
12506
12507static ontransitionend_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12508
12509pub(crate) fn init_ontransitionend_getterinfo<D: DomTypes>() {
12510 ontransitionend_getterinfo.set(JSJitInfo {
12511 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12512 getter: Some(get_ontransitionend::<D>)
12513 },
12514 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12515 protoID: PrototypeList::ID::Document as u16,
12516 },
12517 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12518 _bitfield_align_1: [],
12519 _bitfield_1: __BindgenBitfieldUnit::new(
12520 new_jsjitinfo_bitfield_1!(
12521 JSJitInfo_OpType::Getter as u8,
12522 JSJitInfo_AliasSet::AliasEverything as u8,
12523 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12524 true,
12525 false,
12526 false,
12527 false,
12528 false,
12529 false,
12530 0,
12531 ).to_ne_bytes()
12532 ),
12533});
12534}
12535static ontransitionend_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12536
12537pub(crate) fn init_ontransitionend_setterinfo<D: DomTypes>() {
12538 ontransitionend_setterinfo.set(JSJitInfo {
12539 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12540 setter: Some(set_ontransitionend::<D>)
12541 },
12542 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12543 protoID: PrototypeList::ID::Document as u16,
12544 },
12545 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12546 _bitfield_align_1: [],
12547 _bitfield_1: __BindgenBitfieldUnit::new(
12548 new_jsjitinfo_bitfield_1!(
12549 JSJitInfo_OpType::Setter as u8,
12550 JSJitInfo_AliasSet::AliasEverything as u8,
12551 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12552 false,
12553 false,
12554 false,
12555 false,
12556 false,
12557 false,
12558 0,
12559 ).to_ne_bytes()
12560 ),
12561});
12562}
12563unsafe extern "C" fn get_ontransitioncancel<D: DomTypes>
12564(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12565 let mut result = false;
12566 wrap_panic(&mut || result = (|| {
12567 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12568 let this = &*(this as *const D::Document);
12569 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOntransitioncancel();
12570
12571 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12572 return true;
12573 })());
12574 result
12575}
12576
12577unsafe extern "C" fn set_ontransitioncancel<D: DomTypes>
12578(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12579 let mut result = false;
12580 wrap_panic(&mut || result = {
12581 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12582 let this = &*(this as *const D::Document);
12583 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12584 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12585 } else {
12586 None
12587 };
12588 let result: () = this.SetOntransitioncancel(arg0);
12589
12590 true
12591 });
12592 result
12593}
12594
12595
12596static ontransitioncancel_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12597
12598pub(crate) fn init_ontransitioncancel_getterinfo<D: DomTypes>() {
12599 ontransitioncancel_getterinfo.set(JSJitInfo {
12600 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12601 getter: Some(get_ontransitioncancel::<D>)
12602 },
12603 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12604 protoID: PrototypeList::ID::Document as u16,
12605 },
12606 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12607 _bitfield_align_1: [],
12608 _bitfield_1: __BindgenBitfieldUnit::new(
12609 new_jsjitinfo_bitfield_1!(
12610 JSJitInfo_OpType::Getter as u8,
12611 JSJitInfo_AliasSet::AliasEverything as u8,
12612 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12613 true,
12614 false,
12615 false,
12616 false,
12617 false,
12618 false,
12619 0,
12620 ).to_ne_bytes()
12621 ),
12622});
12623}
12624static ontransitioncancel_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12625
12626pub(crate) fn init_ontransitioncancel_setterinfo<D: DomTypes>() {
12627 ontransitioncancel_setterinfo.set(JSJitInfo {
12628 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12629 setter: Some(set_ontransitioncancel::<D>)
12630 },
12631 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12632 protoID: PrototypeList::ID::Document as u16,
12633 },
12634 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12635 _bitfield_align_1: [],
12636 _bitfield_1: __BindgenBitfieldUnit::new(
12637 new_jsjitinfo_bitfield_1!(
12638 JSJitInfo_OpType::Setter as u8,
12639 JSJitInfo_AliasSet::AliasEverything as u8,
12640 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12641 false,
12642 false,
12643 false,
12644 false,
12645 false,
12646 false,
12647 0,
12648 ).to_ne_bytes()
12649 ),
12650});
12651}
12652unsafe extern "C" fn get_onselectstart<D: DomTypes>
12653(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12654 let mut result = false;
12655 wrap_panic(&mut || result = (|| {
12656 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12657 let this = &*(this as *const D::Document);
12658 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnselectstart();
12659
12660 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12661 return true;
12662 })());
12663 result
12664}
12665
12666unsafe extern "C" fn set_onselectstart<D: DomTypes>
12667(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12668 let mut result = false;
12669 wrap_panic(&mut || result = {
12670 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12671 let this = &*(this as *const D::Document);
12672 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12673 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12674 } else {
12675 None
12676 };
12677 let result: () = this.SetOnselectstart(arg0);
12678
12679 true
12680 });
12681 result
12682}
12683
12684
12685static onselectstart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12686
12687pub(crate) fn init_onselectstart_getterinfo<D: DomTypes>() {
12688 onselectstart_getterinfo.set(JSJitInfo {
12689 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12690 getter: Some(get_onselectstart::<D>)
12691 },
12692 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12693 protoID: PrototypeList::ID::Document as u16,
12694 },
12695 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12696 _bitfield_align_1: [],
12697 _bitfield_1: __BindgenBitfieldUnit::new(
12698 new_jsjitinfo_bitfield_1!(
12699 JSJitInfo_OpType::Getter as u8,
12700 JSJitInfo_AliasSet::AliasEverything as u8,
12701 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12702 true,
12703 false,
12704 false,
12705 false,
12706 false,
12707 false,
12708 0,
12709 ).to_ne_bytes()
12710 ),
12711});
12712}
12713static onselectstart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12714
12715pub(crate) fn init_onselectstart_setterinfo<D: DomTypes>() {
12716 onselectstart_setterinfo.set(JSJitInfo {
12717 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12718 setter: Some(set_onselectstart::<D>)
12719 },
12720 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12721 protoID: PrototypeList::ID::Document as u16,
12722 },
12723 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12724 _bitfield_align_1: [],
12725 _bitfield_1: __BindgenBitfieldUnit::new(
12726 new_jsjitinfo_bitfield_1!(
12727 JSJitInfo_OpType::Setter as u8,
12728 JSJitInfo_AliasSet::AliasEverything as u8,
12729 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12730 false,
12731 false,
12732 false,
12733 false,
12734 false,
12735 false,
12736 0,
12737 ).to_ne_bytes()
12738 ),
12739});
12740}
12741unsafe extern "C" fn get_onselectionchange<D: DomTypes>
12742(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12743 let mut result = false;
12744 wrap_panic(&mut || result = (|| {
12745 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12746 let this = &*(this as *const D::Document);
12747 let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnselectionchange();
12748
12749 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12750 return true;
12751 })());
12752 result
12753}
12754
12755unsafe extern "C" fn set_onselectionchange<D: DomTypes>
12756(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
12757 let mut result = false;
12758 wrap_panic(&mut || result = {
12759 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12760 let this = &*(this as *const D::Document);
12761 let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12762 Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
12763 } else {
12764 None
12765 };
12766 let result: () = this.SetOnselectionchange(arg0);
12767
12768 true
12769 });
12770 result
12771}
12772
12773
12774static onselectionchange_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12775
12776pub(crate) fn init_onselectionchange_getterinfo<D: DomTypes>() {
12777 onselectionchange_getterinfo.set(JSJitInfo {
12778 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12779 getter: Some(get_onselectionchange::<D>)
12780 },
12781 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12782 protoID: PrototypeList::ID::Document as u16,
12783 },
12784 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12785 _bitfield_align_1: [],
12786 _bitfield_1: __BindgenBitfieldUnit::new(
12787 new_jsjitinfo_bitfield_1!(
12788 JSJitInfo_OpType::Getter as u8,
12789 JSJitInfo_AliasSet::AliasEverything as u8,
12790 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12791 true,
12792 false,
12793 false,
12794 false,
12795 false,
12796 false,
12797 0,
12798 ).to_ne_bytes()
12799 ),
12800});
12801}
12802static onselectionchange_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12803
12804pub(crate) fn init_onselectionchange_setterinfo<D: DomTypes>() {
12805 onselectionchange_setterinfo.set(JSJitInfo {
12806 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12807 setter: Some(set_onselectionchange::<D>)
12808 },
12809 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12810 protoID: PrototypeList::ID::Document as u16,
12811 },
12812 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12813 _bitfield_align_1: [],
12814 _bitfield_1: __BindgenBitfieldUnit::new(
12815 new_jsjitinfo_bitfield_1!(
12816 JSJitInfo_OpType::Setter as u8,
12817 JSJitInfo_AliasSet::AliasEverything as u8,
12818 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12819 false,
12820 false,
12821 false,
12822 false,
12823 false,
12824 false,
12825 0,
12826 ).to_ne_bytes()
12827 ),
12828});
12829}
12830unsafe extern "C" fn getElementById<D: DomTypes>
12831(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12832 let mut result = false;
12833 wrap_panic(&mut || result = (|| {
12834 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12835 let this = &*(this as *const D::Document);
12836 let args = &*args;
12837 let argc = args.argc_;
12838
12839 if argc < 1 {
12840 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.getElementById\".");
12841 return false;
12842 }
12843 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
12844 Ok(ConversionResult::Success(value)) => value,
12845 Ok(ConversionResult::Failure(error)) => {
12846 throw_type_error(cx.raw_cx(), &error);
12847 return false;
12848
12849 }
12850 _ => {
12851 return false;
12852
12853 },
12854 }
12855 ;
12856 let result: Option<DomRoot<D::Element>> = this.GetElementById(arg0);
12857
12858 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12859 return true;
12860 })());
12861 result
12862}
12863
12864const getElementById_methodinfo_argTypes: [i32; 2] = [ JSJitInfo_ArgType::String as i32, JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
12865static getElementById_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();
12866
12867pub(crate) fn init_getElementById_methodinfo<D: DomTypes>() {
12868 getElementById_methodinfo.set(JSTypedMethodJitInfo {
12869 base: JSJitInfo {
12870 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12871 method: Some(getElementById::<D>)
12872 },
12873 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12874 protoID: PrototypeList::ID::Document as u16,
12875 },
12876 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12877 _bitfield_align_1: [],
12878 _bitfield_1: __BindgenBitfieldUnit::new(
12879 new_jsjitinfo_bitfield_1!(
12880 JSJitInfo_OpType::Method as u8,
12881 JSJitInfo_AliasSet::AliasDOMSets as u8,
12882 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12883 false,
12884 true,
12885 false,
12886 false,
12887 false,
12888 true,
12889 0,
12890 ).to_ne_bytes()
12891 ),
12892 },
12893 argTypes: &getElementById_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
12894 });
12895}
12896
12897unsafe extern "C" fn get_children<D: DomTypes>
12898(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12899 let mut result = false;
12900 wrap_panic(&mut || result = (|| {
12901 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12902 let this = &*(this as *const D::Document);
12903 let result: DomRoot<D::HTMLCollection> = this.Children(CanGc::note());
12904
12905 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12906 return true;
12907 })());
12908 result
12909}
12910
12911
12912static children_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12913
12914pub(crate) fn init_children_getterinfo<D: DomTypes>() {
12915 children_getterinfo.set(JSJitInfo {
12916 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12917 getter: Some(get_children::<D>)
12918 },
12919 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12920 protoID: PrototypeList::ID::Document as u16,
12921 },
12922 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12923 _bitfield_align_1: [],
12924 _bitfield_1: __BindgenBitfieldUnit::new(
12925 new_jsjitinfo_bitfield_1!(
12926 JSJitInfo_OpType::Getter as u8,
12927 JSJitInfo_AliasSet::AliasNone as u8,
12928 JSValueType::JSVAL_TYPE_OBJECT as u8,
12929 true,
12930 true,
12931 false,
12932 false,
12933 false,
12934 false,
12935 0,
12936 ).to_ne_bytes()
12937 ),
12938});
12939}
12940unsafe extern "C" fn get_firstElementChild<D: DomTypes>
12941(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12942 let mut result = false;
12943 wrap_panic(&mut || result = (|| {
12944 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12945 let this = &*(this as *const D::Document);
12946 let result: Option<DomRoot<D::Element>> = this.GetFirstElementChild();
12947
12948 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12949 return true;
12950 })());
12951 result
12952}
12953
12954
12955static firstElementChild_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12956
12957pub(crate) fn init_firstElementChild_getterinfo<D: DomTypes>() {
12958 firstElementChild_getterinfo.set(JSJitInfo {
12959 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12960 getter: Some(get_firstElementChild::<D>)
12961 },
12962 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12963 protoID: PrototypeList::ID::Document as u16,
12964 },
12965 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
12966 _bitfield_align_1: [],
12967 _bitfield_1: __BindgenBitfieldUnit::new(
12968 new_jsjitinfo_bitfield_1!(
12969 JSJitInfo_OpType::Getter as u8,
12970 JSJitInfo_AliasSet::AliasDOMSets as u8,
12971 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
12972 true,
12973 true,
12974 false,
12975 false,
12976 false,
12977 false,
12978 0,
12979 ).to_ne_bytes()
12980 ),
12981});
12982}
12983unsafe extern "C" fn get_lastElementChild<D: DomTypes>
12984(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
12985 let mut result = false;
12986 wrap_panic(&mut || result = (|| {
12987 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12988 let this = &*(this as *const D::Document);
12989 let result: Option<DomRoot<D::Element>> = this.GetLastElementChild();
12990
12991 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12992 return true;
12993 })());
12994 result
12995}
12996
12997
12998static lastElementChild_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12999
13000pub(crate) fn init_lastElementChild_getterinfo<D: DomTypes>() {
13001 lastElementChild_getterinfo.set(JSJitInfo {
13002 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13003 getter: Some(get_lastElementChild::<D>)
13004 },
13005 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13006 protoID: PrototypeList::ID::Document as u16,
13007 },
13008 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13009 _bitfield_align_1: [],
13010 _bitfield_1: __BindgenBitfieldUnit::new(
13011 new_jsjitinfo_bitfield_1!(
13012 JSJitInfo_OpType::Getter as u8,
13013 JSJitInfo_AliasSet::AliasDOMSets as u8,
13014 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13015 true,
13016 true,
13017 false,
13018 false,
13019 false,
13020 false,
13021 0,
13022 ).to_ne_bytes()
13023 ),
13024});
13025}
13026unsafe extern "C" fn get_childElementCount<D: DomTypes>
13027(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
13028 let mut result = false;
13029 wrap_panic(&mut || result = (|| {
13030 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13031 let this = &*(this as *const D::Document);
13032 let result: u32 = this.ChildElementCount();
13033
13034 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13035 return true;
13036 })());
13037 result
13038}
13039
13040
13041static childElementCount_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13042
13043pub(crate) fn init_childElementCount_getterinfo<D: DomTypes>() {
13044 childElementCount_getterinfo.set(JSJitInfo {
13045 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13046 getter: Some(get_childElementCount::<D>)
13047 },
13048 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13049 protoID: PrototypeList::ID::Document as u16,
13050 },
13051 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13052 _bitfield_align_1: [],
13053 _bitfield_1: __BindgenBitfieldUnit::new(
13054 new_jsjitinfo_bitfield_1!(
13055 JSJitInfo_OpType::Getter as u8,
13056 JSJitInfo_AliasSet::AliasDOMSets as u8,
13057 JSValueType::JSVAL_TYPE_DOUBLE as u8,
13058 true,
13059 true,
13060 false,
13061 false,
13062 false,
13063 false,
13064 0,
13065 ).to_ne_bytes()
13066 ),
13067});
13068}
13069unsafe extern "C" fn prepend<D: DomTypes>
13070(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13071 let mut result = false;
13072 wrap_panic(&mut || result = (|| {
13073 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13074 let this = &*(this as *const D::Document);
13075 let args = &*args;
13076 let argc = args.argc_;
13077
13078 let mut arg0 = vec![];
13079 if argc > 0 {
13080 arg0.reserve(argc as usize);
13081 for variadicArg in 0..argc {
13082 let slot: GenericUnionTypes::NodeOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
13083 Ok(ConversionResult::Success(value)) => value,
13084 Ok(ConversionResult::Failure(error)) => {
13085 throw_type_error(cx.raw_cx(), &error);
13086 return false;
13087
13088 }
13089 _ => {
13090 return false;
13091
13092 },
13093 }
13094 ;
13095 arg0.push(slot);
13096 }
13097 }
13098 <D as DomHelpers<D>>::push_new_element_queue();
13099
13100 let result: Result<(), Error> = this.Prepend(arg0, CanGc::note());
13101 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
13102
13103 let result = match result {
13104 Ok(result) => result,
13105 Err(e) => {
13106 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
13107 return false;
13108 },
13109 };
13110
13111 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13112 return true;
13113 })());
13114 result
13115}
13116
13117
13118static prepend_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13119
13120pub(crate) fn init_prepend_methodinfo<D: DomTypes>() {
13121 prepend_methodinfo.set(JSJitInfo {
13122 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13123 method: Some(prepend::<D>)
13124 },
13125 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13126 protoID: PrototypeList::ID::Document as u16,
13127 },
13128 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13129 _bitfield_align_1: [],
13130 _bitfield_1: __BindgenBitfieldUnit::new(
13131 new_jsjitinfo_bitfield_1!(
13132 JSJitInfo_OpType::Method as u8,
13133 JSJitInfo_AliasSet::AliasEverything as u8,
13134 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13135 false,
13136 false,
13137 false,
13138 false,
13139 false,
13140 false,
13141 0,
13142 ).to_ne_bytes()
13143 ),
13144});
13145}
13146unsafe extern "C" fn append<D: DomTypes>
13147(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13148 let mut result = false;
13149 wrap_panic(&mut || result = (|| {
13150 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13151 let this = &*(this as *const D::Document);
13152 let args = &*args;
13153 let argc = args.argc_;
13154
13155 let mut arg0 = vec![];
13156 if argc > 0 {
13157 arg0.reserve(argc as usize);
13158 for variadicArg in 0..argc {
13159 let slot: GenericUnionTypes::NodeOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
13160 Ok(ConversionResult::Success(value)) => value,
13161 Ok(ConversionResult::Failure(error)) => {
13162 throw_type_error(cx.raw_cx(), &error);
13163 return false;
13164
13165 }
13166 _ => {
13167 return false;
13168
13169 },
13170 }
13171 ;
13172 arg0.push(slot);
13173 }
13174 }
13175 <D as DomHelpers<D>>::push_new_element_queue();
13176
13177 let result: Result<(), Error> = this.Append(arg0, CanGc::note());
13178 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
13179
13180 let result = match result {
13181 Ok(result) => result,
13182 Err(e) => {
13183 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
13184 return false;
13185 },
13186 };
13187
13188 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13189 return true;
13190 })());
13191 result
13192}
13193
13194
13195static append_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13196
13197pub(crate) fn init_append_methodinfo<D: DomTypes>() {
13198 append_methodinfo.set(JSJitInfo {
13199 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13200 method: Some(append::<D>)
13201 },
13202 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13203 protoID: PrototypeList::ID::Document as u16,
13204 },
13205 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13206 _bitfield_align_1: [],
13207 _bitfield_1: __BindgenBitfieldUnit::new(
13208 new_jsjitinfo_bitfield_1!(
13209 JSJitInfo_OpType::Method as u8,
13210 JSJitInfo_AliasSet::AliasEverything as u8,
13211 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13212 false,
13213 false,
13214 false,
13215 false,
13216 false,
13217 false,
13218 0,
13219 ).to_ne_bytes()
13220 ),
13221});
13222}
13223unsafe extern "C" fn replaceChildren<D: DomTypes>
13224(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13225 let mut result = false;
13226 wrap_panic(&mut || result = (|| {
13227 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13228 let this = &*(this as *const D::Document);
13229 let args = &*args;
13230 let argc = args.argc_;
13231
13232 let mut arg0 = vec![];
13233 if argc > 0 {
13234 arg0.reserve(argc as usize);
13235 for variadicArg in 0..argc {
13236 let slot: GenericUnionTypes::NodeOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
13237 Ok(ConversionResult::Success(value)) => value,
13238 Ok(ConversionResult::Failure(error)) => {
13239 throw_type_error(cx.raw_cx(), &error);
13240 return false;
13241
13242 }
13243 _ => {
13244 return false;
13245
13246 },
13247 }
13248 ;
13249 arg0.push(slot);
13250 }
13251 }
13252 <D as DomHelpers<D>>::push_new_element_queue();
13253
13254 let result: Result<(), Error> = this.ReplaceChildren(arg0, CanGc::note());
13255 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
13256
13257 let result = match result {
13258 Ok(result) => result,
13259 Err(e) => {
13260 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
13261 return false;
13262 },
13263 };
13264
13265 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13266 return true;
13267 })());
13268 result
13269}
13270
13271
13272static replaceChildren_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13273
13274pub(crate) fn init_replaceChildren_methodinfo<D: DomTypes>() {
13275 replaceChildren_methodinfo.set(JSJitInfo {
13276 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13277 method: Some(replaceChildren::<D>)
13278 },
13279 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13280 protoID: PrototypeList::ID::Document as u16,
13281 },
13282 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13283 _bitfield_align_1: [],
13284 _bitfield_1: __BindgenBitfieldUnit::new(
13285 new_jsjitinfo_bitfield_1!(
13286 JSJitInfo_OpType::Method as u8,
13287 JSJitInfo_AliasSet::AliasEverything as u8,
13288 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13289 false,
13290 false,
13291 false,
13292 false,
13293 false,
13294 false,
13295 0,
13296 ).to_ne_bytes()
13297 ),
13298});
13299}
13300unsafe extern "C" fn querySelector<D: DomTypes>
13301(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13302 let mut result = false;
13303 wrap_panic(&mut || result = (|| {
13304 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13305 let this = &*(this as *const D::Document);
13306 let args = &*args;
13307 let argc = args.argc_;
13308
13309 if argc < 1 {
13310 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.querySelector\".");
13311 return false;
13312 }
13313 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
13314 Ok(ConversionResult::Success(value)) => value,
13315 Ok(ConversionResult::Failure(error)) => {
13316 throw_type_error(cx.raw_cx(), &error);
13317 return false;
13318
13319 }
13320 _ => {
13321 return false;
13322
13323 },
13324 }
13325 ;
13326 let result: Result<Option<DomRoot<D::Element>>, Error> = this.QuerySelector(arg0);
13327 let result = match result {
13328 Ok(result) => result,
13329 Err(e) => {
13330 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
13331 return false;
13332 },
13333 };
13334
13335 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13336 return true;
13337 })());
13338 result
13339}
13340
13341const querySelector_methodinfo_argTypes: [i32; 2] = [ JSJitInfo_ArgType::String as i32, JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
13342static querySelector_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();
13343
13344pub(crate) fn init_querySelector_methodinfo<D: DomTypes>() {
13345 querySelector_methodinfo.set(JSTypedMethodJitInfo {
13346 base: JSJitInfo {
13347 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13348 method: Some(querySelector::<D>)
13349 },
13350 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13351 protoID: PrototypeList::ID::Document as u16,
13352 },
13353 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13354 _bitfield_align_1: [],
13355 _bitfield_1: __BindgenBitfieldUnit::new(
13356 new_jsjitinfo_bitfield_1!(
13357 JSJitInfo_OpType::Method as u8,
13358 JSJitInfo_AliasSet::AliasDOMSets as u8,
13359 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13360 false,
13361 false,
13362 false,
13363 false,
13364 false,
13365 true,
13366 0,
13367 ).to_ne_bytes()
13368 ),
13369 },
13370 argTypes: &querySelector_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
13371 });
13372}
13373
13374unsafe extern "C" fn querySelectorAll<D: DomTypes>
13375(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13376 let mut result = false;
13377 wrap_panic(&mut || result = (|| {
13378 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13379 let this = &*(this as *const D::Document);
13380 let args = &*args;
13381 let argc = args.argc_;
13382
13383 if argc < 1 {
13384 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.querySelectorAll\".");
13385 return false;
13386 }
13387 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
13388 Ok(ConversionResult::Success(value)) => value,
13389 Ok(ConversionResult::Failure(error)) => {
13390 throw_type_error(cx.raw_cx(), &error);
13391 return false;
13392
13393 }
13394 _ => {
13395 return false;
13396
13397 },
13398 }
13399 ;
13400 let result: Result<DomRoot<D::NodeList>, Error> = this.QuerySelectorAll(arg0);
13401 let result = match result {
13402 Ok(result) => result,
13403 Err(e) => {
13404 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
13405 return false;
13406 },
13407 };
13408
13409 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13410 return true;
13411 })());
13412 result
13413}
13414
13415
13416static querySelectorAll_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13417
13418pub(crate) fn init_querySelectorAll_methodinfo<D: DomTypes>() {
13419 querySelectorAll_methodinfo.set(JSJitInfo {
13420 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13421 method: Some(querySelectorAll::<D>)
13422 },
13423 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13424 protoID: PrototypeList::ID::Document as u16,
13425 },
13426 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13427 _bitfield_align_1: [],
13428 _bitfield_1: __BindgenBitfieldUnit::new(
13429 new_jsjitinfo_bitfield_1!(
13430 JSJitInfo_OpType::Method as u8,
13431 JSJitInfo_AliasSet::AliasEverything as u8,
13432 JSValueType::JSVAL_TYPE_OBJECT as u8,
13433 false,
13434 false,
13435 false,
13436 false,
13437 false,
13438 false,
13439 0,
13440 ).to_ne_bytes()
13441 ),
13442});
13443}
13444unsafe extern "C" fn createExpression<D: DomTypes>
13445(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13446 let mut result = false;
13447 wrap_panic(&mut || result = (|| {
13448 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13449 let this = &*(this as *const D::Document);
13450 let args = &*args;
13451 let argc = args.argc_;
13452
13453 if argc < 1 {
13454 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createExpression\".");
13455 return false;
13456 }
13457 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
13458 Ok(ConversionResult::Success(value)) => value,
13459 Ok(ConversionResult::Failure(error)) => {
13460 throw_type_error(cx.raw_cx(), &error);
13461 return false;
13462
13463 }
13464 _ => {
13465 return false;
13466
13467 },
13468 }
13469 ;
13470 let arg1: Option<Rc<crate::codegen::GenericBindings::XPathNSResolverBinding::XPathNSResolver<D>>> = if args.get(1).is_undefined() {
13471 None
13472 } else if HandleValue::from_raw(args.get(1)).get().is_object() {
13473 Some(crate::codegen::GenericBindings::XPathNSResolverBinding::XPathNSResolver::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(1)).get().to_object()))
13474 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
13475 None
13476 } else {
13477 throw_type_error(cx.raw_cx(), "Value is not an object.");
13478 return false;
13479
13480 };
13481 let result: Result<DomRoot<D::XPathExpression>, Error> = this.CreateExpression(arg0, arg1, CanGc::note());
13482 let result = match result {
13483 Ok(result) => result,
13484 Err(e) => {
13485 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
13486 return false;
13487 },
13488 };
13489
13490 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13491 return true;
13492 })());
13493 result
13494}
13495
13496
13497static createExpression_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13498
13499pub(crate) fn init_createExpression_methodinfo<D: DomTypes>() {
13500 createExpression_methodinfo.set(JSJitInfo {
13501 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13502 method: Some(createExpression::<D>)
13503 },
13504 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13505 protoID: PrototypeList::ID::Document as u16,
13506 },
13507 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13508 _bitfield_align_1: [],
13509 _bitfield_1: __BindgenBitfieldUnit::new(
13510 new_jsjitinfo_bitfield_1!(
13511 JSJitInfo_OpType::Method as u8,
13512 JSJitInfo_AliasSet::AliasEverything as u8,
13513 JSValueType::JSVAL_TYPE_OBJECT as u8,
13514 false,
13515 false,
13516 false,
13517 false,
13518 false,
13519 false,
13520 0,
13521 ).to_ne_bytes()
13522 ),
13523});
13524}
13525unsafe extern "C" fn createNSResolver<D: DomTypes>
13526(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13527 let mut result = false;
13528 wrap_panic(&mut || result = (|| {
13529 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13530 let this = &*(this as *const D::Document);
13531 let args = &*args;
13532 let argc = args.argc_;
13533
13534 if argc < 1 {
13535 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.createNSResolver\".");
13536 return false;
13537 }
13538 let arg0: DomRoot<D::Node> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13539 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
13540 Ok(val) => val,
13541 Err(()) => {
13542 throw_type_error(cx.raw_cx(), "value does not implement interface Node.");
13543 return false;
13544
13545 }
13546 }
13547
13548 } else {
13549 throw_type_error(cx.raw_cx(), "Value is not an object.");
13550 return false;
13551
13552 };
13553 let result: DomRoot<D::Node> = this.CreateNSResolver(&arg0, CanGc::note());
13554
13555 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13556 return true;
13557 })());
13558 result
13559}
13560
13561
13562static createNSResolver_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13563
13564pub(crate) fn init_createNSResolver_methodinfo<D: DomTypes>() {
13565 createNSResolver_methodinfo.set(JSJitInfo {
13566 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13567 method: Some(createNSResolver::<D>)
13568 },
13569 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13570 protoID: PrototypeList::ID::Document as u16,
13571 },
13572 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13573 _bitfield_align_1: [],
13574 _bitfield_1: __BindgenBitfieldUnit::new(
13575 new_jsjitinfo_bitfield_1!(
13576 JSJitInfo_OpType::Method as u8,
13577 JSJitInfo_AliasSet::AliasEverything as u8,
13578 JSValueType::JSVAL_TYPE_OBJECT as u8,
13579 false,
13580 false,
13581 false,
13582 false,
13583 false,
13584 false,
13585 0,
13586 ).to_ne_bytes()
13587 ),
13588});
13589}
13590unsafe extern "C" fn evaluate<D: DomTypes>
13591(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13592 let mut result = false;
13593 wrap_panic(&mut || result = (|| {
13594 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13595 let this = &*(this as *const D::Document);
13596 let args = &*args;
13597 let argc = args.argc_;
13598
13599 if argc < 2 {
13600 throw_type_error(cx.raw_cx(), "Not enough arguments to \"Document.evaluate\".");
13601 return false;
13602 }
13603 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
13604 Ok(ConversionResult::Success(value)) => value,
13605 Ok(ConversionResult::Failure(error)) => {
13606 throw_type_error(cx.raw_cx(), &error);
13607 return false;
13608
13609 }
13610 _ => {
13611 return false;
13612
13613 },
13614 }
13615 ;
13616 let arg1: DomRoot<D::Node> = if HandleValue::from_raw(args.get(1)).get().is_object() {
13617 match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
13618 Ok(val) => val,
13619 Err(()) => {
13620 throw_type_error(cx.raw_cx(), "value does not implement interface Node.");
13621 return false;
13622
13623 }
13624 }
13625
13626 } else {
13627 throw_type_error(cx.raw_cx(), "Value is not an object.");
13628 return false;
13629
13630 };
13631 let arg2: Option<Rc<crate::codegen::GenericBindings::XPathNSResolverBinding::XPathNSResolver<D>>> = if args.get(2).is_undefined() {
13632 None
13633 } else if HandleValue::from_raw(args.get(2)).get().is_object() {
13634 Some(crate::codegen::GenericBindings::XPathNSResolverBinding::XPathNSResolver::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(2)).get().to_object()))
13635 } else if HandleValue::from_raw(args.get(2)).get().is_null_or_undefined() {
13636 None
13637 } else {
13638 throw_type_error(cx.raw_cx(), "Value is not an object.");
13639 return false;
13640
13641 };
13642 let arg3: u16 = if args.get(3).is_undefined() {
13643 0
13644 } else {
13645 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
13646 Ok(ConversionResult::Success(value)) => value,
13647 Ok(ConversionResult::Failure(error)) => {
13648 throw_type_error(cx.raw_cx(), &error);
13649 return false;
13650
13651 }
13652 _ => {
13653 return false;
13654
13655 },
13656 }
13657
13658 };
13659 let arg4: Option<DomRoot<D::XPathResult>> = if args.get(4).is_undefined() {
13660 None
13661 } else if HandleValue::from_raw(args.get(4)).get().is_object() {
13662 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(4)), SafeJSContext::from_ptr(cx.raw_cx())) {
13663 Ok(val) => val,
13664 Err(()) => {
13665 throw_type_error(cx.raw_cx(), "value does not implement interface XPathResult.");
13666 return false;
13667
13668 }
13669 }
13670 )
13671 } else if HandleValue::from_raw(args.get(4)).get().is_null_or_undefined() {
13672 None
13673 } else {
13674 throw_type_error(cx.raw_cx(), "Value is not an object.");
13675 return false;
13676
13677 };
13678 let result: Result<DomRoot<D::XPathResult>, Error> = this.Evaluate(arg0, &arg1, arg2, arg3, arg4.as_deref(), CanGc::note());
13679 let result = match result {
13680 Ok(result) => result,
13681 Err(e) => {
13682 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
13683 return false;
13684 },
13685 };
13686
13687 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13688 return true;
13689 })());
13690 result
13691}
13692
13693
13694static evaluate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13695
13696pub(crate) fn init_evaluate_methodinfo<D: DomTypes>() {
13697 evaluate_methodinfo.set(JSJitInfo {
13698 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13699 method: Some(evaluate::<D>)
13700 },
13701 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13702 protoID: PrototypeList::ID::Document as u16,
13703 },
13704 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 2 },
13705 _bitfield_align_1: [],
13706 _bitfield_1: __BindgenBitfieldUnit::new(
13707 new_jsjitinfo_bitfield_1!(
13708 JSJitInfo_OpType::Method as u8,
13709 JSJitInfo_AliasSet::AliasEverything as u8,
13710 JSValueType::JSVAL_TYPE_OBJECT as u8,
13711 false,
13712 false,
13713 false,
13714 false,
13715 false,
13716 false,
13717 0,
13718 ).to_ne_bytes()
13719 ),
13720});
13721}
13722unsafe extern "C" fn _finalize<D: DomTypes>
13723(_cx: *mut GCContext, obj: *mut JSObject){
13724 wrap_panic(&mut || {
13725
13726 let this = native_from_object_static::<D::Document>(obj).unwrap();
13727 finalize_common(this);
13728 })
13729}
13730
13731unsafe extern "C" fn _trace<D: DomTypes>
13732(trc: *mut JSTracer, obj: *mut JSObject){
13733 wrap_panic(&mut || {
13734
13735 let this = native_from_object_static::<D::Document>(obj).unwrap();
13736 if this.is_null() { return; } (*this).trace(trc);
13738 })
13739}
13740
13741pub unsafe fn DefineProxyHandler<D: DomTypes>
13742() -> *const libc::c_void{
13743
13744 init_proxy_handler_dom_class::<D>();
13745
13746 let traps = ProxyTraps {
13747 enter: None,
13748 getOwnPropertyDescriptor: Some(getOwnPropertyDescriptor::<D>),
13749 defineProperty: Some(proxyhandler::define_property),
13750 ownPropertyKeys: Some(own_property_keys::<D>),
13751 delete_: Some(proxyhandler::delete),
13752 enumerate: None,
13753 getPrototypeIfOrdinary: Some(proxyhandler::get_prototype_if_ordinary),
13754 getPrototype: None,
13755 setPrototype: None,
13756 setImmutablePrototype: None,
13757 preventExtensions: Some(proxyhandler::prevent_extensions),
13758 isExtensible: Some(proxyhandler::is_extensible),
13759 has: None,
13760 get: Some(get::<D>),
13761 set: None,
13762 call: None,
13763 construct: None,
13764 hasOwn: Some(hasOwn::<D>),
13765 getOwnEnumerablePropertyKeys: Some(own_property_keys::<D>),
13766 nativeCall: None,
13767 objectClassIs: None,
13768 className: Some(className),
13769 fun_toString: None,
13770 boxedValue_unbox: None,
13771 defaultValue: None,
13772 trace: Some(_trace::<D>),
13773 finalize: Some(_finalize::<D>),
13774 objectMoved: None,
13775 isCallable: None,
13776 isConstructor: None,
13777 };
13778
13779 CreateProxyHandler(&traps, unsafe { Class.get() }.as_void_ptr())
13780}
13781
13782#[inline] unsafe fn UnwrapProxy<D: DomTypes>
13783(obj: RawHandleObject) -> *const D::Document{
13784
13785 let mut slot = UndefinedValue();
13786 GetProxyReservedSlot(obj.get(), 0, &mut slot);
13787 let box_ = slot.to_private() as *const D::Document;
13788 return box_;
13789}
13790
13791
13792pub static Class: ThreadUnsafeOnceLock<DOMClass> = ThreadUnsafeOnceLock::new();
13793
13794pub(crate) fn init_proxy_handler_dom_class<D: DomTypes>() {
13795 Class.set(
13796DOMClass {
13797 interface_chain: [ PrototypeList::ID::EventTarget, PrototypeList::ID::Node, PrototypeList::ID::Document, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
13798 depth: 2,
13799 type_id: crate::codegen::InheritTypes::TopTypeId { eventtarget: (crate::codegen::InheritTypes::EventTargetTypeId::Node(crate::codegen::InheritTypes::NodeTypeId::Document(crate::codegen::InheritTypes::DocumentTypeId::Document))) },
13800 malloc_size_of: malloc_size_of_including_raw_self::<D::Document> as unsafe fn(&mut _, _) -> _,
13801 global: Globals::EMPTY,
13802});
13803}
13804
13805unsafe extern "C" fn own_property_keys<D: DomTypes>
13806(cx: *mut RawJSContext, proxy: RawHandleObject, props: RawMutableHandleIdVector) -> bool{
13807 let mut result = false;
13808 wrap_panic(&mut || result = (|| {
13809 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13810 let mut cx = CurrentRealm::assert(&mut cx);
13811 let cx = &mut cx;
13812 let unwrapped_proxy = UnwrapProxy::<D>(proxy);
13813 for name in (*unwrapped_proxy).SupportedPropertyNames() {
13814 let cstring = CString::new(name).unwrap();
13815 let jsstring = JS_AtomizeAndPinString(cx.raw_cx(), cstring.as_ptr());
13816 rooted!(&in(cx) let rooted = jsstring);
13817 rooted!(&in(cx) let mut rooted_jsid: jsid);
13818 RUST_INTERNED_STRING_TO_JSID(cx.raw_cx(), rooted.handle().get(), rooted_jsid.handle_mut());
13819 AppendToIdVector(props, rooted_jsid.handle());
13820 }
13821 rooted!(&in(cx) let mut expando = ptr::null_mut::<JSObject>());
13822 get_expando_object(proxy, expando.handle_mut());
13823 if !expando.is_null() &&
13824 !GetPropertyKeys(cx.raw_cx(), expando.handle(), JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, props) {
13825 return false;
13826 }
13827
13828 true
13829
13830 })());
13831 result
13832}
13833
13834unsafe extern "C" fn getOwnPropertyDescriptor<D: DomTypes>
13835(cx: *mut RawJSContext, proxy: RawHandleObject, id: RawHandleId, mut desc: RawMutableHandle<PropertyDescriptor>, is_none: *mut bool) -> bool{
13836 let mut result = false;
13837 wrap_panic(&mut || result = (|| {
13838 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13839 let mut cx = CurrentRealm::assert(&mut cx);
13840 let cx = &mut cx;
13841 rooted!(&in(cx) let mut expando = ptr::null_mut::<JSObject>());
13842 get_expando_object(proxy, expando.handle_mut());
13843 let proxy_lt = Handle::from_raw(proxy);
13845 let id_lt = Handle::from_raw(id);
13846 if !expando.is_null() {
13847 rooted!(&in(cx) let mut ignored = ptr::null_mut::<JSObject>());
13848 if !JS_GetPropertyDescriptorById(cx.raw_cx(), expando.handle().into(), id, desc, ignored.handle_mut().into(), is_none) {
13849 return false;
13850 }
13851 if !*is_none {
13852 return true;
13854 }
13855 }
13856
13857 if id.is_string() || id.is_int() {
13858 let mut has_on_proto = false;
13859 if !has_property_on_prototype(cx.raw_cx(), proxy_lt, id_lt, &mut has_on_proto) {
13860 return false;
13861 }
13862 if !has_on_proto {
13863 let name = jsid_to_string(cx.raw_cx(), Handle::from_raw(id)).expect("Not a string-convertible JSID?");
13864 let this = UnwrapProxy::<D>(proxy);
13865 let this = &*this;
13866 let result: Option<GenericUnionTypes::WindowProxyOrElementOrHTMLCollection::<D>> = this.NamedGetter(name, CanGc::note());
13867
13868 if let Some(result) = result {
13869 rooted!(&in(cx) let mut rval = UndefinedValue());
13870 (result).to_jsval(cx.raw_cx(), rval.handle_mut());
13871 set_property_descriptor(
13872 MutableHandle::from_raw(desc),
13873 rval.handle(),
13874 (JSPROP_ENUMERATE | JSPROP_READONLY) as u32,
13875 &mut *is_none
13876 );
13877 return true;
13878 }
13879 }
13880 }
13881 true
13882 })());
13883 result
13884}
13885
13886unsafe extern "C" fn className(cx: *mut RawJSContext, _proxy: RawHandleObject) -> *const libc::c_char{
13887 c"Document".as_ptr()
13888}
13889
13890unsafe extern "C" fn get<D: DomTypes>
13891(cx: *mut RawJSContext, proxy: RawHandleObject, receiver: RawHandleValue, id: RawHandleId, vp: RawMutableHandleValue) -> bool{
13892 let mut result = false;
13893 wrap_panic(&mut || result = (|| {
13894
13895 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13898 let mut cx = CurrentRealm::assert(&mut cx);
13899 let cx = &mut cx;
13900
13901
13902
13903 let proxy_lt = Handle::from_raw(proxy);
13904 let mut vp_lt = MutableHandle::from_raw(vp);
13905 let id_lt = Handle::from_raw(id);
13906 let receiver_lt = Handle::from_raw(receiver);
13907
13908 rooted!(&in(cx) let mut expando = ptr::null_mut::<JSObject>());
13909 get_expando_object(proxy, expando.handle_mut());
13910 if !expando.is_null() {
13911 let mut hasProp = false;
13912 if !JS_HasPropertyById(cx.raw_cx(), expando.handle().into(), id, &mut hasProp) {
13913 return false;
13914 }
13915
13916 if hasProp {
13917 return JS_ForwardGetPropertyTo(cx.raw_cx(), expando.handle().into(), id, receiver, vp);
13918 }
13919 }
13920
13921 let mut found = false;
13922 if !get_property_on_prototype(cx.raw_cx(), proxy_lt, receiver_lt, id_lt, &mut found, vp_lt.reborrow()) {
13923 return false;
13924 }
13925
13926 if found {
13927 return true;
13928 }
13929 if id.is_string() || id.is_int() {
13930 let name = jsid_to_string(cx.raw_cx(), Handle::from_raw(id)).expect("Not a string-convertible JSID?");
13931 let this = UnwrapProxy::<D>(proxy);
13932 let this = &*this;
13933 let result: Option<GenericUnionTypes::WindowProxyOrElementOrHTMLCollection::<D>> = this.NamedGetter(name, CanGc::note());
13934
13935 if let Some(result) = result {
13936
13937 (result).to_jsval(cx.raw_cx(), vp_lt);
13938 return true;
13939 }}
13940
13941 vp.set(UndefinedValue());
13942 true
13943 })());
13944 result
13945}
13946
13947unsafe extern "C" fn hasOwn<D: DomTypes>
13948(cx: *mut RawJSContext, proxy: RawHandleObject, id: RawHandleId, bp: *mut bool) -> bool{
13949 let mut result = false;
13950 wrap_panic(&mut || result = (|| {
13951 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13952 let mut cx = CurrentRealm::assert(&mut cx);
13953 let cx = &mut cx;
13954 rooted!(&in(cx) let mut expando = ptr::null_mut::<JSObject>());
13955 let proxy_lt = Handle::from_raw(proxy);
13956 let id_lt = Handle::from_raw(id);
13957 get_expando_object(proxy, expando.handle_mut());
13958 if !expando.is_null() {
13959 let ok = JS_HasPropertyById(cx.raw_cx(), expando.handle().into(), id, bp);
13960 if !ok || *bp {
13961 return ok;
13962 }
13963 }
13964
13965 if id.is_string() || id.is_int() {
13966 let mut has_on_proto = false;
13967 if !has_property_on_prototype(cx.raw_cx(), proxy_lt, id_lt, &mut has_on_proto) {
13968 return false;
13969 }
13970 if !has_on_proto {
13971 let name = jsid_to_string(cx.raw_cx(), Handle::from_raw(id)).expect("Not a string-convertible JSID?");
13972 let this = UnwrapProxy::<D>(proxy);
13973 let this = &*this;
13974 let result: Option<GenericUnionTypes::WindowProxyOrElementOrHTMLCollection::<D>> = this.NamedGetter(name, CanGc::note());
13975
13976 *bp = result.is_some();
13977 return true;
13978 }
13979 }
13980
13981 *bp = false;
13982 true
13983 })());
13984 result
13985}
13986
13987#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
13988(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::Document>, _can_gc: CanGc) -> DomRoot<D::Document>{
13989
13990 let raw = Root::new(MaybeUnreflectedDom::from_box(object));
13991
13992 let scope = scope.reflector().get_jsobject();
13993 assert!(!scope.get().is_null());
13994 assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
13995 let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());
13996
13997 rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
13998 GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
13999 assert!(!canonical_proto.is_null());
14000
14001
14002 let handler: *const libc::c_void =
14003 RegisterBindings::proxy_handlers::Document
14004 .load(std::sync::atomic::Ordering::Acquire);
14005 rooted!(&in(cx) let obj = NewProxyObject(
14006 cx.raw_cx(),
14007 handler,
14008 Handle::from_raw(UndefinedHandleValue),
14009 canonical_proto.get(),
14010 ptr::null(),
14011 false,
14012 ));
14013 assert!(!obj.is_null());
14014 SetProxyReservedSlot(
14015 obj.get(),
14016 0,
14017 &PrivateValue(raw.as_ptr() as *const libc::c_void),
14018 );
14019
14020 let root = raw.reflect_with(obj.get());
14021
14022 rooted!(&in(cx) let mut expando = ptr::null_mut::<JSObject>());
14023 ensure_expando_object(cx.raw_cx(), obj.handle().into(), expando.handle_mut());
14024
14025 let mut slot = UndefinedValue();
14026 JS_GetReservedSlot(canonical_proto.get(), DOM_PROTO_UNFORGEABLE_HOLDER_SLOT, &mut slot);
14027 rooted!(&in(cx) let mut unforgeable_holder = ptr::null_mut::<JSObject>());
14028 unforgeable_holder.handle_mut().set(slot.to_object());
14029 assert!(JS_InitializePropertiesFromCompatibleNativeObject(cx.raw_cx(), expando.handle(), unforgeable_holder.handle()));
14030
14031
14032 DomRoot::from_ref(&*root)
14033}
14034
14035const unscopable_names: &[&std::ffi::CStr] = &[
14036 c"prepend",
14037 c"append",
14038 c"replaceChildren"
14039];
14040
14041pub trait DocumentMethods<D: DomTypes> {
14042 fn Implementation(&self, r#_can_gc: CanGc) -> DomRoot<D::DOMImplementation>;
14043 fn URL(&self, ) -> USVString;
14044 fn DocumentURI(&self, ) -> USVString;
14045 fn CompatMode(&self, ) -> DOMString;
14046 fn CharacterSet(&self, ) -> DOMString;
14047 fn Charset(&self, ) -> DOMString;
14048 fn InputEncoding(&self, ) -> DOMString;
14049 fn ContentType(&self, ) -> DOMString;
14050 fn GetDoctype(&self, ) -> Option<DomRoot<D::DocumentType>>;
14051 fn GetDocumentElement(&self, ) -> Option<DomRoot<D::Element>>;
14052 fn GetElementsByTagName(&self, r#qualifiedName: DOMString, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14053 fn GetElementsByTagNameNS(&self, r#namespace: Option<DOMString>, r#qualifiedName: DOMString, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14054 fn GetElementsByClassName(&self, r#classNames: DOMString, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14055 fn CreateElement(&self, r#localName: DOMString, r#options: GenericUnionTypes::StringOrElementCreationOptions, r#_can_gc: CanGc) -> Fallible<DomRoot<D::Element>>;
14056 fn CreateElementNS(&self, r#namespace: Option<DOMString>, r#qualifiedName: DOMString, r#options: GenericUnionTypes::StringOrElementCreationOptions, r#_can_gc: CanGc) -> Fallible<DomRoot<D::Element>>;
14057 fn CreateDocumentFragment(&self, r#_can_gc: CanGc) -> DomRoot<D::DocumentFragment>;
14058 fn CreateTextNode(&self, r#data: DOMString, r#_can_gc: CanGc) -> DomRoot<D::Text>;
14059 fn CreateCDATASection(&self, r#data: DOMString, r#_can_gc: CanGc) -> Fallible<DomRoot<D::CDATASection>>;
14060 fn CreateComment(&self, r#data: DOMString, r#_can_gc: CanGc) -> DomRoot<D::Comment>;
14061 fn CreateProcessingInstruction(&self, r#target: DOMString, r#data: DOMString, r#_can_gc: CanGc) -> Fallible<DomRoot<D::ProcessingInstruction>>;
14062 fn ImportNode(&self, r#node: &D::Node, r#deep: bool, r#_can_gc: CanGc) -> Fallible<DomRoot<D::Node>>;
14063 fn AdoptNode(&self, r#node: &D::Node, r#_can_gc: CanGc) -> Fallible<DomRoot<D::Node>>;
14064 fn CreateAttribute(&self, r#localName: DOMString, r#_can_gc: CanGc) -> Fallible<DomRoot<D::Attr>>;
14065 fn CreateAttributeNS(&self, r#namespace: Option<DOMString>, r#qualifiedName: DOMString, r#_can_gc: CanGc) -> Fallible<DomRoot<D::Attr>>;
14066 fn CreateEvent(&self, r#interface_: DOMString, r#_can_gc: CanGc) -> Fallible<DomRoot<D::Event>>;
14067 fn CreateRange(&self, r#_can_gc: CanGc) -> DomRoot<D::Range>;
14068 fn CreateNodeIterator(&self, r#root: &D::Node, r#whatToShow: u32, r#filter: Option<Rc<crate::codegen::GenericBindings::NodeFilterBinding::NodeFilter<D>>>, r#_can_gc: CanGc) -> DomRoot<D::NodeIterator>;
14069 fn CreateTreeWalker(&self, r#root: &D::Node, r#whatToShow: u32, r#filter: Option<Rc<crate::codegen::GenericBindings::NodeFilterBinding::NodeFilter<D>>>) -> DomRoot<D::TreeWalker>;
14070 fn ParseHTMLUnsafe(r#global: &D::Window, r#html: GenericUnionTypes::TrustedHTMLOrString::<D>, r#_can_gc: CanGc) -> Fallible<DomRoot<D::Document>>;
14071 fn GetLocation(&self, ) -> Option<DomRoot<D::Location>>;
14072 fn Domain(&self, ) -> DOMString;
14073 fn SetDomain(&self, r#value: DOMString) -> ErrorResult;
14074 fn Referrer(&self, ) -> DOMString;
14075 fn GetCookie(&self, ) -> Fallible<DOMString>;
14076 fn SetCookie(&self, r#value: DOMString) -> ErrorResult;
14077 fn LastModified(&self, ) -> DOMString;
14078 fn ReadyState(&self, ) -> DocumentReadyState;
14079 fn Title(&self, ) -> DOMString;
14080 fn SetTitle(&self, r#value: DOMString, r#_can_gc: CanGc);
14081 fn GetBody(&self, ) -> Option<DomRoot<D::HTMLElement>>;
14082 fn SetBody(&self, r#value: Option<&D::HTMLElement>, r#_can_gc: CanGc) -> ErrorResult;
14083 fn GetHead(&self, ) -> Option<DomRoot<D::HTMLHeadElement>>;
14084 fn Images(&self, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14085 fn Embeds(&self, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14086 fn Plugins(&self, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14087 fn Links(&self, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14088 fn Forms(&self, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14089 fn Scripts(&self, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14090 fn GetElementsByName(&self, r#elementName: DOMString, r#_can_gc: CanGc) -> DomRoot<D::NodeList>;
14091 fn GetCurrentScript(&self, ) -> Option<DomRoot<D::HTMLScriptElement>>;
14092 fn Open(&self, r#unused1: Option<DOMString>, r#unused2: Option<DOMString>, r#_can_gc: CanGc) -> Fallible<DomRoot<D::Document>>;
14093 fn Open_(&self, r#url: USVString, r#name: DOMString, r#features: DOMString, r#_can_gc: CanGc) -> Fallible<Option<DomRoot<D::WindowProxy>>>;
14094 fn Close(&self, r#_can_gc: CanGc) -> Fallible<()>;
14095 fn Write(&self, r#text: Vec<GenericUnionTypes::TrustedHTMLOrString::<D>>, r#_can_gc: CanGc) -> Fallible<()>;
14096 fn Writeln(&self, r#text: Vec<GenericUnionTypes::TrustedHTMLOrString::<D>>, r#_can_gc: CanGc) -> Fallible<()>;
14097 fn GetDefaultView(&self, ) -> Option<DomRoot<D::Window>>;
14098 fn HasFocus(&self, ) -> bool;
14099 fn QueryCommandSupported(&self, r#commandId: DOMString) -> bool;
14100 fn Hidden(&self, ) -> bool;
14101 fn VisibilityState(&self, ) -> DocumentVisibilityState;
14102 fn GetOnreadystatechange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14103 fn SetOnreadystatechange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14104 fn FgColor(&self, ) -> DOMString;
14105 fn SetFgColor(&self, r#value: DOMString, r#_can_gc: CanGc);
14106 fn BgColor(&self, ) -> DOMString;
14107 fn SetBgColor(&self, r#value: DOMString, r#_can_gc: CanGc);
14108 fn Anchors(&self, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14109 fn Applets(&self, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14110 fn Clear(&self, );
14111 fn CaptureEvents(&self, );
14112 fn ReleaseEvents(&self, );
14113 fn FullscreenEnabled(&self, ) -> bool;
14114 fn GetFullscreenElement(&self, ) -> Option<DomRoot<D::Element>>;
14115 fn Fullscreen(&self, ) -> bool;
14116 fn ExitFullscreen(&self, r#_can_gc: CanGc) -> Rc<D::Promise>;
14117 fn GetOnfullscreenchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14118 fn SetOnfullscreenchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14119 fn GetOnfullscreenerror(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14120 fn SetOnfullscreenerror(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14121 fn GetScrollingElement(&self, ) -> Option<DomRoot<D::Element>>;
14122 fn GetSelection(&self, r#_can_gc: CanGc) -> Option<DomRoot<D::Selection>>;
14123 fn ServoGetMediaControls(&self, r#id: DOMString) -> Fallible<DomRoot<D::ShadowRoot>>;
14124 fn ElementFromPoint(&self, r#x: Finite<f64>, r#y: Finite<f64>) -> Option<DomRoot<D::Element>>;
14125 fn ElementsFromPoint(&self, r#x: Finite<f64>, r#y: Finite<f64>) -> Vec<DomRoot<D::Element>>;
14126 fn GetActiveElement(&self, ) -> Option<DomRoot<D::Element>>;
14127 fn StyleSheets(&self, r#_can_gc: CanGc) -> DomRoot<D::StyleSheetList>;
14128 fn AdoptedStyleSheets(&self, r#cx: SafeJSContext, r#_can_gc: CanGc, r#retval: MutableHandleValue);
14129 fn SetAdoptedStyleSheets(&self, r#cx: SafeJSContext, r#value: HandleValue, r#_can_gc: CanGc) -> ErrorResult;
14130 fn Fonts(&self, r#_can_gc: CanGc) -> DomRoot<D::FontFaceSet>;
14131 fn GetOnabort(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14132 fn SetOnabort(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14133 fn GetOnauxclick(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14134 fn SetOnauxclick(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14135 fn GetOnbeforeinput(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14136 fn SetOnbeforeinput(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14137 fn GetOnbeforematch(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14138 fn SetOnbeforematch(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14139 fn GetOnbeforetoggle(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14140 fn SetOnbeforetoggle(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14141 fn GetOnblur(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14142 fn SetOnblur(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14143 fn GetOncancel(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14144 fn SetOncancel(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14145 fn GetOncanplay(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14146 fn SetOncanplay(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14147 fn GetOncanplaythrough(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14148 fn SetOncanplaythrough(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14149 fn GetOnchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14150 fn SetOnchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14151 fn GetOnclick(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14152 fn SetOnclick(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14153 fn GetOnclose(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14154 fn SetOnclose(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14155 fn GetOncommand(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14156 fn SetOncommand(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14157 fn GetOncontextlost(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14158 fn SetOncontextlost(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14159 fn GetOncontextmenu(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14160 fn SetOncontextmenu(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14161 fn GetOncontextrestored(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14162 fn SetOncontextrestored(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14163 fn GetOncopy(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14164 fn SetOncopy(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14165 fn GetOncuechange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14166 fn SetOncuechange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14167 fn GetOncut(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14168 fn SetOncut(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14169 fn GetOndblclick(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14170 fn SetOndblclick(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14171 fn GetOndrag(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14172 fn SetOndrag(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14173 fn GetOndragend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14174 fn SetOndragend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14175 fn GetOndragenter(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14176 fn SetOndragenter(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14177 fn GetOndragleave(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14178 fn SetOndragleave(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14179 fn GetOndragover(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14180 fn SetOndragover(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14181 fn GetOndragstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14182 fn SetOndragstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14183 fn GetOndrop(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14184 fn SetOndrop(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14185 fn GetOndurationchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14186 fn SetOndurationchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14187 fn GetOnemptied(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14188 fn SetOnemptied(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14189 fn GetOnended(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14190 fn SetOnended(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14191 fn GetOnerror(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::OnErrorEventHandlerNonNull<D>>>;
14192 fn SetOnerror(&self, r#value: Option<Rc<OnErrorEventHandlerNonNull<D>>>);
14193 fn GetOnfocus(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14194 fn SetOnfocus(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14195 fn GetOnformdata(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14196 fn SetOnformdata(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14197 fn GetOninput(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14198 fn SetOninput(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14199 fn GetOninvalid(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14200 fn SetOninvalid(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14201 fn GetOnkeydown(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14202 fn SetOnkeydown(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14203 fn GetOnkeypress(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14204 fn SetOnkeypress(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14205 fn GetOnkeyup(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14206 fn SetOnkeyup(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14207 fn GetOnload(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14208 fn SetOnload(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14209 fn GetOnloadeddata(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14210 fn SetOnloadeddata(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14211 fn GetOnloadedmetadata(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14212 fn SetOnloadedmetadata(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14213 fn GetOnloadstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14214 fn SetOnloadstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14215 fn GetOnmousedown(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14216 fn SetOnmousedown(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14217 fn GetOnmouseenter(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14218 fn SetOnmouseenter(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14219 fn GetOnmouseleave(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14220 fn SetOnmouseleave(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14221 fn GetOnmousemove(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14222 fn SetOnmousemove(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14223 fn GetOnmouseout(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14224 fn SetOnmouseout(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14225 fn GetOnmouseover(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14226 fn SetOnmouseover(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14227 fn GetOnmouseup(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14228 fn SetOnmouseup(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14229 fn GetOnpaste(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14230 fn SetOnpaste(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14231 fn GetOnpause(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14232 fn SetOnpause(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14233 fn GetOnplay(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14234 fn SetOnplay(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14235 fn GetOnplaying(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14236 fn SetOnplaying(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14237 fn GetOnprogress(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14238 fn SetOnprogress(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14239 fn GetOnratechange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14240 fn SetOnratechange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14241 fn GetOnreset(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14242 fn SetOnreset(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14243 fn GetOnresize(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14244 fn SetOnresize(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14245 fn GetOnscroll(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14246 fn SetOnscroll(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14247 fn GetOnscrollend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14248 fn SetOnscrollend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14249 fn GetOnsecuritypolicyviolation(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14250 fn SetOnsecuritypolicyviolation(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14251 fn GetOnseeked(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14252 fn SetOnseeked(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14253 fn GetOnseeking(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14254 fn SetOnseeking(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14255 fn GetOnselect(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14256 fn SetOnselect(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14257 fn GetOnslotchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14258 fn SetOnslotchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14259 fn GetOnstalled(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14260 fn SetOnstalled(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14261 fn GetOnsubmit(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14262 fn SetOnsubmit(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14263 fn GetOnsuspend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14264 fn SetOnsuspend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14265 fn GetOntimeupdate(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14266 fn SetOntimeupdate(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14267 fn GetOntoggle(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14268 fn SetOntoggle(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14269 fn GetOnvolumechange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14270 fn SetOnvolumechange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14271 fn GetOnwaiting(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14272 fn SetOnwaiting(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14273 fn GetOnwebkitanimationend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14274 fn SetOnwebkitanimationend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14275 fn GetOnwebkitanimationiteration(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14276 fn SetOnwebkitanimationiteration(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14277 fn GetOnwebkitanimationstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14278 fn SetOnwebkitanimationstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14279 fn GetOnwebkittransitionend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14280 fn SetOnwebkittransitionend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14281 fn GetOnwheel(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14282 fn SetOnwheel(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14283 fn GetOnanimationstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14284 fn SetOnanimationstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14285 fn GetOnanimationiteration(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14286 fn SetOnanimationiteration(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14287 fn GetOnanimationend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14288 fn SetOnanimationend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14289 fn GetOnanimationcancel(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14290 fn SetOnanimationcancel(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14291 fn GetOntransitionrun(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14292 fn SetOntransitionrun(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14293 fn GetOntransitionend(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14294 fn SetOntransitionend(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14295 fn GetOntransitioncancel(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14296 fn SetOntransitioncancel(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14297 fn GetOnselectstart(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14298 fn SetOnselectstart(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14299 fn GetOnselectionchange(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
14300 fn SetOnselectionchange(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
14301 fn GetElementById(&self, r#elementId: DOMString) -> Option<DomRoot<D::Element>>;
14302 fn Children(&self, r#_can_gc: CanGc) -> DomRoot<D::HTMLCollection>;
14303 fn GetFirstElementChild(&self, ) -> Option<DomRoot<D::Element>>;
14304 fn GetLastElementChild(&self, ) -> Option<DomRoot<D::Element>>;
14305 fn ChildElementCount(&self, ) -> u32;
14306 fn Prepend(&self, r#nodes: Vec<GenericUnionTypes::NodeOrString::<D>>, r#_can_gc: CanGc) -> Fallible<()>;
14307 fn Append(&self, r#nodes: Vec<GenericUnionTypes::NodeOrString::<D>>, r#_can_gc: CanGc) -> Fallible<()>;
14308 fn ReplaceChildren(&self, r#nodes: Vec<GenericUnionTypes::NodeOrString::<D>>, r#_can_gc: CanGc) -> Fallible<()>;
14309 fn QuerySelector(&self, r#selectors: DOMString) -> Fallible<Option<DomRoot<D::Element>>>;
14310 fn QuerySelectorAll(&self, r#selectors: DOMString) -> Fallible<DomRoot<D::NodeList>>;
14311 fn CreateExpression(&self, r#expression: DOMString, r#resolver: Option<Rc<crate::codegen::GenericBindings::XPathNSResolverBinding::XPathNSResolver<D>>>, r#_can_gc: CanGc) -> Fallible<DomRoot<D::XPathExpression>>;
14312 fn CreateNSResolver(&self, r#nodeResolver: &D::Node, r#_can_gc: CanGc) -> DomRoot<D::Node>;
14313 fn Evaluate(&self, r#expression: DOMString, r#contextNode: &D::Node, r#resolver: Option<Rc<crate::codegen::GenericBindings::XPathNSResolverBinding::XPathNSResolver<D>>>, r#type_: u16, r#result: Option<&D::XPathResult>, r#_can_gc: CanGc) -> Fallible<DomRoot<D::XPathResult>>;
14314 fn SupportedPropertyNames(&self, ) -> Vec<DOMString>;
14315 fn NamedGetter(&self, r#name: DOMString, r#_can_gc: CanGc) -> Option<GenericUnionTypes::WindowProxyOrElementOrHTMLCollection::<D>>;
14316 fn Constructor(r#global: &D::Window, r#proto: Option<HandleObject>, r#can_gc: CanGc) -> Fallible<DomRoot<D::Document>>;
14317}
14318static sStaticMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
14319
14320pub(crate) fn init_sStaticMethods_specs<D: DomTypes>() {
14321 sStaticMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
14322 JSFunctionSpec {
14323 name: JSPropertySpec_Name { string_: c"parseHTMLUnsafe".as_ptr() },
14324 call: JSNativeWrapper { op: Some(parseHTMLUnsafe::<D>), info: ptr::null() },
14325 nargs: 1,
14326 flags: (JSPROP_ENUMERATE) as u16,
14327 selfHostedName: ptr::null()
14328 },
14329 JSFunctionSpec {
14330 name: JSPropertySpec_Name { string_: ptr::null() },
14331 call: JSNativeWrapper { op: None, info: ptr::null() },
14332 nargs: 0,
14333 flags: 0,
14334 selfHostedName: ptr::null()
14335 }]))[..]
14336])));
14337}static sStaticMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
14338
14339pub(crate) fn init_sStaticMethods_prefs<D: DomTypes>() {
14340 sStaticMethods.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sStaticMethods_specs.get() })[0])])));
14341}static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
14342
14343pub(crate) fn init_sMethods_specs<D: DomTypes>() {
14344 sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
14345 JSFunctionSpec {
14346 name: JSPropertySpec_Name { string_: c"getElementsByTagName".as_ptr() },
14347 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getElementsByTagName_methodinfo.get() } as *const _ as *const JSJitInfo },
14348 nargs: 1,
14349 flags: (JSPROP_ENUMERATE) as u16,
14350 selfHostedName: ptr::null()
14351 },
14352 JSFunctionSpec {
14353 name: JSPropertySpec_Name { string_: c"getElementsByTagNameNS".as_ptr() },
14354 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getElementsByTagNameNS_methodinfo.get() } as *const _ as *const JSJitInfo },
14355 nargs: 2,
14356 flags: (JSPROP_ENUMERATE) as u16,
14357 selfHostedName: ptr::null()
14358 },
14359 JSFunctionSpec {
14360 name: JSPropertySpec_Name { string_: c"getElementsByClassName".as_ptr() },
14361 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getElementsByClassName_methodinfo.get() } as *const _ as *const JSJitInfo },
14362 nargs: 1,
14363 flags: (JSPROP_ENUMERATE) as u16,
14364 selfHostedName: ptr::null()
14365 },
14366 JSFunctionSpec {
14367 name: JSPropertySpec_Name { string_: c"createElement".as_ptr() },
14368 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createElement_methodinfo.get() } as *const _ as *const JSJitInfo },
14369 nargs: 1,
14370 flags: (JSPROP_ENUMERATE) as u16,
14371 selfHostedName: ptr::null()
14372 },
14373 JSFunctionSpec {
14374 name: JSPropertySpec_Name { string_: c"createElementNS".as_ptr() },
14375 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createElementNS_methodinfo.get() } as *const _ as *const JSJitInfo },
14376 nargs: 2,
14377 flags: (JSPROP_ENUMERATE) as u16,
14378 selfHostedName: ptr::null()
14379 },
14380 JSFunctionSpec {
14381 name: JSPropertySpec_Name { string_: c"createDocumentFragment".as_ptr() },
14382 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createDocumentFragment_methodinfo.get() } as *const _ as *const JSJitInfo },
14383 nargs: 0,
14384 flags: (JSPROP_ENUMERATE) as u16,
14385 selfHostedName: ptr::null()
14386 },
14387 JSFunctionSpec {
14388 name: JSPropertySpec_Name { string_: c"createTextNode".as_ptr() },
14389 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createTextNode_methodinfo.get() } as *const _ as *const JSJitInfo },
14390 nargs: 1,
14391 flags: (JSPROP_ENUMERATE) as u16,
14392 selfHostedName: ptr::null()
14393 },
14394 JSFunctionSpec {
14395 name: JSPropertySpec_Name { string_: c"createCDATASection".as_ptr() },
14396 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createCDATASection_methodinfo.get() } as *const _ as *const JSJitInfo },
14397 nargs: 1,
14398 flags: (JSPROP_ENUMERATE) as u16,
14399 selfHostedName: ptr::null()
14400 },
14401 JSFunctionSpec {
14402 name: JSPropertySpec_Name { string_: c"createComment".as_ptr() },
14403 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createComment_methodinfo.get() } as *const _ as *const JSJitInfo },
14404 nargs: 1,
14405 flags: (JSPROP_ENUMERATE) as u16,
14406 selfHostedName: ptr::null()
14407 },
14408 JSFunctionSpec {
14409 name: JSPropertySpec_Name { string_: c"createProcessingInstruction".as_ptr() },
14410 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createProcessingInstruction_methodinfo.get() } as *const _ as *const JSJitInfo },
14411 nargs: 2,
14412 flags: (JSPROP_ENUMERATE) as u16,
14413 selfHostedName: ptr::null()
14414 },
14415 JSFunctionSpec {
14416 name: JSPropertySpec_Name { string_: c"importNode".as_ptr() },
14417 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { importNode_methodinfo.get() } as *const _ as *const JSJitInfo },
14418 nargs: 1,
14419 flags: (JSPROP_ENUMERATE) as u16,
14420 selfHostedName: ptr::null()
14421 },
14422 JSFunctionSpec {
14423 name: JSPropertySpec_Name { string_: c"adoptNode".as_ptr() },
14424 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { adoptNode_methodinfo.get() } as *const _ as *const JSJitInfo },
14425 nargs: 1,
14426 flags: (JSPROP_ENUMERATE) as u16,
14427 selfHostedName: ptr::null()
14428 },
14429 JSFunctionSpec {
14430 name: JSPropertySpec_Name { string_: c"createAttribute".as_ptr() },
14431 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createAttribute_methodinfo.get() } as *const _ as *const JSJitInfo },
14432 nargs: 1,
14433 flags: (JSPROP_ENUMERATE) as u16,
14434 selfHostedName: ptr::null()
14435 },
14436 JSFunctionSpec {
14437 name: JSPropertySpec_Name { string_: c"createAttributeNS".as_ptr() },
14438 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createAttributeNS_methodinfo.get() } as *const _ as *const JSJitInfo },
14439 nargs: 2,
14440 flags: (JSPROP_ENUMERATE) as u16,
14441 selfHostedName: ptr::null()
14442 },
14443 JSFunctionSpec {
14444 name: JSPropertySpec_Name { string_: c"createEvent".as_ptr() },
14445 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createEvent_methodinfo.get() } as *const _ as *const JSJitInfo },
14446 nargs: 1,
14447 flags: (JSPROP_ENUMERATE) as u16,
14448 selfHostedName: ptr::null()
14449 },
14450 JSFunctionSpec {
14451 name: JSPropertySpec_Name { string_: c"createRange".as_ptr() },
14452 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createRange_methodinfo.get() } as *const _ as *const JSJitInfo },
14453 nargs: 0,
14454 flags: (JSPROP_ENUMERATE) as u16,
14455 selfHostedName: ptr::null()
14456 },
14457 JSFunctionSpec {
14458 name: JSPropertySpec_Name { string_: c"createNodeIterator".as_ptr() },
14459 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createNodeIterator_methodinfo.get() } as *const _ as *const JSJitInfo },
14460 nargs: 1,
14461 flags: (JSPROP_ENUMERATE) as u16,
14462 selfHostedName: ptr::null()
14463 },
14464 JSFunctionSpec {
14465 name: JSPropertySpec_Name { string_: c"createTreeWalker".as_ptr() },
14466 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createTreeWalker_methodinfo.get() } as *const _ as *const JSJitInfo },
14467 nargs: 1,
14468 flags: (JSPROP_ENUMERATE) as u16,
14469 selfHostedName: ptr::null()
14470 },
14471 JSFunctionSpec {
14472 name: JSPropertySpec_Name { string_: c"getElementsByName".as_ptr() },
14473 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getElementsByName_methodinfo.get() } as *const _ as *const JSJitInfo },
14474 nargs: 1,
14475 flags: (JSPROP_ENUMERATE) as u16,
14476 selfHostedName: ptr::null()
14477 },
14478 JSFunctionSpec {
14479 name: JSPropertySpec_Name { string_: c"open".as_ptr() },
14480 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { open_methodinfo.get() } as *const _ as *const JSJitInfo },
14481 nargs: 0,
14482 flags: (JSPROP_ENUMERATE) as u16,
14483 selfHostedName: ptr::null()
14484 },
14485 JSFunctionSpec {
14486 name: JSPropertySpec_Name { string_: c"close".as_ptr() },
14487 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { close_methodinfo.get() } as *const _ as *const JSJitInfo },
14488 nargs: 0,
14489 flags: (JSPROP_ENUMERATE) as u16,
14490 selfHostedName: ptr::null()
14491 },
14492 JSFunctionSpec {
14493 name: JSPropertySpec_Name { string_: c"write".as_ptr() },
14494 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { write_methodinfo.get() } as *const _ as *const JSJitInfo },
14495 nargs: 0,
14496 flags: (JSPROP_ENUMERATE) as u16,
14497 selfHostedName: ptr::null()
14498 },
14499 JSFunctionSpec {
14500 name: JSPropertySpec_Name { string_: c"writeln".as_ptr() },
14501 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { writeln_methodinfo.get() } as *const _ as *const JSJitInfo },
14502 nargs: 0,
14503 flags: (JSPROP_ENUMERATE) as u16,
14504 selfHostedName: ptr::null()
14505 },
14506 JSFunctionSpec {
14507 name: JSPropertySpec_Name { string_: c"hasFocus".as_ptr() },
14508 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { hasFocus_methodinfo.get() } as *const _ as *const JSJitInfo },
14509 nargs: 0,
14510 flags: (JSPROP_ENUMERATE) as u16,
14511 selfHostedName: ptr::null()
14512 },
14513 JSFunctionSpec {
14514 name: JSPropertySpec_Name { string_: c"queryCommandSupported".as_ptr() },
14515 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { queryCommandSupported_methodinfo.get() } as *const _ as *const JSJitInfo },
14516 nargs: 1,
14517 flags: (JSPROP_ENUMERATE) as u16,
14518 selfHostedName: ptr::null()
14519 },
14520 JSFunctionSpec {
14521 name: JSPropertySpec_Name { string_: c"clear".as_ptr() },
14522 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clear_methodinfo.get() } as *const _ as *const JSJitInfo },
14523 nargs: 0,
14524 flags: (JSPROP_ENUMERATE) as u16,
14525 selfHostedName: ptr::null()
14526 },
14527 JSFunctionSpec {
14528 name: JSPropertySpec_Name { string_: c"captureEvents".as_ptr() },
14529 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { captureEvents_methodinfo.get() } as *const _ as *const JSJitInfo },
14530 nargs: 0,
14531 flags: (JSPROP_ENUMERATE) as u16,
14532 selfHostedName: ptr::null()
14533 },
14534 JSFunctionSpec {
14535 name: JSPropertySpec_Name { string_: c"releaseEvents".as_ptr() },
14536 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { releaseEvents_methodinfo.get() } as *const _ as *const JSJitInfo },
14537 nargs: 0,
14538 flags: (JSPROP_ENUMERATE) as u16,
14539 selfHostedName: ptr::null()
14540 },
14541 JSFunctionSpec {
14542 name: JSPropertySpec_Name { string_: c"exitFullscreen".as_ptr() },
14543 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { exitFullscreen_methodinfo.get() } as *const _ as *const JSJitInfo },
14544 nargs: 0,
14545 flags: (JSPROP_ENUMERATE) as u16,
14546 selfHostedName: ptr::null()
14547 },
14548 JSFunctionSpec {
14549 name: JSPropertySpec_Name { string_: c"getSelection".as_ptr() },
14550 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getSelection_methodinfo.get() } as *const _ as *const JSJitInfo },
14551 nargs: 0,
14552 flags: (JSPROP_ENUMERATE) as u16,
14553 selfHostedName: ptr::null()
14554 },
14555 JSFunctionSpec {
14556 name: JSPropertySpec_Name { string_: c"servoGetMediaControls".as_ptr() },
14557 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { servoGetMediaControls_methodinfo.get() } as *const _ as *const JSJitInfo },
14558 nargs: 1,
14559 flags: (JSPROP_ENUMERATE) as u16,
14560 selfHostedName: ptr::null()
14561 },
14562 JSFunctionSpec {
14563 name: JSPropertySpec_Name { string_: c"elementFromPoint".as_ptr() },
14564 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { elementFromPoint_methodinfo.get() } as *const _ as *const JSJitInfo },
14565 nargs: 2,
14566 flags: (JSPROP_ENUMERATE) as u16,
14567 selfHostedName: ptr::null()
14568 },
14569 JSFunctionSpec {
14570 name: JSPropertySpec_Name { string_: c"elementsFromPoint".as_ptr() },
14571 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { elementsFromPoint_methodinfo.get() } as *const _ as *const JSJitInfo },
14572 nargs: 2,
14573 flags: (JSPROP_ENUMERATE) as u16,
14574 selfHostedName: ptr::null()
14575 },
14576 JSFunctionSpec {
14577 name: JSPropertySpec_Name { string_: c"getElementById".as_ptr() },
14578 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getElementById_methodinfo.get() } as *const _ as *const JSJitInfo },
14579 nargs: 1,
14580 flags: (JSPROP_ENUMERATE) as u16,
14581 selfHostedName: ptr::null()
14582 },
14583 JSFunctionSpec {
14584 name: JSPropertySpec_Name { string_: c"prepend".as_ptr() },
14585 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { prepend_methodinfo.get() } as *const _ as *const JSJitInfo },
14586 nargs: 0,
14587 flags: (JSPROP_ENUMERATE) as u16,
14588 selfHostedName: ptr::null()
14589 },
14590 JSFunctionSpec {
14591 name: JSPropertySpec_Name { string_: c"append".as_ptr() },
14592 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { append_methodinfo.get() } as *const _ as *const JSJitInfo },
14593 nargs: 0,
14594 flags: (JSPROP_ENUMERATE) as u16,
14595 selfHostedName: ptr::null()
14596 },
14597 JSFunctionSpec {
14598 name: JSPropertySpec_Name { string_: c"replaceChildren".as_ptr() },
14599 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { replaceChildren_methodinfo.get() } as *const _ as *const JSJitInfo },
14600 nargs: 0,
14601 flags: (JSPROP_ENUMERATE) as u16,
14602 selfHostedName: ptr::null()
14603 },
14604 JSFunctionSpec {
14605 name: JSPropertySpec_Name { string_: c"querySelector".as_ptr() },
14606 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { querySelector_methodinfo.get() } as *const _ as *const JSJitInfo },
14607 nargs: 1,
14608 flags: (JSPROP_ENUMERATE) as u16,
14609 selfHostedName: ptr::null()
14610 },
14611 JSFunctionSpec {
14612 name: JSPropertySpec_Name { string_: c"querySelectorAll".as_ptr() },
14613 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { querySelectorAll_methodinfo.get() } as *const _ as *const JSJitInfo },
14614 nargs: 1,
14615 flags: (JSPROP_ENUMERATE) as u16,
14616 selfHostedName: ptr::null()
14617 },
14618 JSFunctionSpec {
14619 name: JSPropertySpec_Name { string_: c"createExpression".as_ptr() },
14620 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createExpression_methodinfo.get() } as *const _ as *const JSJitInfo },
14621 nargs: 1,
14622 flags: (JSPROP_ENUMERATE) as u16,
14623 selfHostedName: ptr::null()
14624 },
14625 JSFunctionSpec {
14626 name: JSPropertySpec_Name { string_: c"createNSResolver".as_ptr() },
14627 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createNSResolver_methodinfo.get() } as *const _ as *const JSJitInfo },
14628 nargs: 1,
14629 flags: (JSPROP_ENUMERATE) as u16,
14630 selfHostedName: ptr::null()
14631 },
14632 JSFunctionSpec {
14633 name: JSPropertySpec_Name { string_: c"evaluate".as_ptr() },
14634 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { evaluate_methodinfo.get() } as *const _ as *const JSJitInfo },
14635 nargs: 2,
14636 flags: (JSPROP_ENUMERATE) as u16,
14637 selfHostedName: ptr::null()
14638 },
14639 JSFunctionSpec {
14640 name: JSPropertySpec_Name { string_: ptr::null() },
14641 call: JSNativeWrapper { op: None, info: ptr::null() },
14642 nargs: 0,
14643 flags: 0,
14644 selfHostedName: ptr::null()
14645 }]))[..]
14646])));
14647}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
14648
14649pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
14650 sMethods.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sMethods_specs.get() })[0])])));
14651}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
14652
14653pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
14654 sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
14655 JSPropertySpec {
14656 name: JSPropertySpec_Name { string_: c"implementation".as_ptr() },
14657 attributes_: (JSPROP_ENUMERATE),
14658 kind_: (JSPropertySpec_Kind::NativeAccessor),
14659 u: JSPropertySpec_AccessorsOrValue {
14660 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14661 getter: JSPropertySpec_Accessor {
14662 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { implementation_getterinfo.get() } },
14663 },
14664 setter: JSPropertySpec_Accessor {
14665 native: JSNativeWrapper { op: None, info: ptr::null() },
14666 }
14667 }
14668 }
14669 }
14670,
14671 JSPropertySpec {
14672 name: JSPropertySpec_Name { string_: c"URL".as_ptr() },
14673 attributes_: (JSPROP_ENUMERATE),
14674 kind_: (JSPropertySpec_Kind::NativeAccessor),
14675 u: JSPropertySpec_AccessorsOrValue {
14676 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14677 getter: JSPropertySpec_Accessor {
14678 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { URL_getterinfo.get() } },
14679 },
14680 setter: JSPropertySpec_Accessor {
14681 native: JSNativeWrapper { op: None, info: ptr::null() },
14682 }
14683 }
14684 }
14685 }
14686,
14687 JSPropertySpec {
14688 name: JSPropertySpec_Name { string_: c"documentURI".as_ptr() },
14689 attributes_: (JSPROP_ENUMERATE),
14690 kind_: (JSPropertySpec_Kind::NativeAccessor),
14691 u: JSPropertySpec_AccessorsOrValue {
14692 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14693 getter: JSPropertySpec_Accessor {
14694 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { documentURI_getterinfo.get() } },
14695 },
14696 setter: JSPropertySpec_Accessor {
14697 native: JSNativeWrapper { op: None, info: ptr::null() },
14698 }
14699 }
14700 }
14701 }
14702,
14703 JSPropertySpec {
14704 name: JSPropertySpec_Name { string_: c"compatMode".as_ptr() },
14705 attributes_: (JSPROP_ENUMERATE),
14706 kind_: (JSPropertySpec_Kind::NativeAccessor),
14707 u: JSPropertySpec_AccessorsOrValue {
14708 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14709 getter: JSPropertySpec_Accessor {
14710 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { compatMode_getterinfo.get() } },
14711 },
14712 setter: JSPropertySpec_Accessor {
14713 native: JSNativeWrapper { op: None, info: ptr::null() },
14714 }
14715 }
14716 }
14717 }
14718,
14719 JSPropertySpec {
14720 name: JSPropertySpec_Name { string_: c"characterSet".as_ptr() },
14721 attributes_: (JSPROP_ENUMERATE),
14722 kind_: (JSPropertySpec_Kind::NativeAccessor),
14723 u: JSPropertySpec_AccessorsOrValue {
14724 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14725 getter: JSPropertySpec_Accessor {
14726 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { characterSet_getterinfo.get() } },
14727 },
14728 setter: JSPropertySpec_Accessor {
14729 native: JSNativeWrapper { op: None, info: ptr::null() },
14730 }
14731 }
14732 }
14733 }
14734,
14735 JSPropertySpec {
14736 name: JSPropertySpec_Name { string_: c"charset".as_ptr() },
14737 attributes_: (JSPROP_ENUMERATE),
14738 kind_: (JSPropertySpec_Kind::NativeAccessor),
14739 u: JSPropertySpec_AccessorsOrValue {
14740 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14741 getter: JSPropertySpec_Accessor {
14742 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { charset_getterinfo.get() } },
14743 },
14744 setter: JSPropertySpec_Accessor {
14745 native: JSNativeWrapper { op: None, info: ptr::null() },
14746 }
14747 }
14748 }
14749 }
14750,
14751 JSPropertySpec {
14752 name: JSPropertySpec_Name { string_: c"inputEncoding".as_ptr() },
14753 attributes_: (JSPROP_ENUMERATE),
14754 kind_: (JSPropertySpec_Kind::NativeAccessor),
14755 u: JSPropertySpec_AccessorsOrValue {
14756 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14757 getter: JSPropertySpec_Accessor {
14758 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { inputEncoding_getterinfo.get() } },
14759 },
14760 setter: JSPropertySpec_Accessor {
14761 native: JSNativeWrapper { op: None, info: ptr::null() },
14762 }
14763 }
14764 }
14765 }
14766,
14767 JSPropertySpec {
14768 name: JSPropertySpec_Name { string_: c"contentType".as_ptr() },
14769 attributes_: (JSPROP_ENUMERATE),
14770 kind_: (JSPropertySpec_Kind::NativeAccessor),
14771 u: JSPropertySpec_AccessorsOrValue {
14772 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14773 getter: JSPropertySpec_Accessor {
14774 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { contentType_getterinfo.get() } },
14775 },
14776 setter: JSPropertySpec_Accessor {
14777 native: JSNativeWrapper { op: None, info: ptr::null() },
14778 }
14779 }
14780 }
14781 }
14782,
14783 JSPropertySpec {
14784 name: JSPropertySpec_Name { string_: c"doctype".as_ptr() },
14785 attributes_: (JSPROP_ENUMERATE),
14786 kind_: (JSPropertySpec_Kind::NativeAccessor),
14787 u: JSPropertySpec_AccessorsOrValue {
14788 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14789 getter: JSPropertySpec_Accessor {
14790 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { doctype_getterinfo.get() } },
14791 },
14792 setter: JSPropertySpec_Accessor {
14793 native: JSNativeWrapper { op: None, info: ptr::null() },
14794 }
14795 }
14796 }
14797 }
14798,
14799 JSPropertySpec {
14800 name: JSPropertySpec_Name { string_: c"documentElement".as_ptr() },
14801 attributes_: (JSPROP_ENUMERATE),
14802 kind_: (JSPropertySpec_Kind::NativeAccessor),
14803 u: JSPropertySpec_AccessorsOrValue {
14804 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14805 getter: JSPropertySpec_Accessor {
14806 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { documentElement_getterinfo.get() } },
14807 },
14808 setter: JSPropertySpec_Accessor {
14809 native: JSNativeWrapper { op: None, info: ptr::null() },
14810 }
14811 }
14812 }
14813 }
14814,
14815 JSPropertySpec {
14816 name: JSPropertySpec_Name { string_: c"domain".as_ptr() },
14817 attributes_: (JSPROP_ENUMERATE),
14818 kind_: (JSPropertySpec_Kind::NativeAccessor),
14819 u: JSPropertySpec_AccessorsOrValue {
14820 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14821 getter: JSPropertySpec_Accessor {
14822 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { domain_getterinfo.get() } },
14823 },
14824 setter: JSPropertySpec_Accessor {
14825 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { domain_setterinfo.get() } },
14826 }
14827 }
14828 }
14829 }
14830,
14831 JSPropertySpec {
14832 name: JSPropertySpec_Name { string_: c"referrer".as_ptr() },
14833 attributes_: (JSPROP_ENUMERATE),
14834 kind_: (JSPropertySpec_Kind::NativeAccessor),
14835 u: JSPropertySpec_AccessorsOrValue {
14836 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14837 getter: JSPropertySpec_Accessor {
14838 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { referrer_getterinfo.get() } },
14839 },
14840 setter: JSPropertySpec_Accessor {
14841 native: JSNativeWrapper { op: None, info: ptr::null() },
14842 }
14843 }
14844 }
14845 }
14846,
14847 JSPropertySpec {
14848 name: JSPropertySpec_Name { string_: c"cookie".as_ptr() },
14849 attributes_: (JSPROP_ENUMERATE),
14850 kind_: (JSPropertySpec_Kind::NativeAccessor),
14851 u: JSPropertySpec_AccessorsOrValue {
14852 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14853 getter: JSPropertySpec_Accessor {
14854 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { cookie_getterinfo.get() } },
14855 },
14856 setter: JSPropertySpec_Accessor {
14857 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { cookie_setterinfo.get() } },
14858 }
14859 }
14860 }
14861 }
14862,
14863 JSPropertySpec {
14864 name: JSPropertySpec_Name { string_: c"lastModified".as_ptr() },
14865 attributes_: (JSPROP_ENUMERATE),
14866 kind_: (JSPropertySpec_Kind::NativeAccessor),
14867 u: JSPropertySpec_AccessorsOrValue {
14868 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14869 getter: JSPropertySpec_Accessor {
14870 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { lastModified_getterinfo.get() } },
14871 },
14872 setter: JSPropertySpec_Accessor {
14873 native: JSNativeWrapper { op: None, info: ptr::null() },
14874 }
14875 }
14876 }
14877 }
14878,
14879 JSPropertySpec {
14880 name: JSPropertySpec_Name { string_: c"readyState".as_ptr() },
14881 attributes_: (JSPROP_ENUMERATE),
14882 kind_: (JSPropertySpec_Kind::NativeAccessor),
14883 u: JSPropertySpec_AccessorsOrValue {
14884 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14885 getter: JSPropertySpec_Accessor {
14886 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { readyState_getterinfo.get() } },
14887 },
14888 setter: JSPropertySpec_Accessor {
14889 native: JSNativeWrapper { op: None, info: ptr::null() },
14890 }
14891 }
14892 }
14893 }
14894,
14895 JSPropertySpec {
14896 name: JSPropertySpec_Name { string_: c"title".as_ptr() },
14897 attributes_: (JSPROP_ENUMERATE),
14898 kind_: (JSPropertySpec_Kind::NativeAccessor),
14899 u: JSPropertySpec_AccessorsOrValue {
14900 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14901 getter: JSPropertySpec_Accessor {
14902 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { title_getterinfo.get() } },
14903 },
14904 setter: JSPropertySpec_Accessor {
14905 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { title_setterinfo.get() } },
14906 }
14907 }
14908 }
14909 }
14910,
14911 JSPropertySpec {
14912 name: JSPropertySpec_Name { string_: c"body".as_ptr() },
14913 attributes_: (JSPROP_ENUMERATE),
14914 kind_: (JSPropertySpec_Kind::NativeAccessor),
14915 u: JSPropertySpec_AccessorsOrValue {
14916 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14917 getter: JSPropertySpec_Accessor {
14918 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { body_getterinfo.get() } },
14919 },
14920 setter: JSPropertySpec_Accessor {
14921 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { body_setterinfo.get() } },
14922 }
14923 }
14924 }
14925 }
14926,
14927 JSPropertySpec {
14928 name: JSPropertySpec_Name { string_: c"head".as_ptr() },
14929 attributes_: (JSPROP_ENUMERATE),
14930 kind_: (JSPropertySpec_Kind::NativeAccessor),
14931 u: JSPropertySpec_AccessorsOrValue {
14932 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14933 getter: JSPropertySpec_Accessor {
14934 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { head_getterinfo.get() } },
14935 },
14936 setter: JSPropertySpec_Accessor {
14937 native: JSNativeWrapper { op: None, info: ptr::null() },
14938 }
14939 }
14940 }
14941 }
14942,
14943 JSPropertySpec {
14944 name: JSPropertySpec_Name { string_: c"images".as_ptr() },
14945 attributes_: (JSPROP_ENUMERATE),
14946 kind_: (JSPropertySpec_Kind::NativeAccessor),
14947 u: JSPropertySpec_AccessorsOrValue {
14948 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14949 getter: JSPropertySpec_Accessor {
14950 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { images_getterinfo.get() } },
14951 },
14952 setter: JSPropertySpec_Accessor {
14953 native: JSNativeWrapper { op: None, info: ptr::null() },
14954 }
14955 }
14956 }
14957 }
14958,
14959 JSPropertySpec {
14960 name: JSPropertySpec_Name { string_: c"embeds".as_ptr() },
14961 attributes_: (JSPROP_ENUMERATE),
14962 kind_: (JSPropertySpec_Kind::NativeAccessor),
14963 u: JSPropertySpec_AccessorsOrValue {
14964 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14965 getter: JSPropertySpec_Accessor {
14966 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { embeds_getterinfo.get() } },
14967 },
14968 setter: JSPropertySpec_Accessor {
14969 native: JSNativeWrapper { op: None, info: ptr::null() },
14970 }
14971 }
14972 }
14973 }
14974,
14975 JSPropertySpec {
14976 name: JSPropertySpec_Name { string_: c"plugins".as_ptr() },
14977 attributes_: (JSPROP_ENUMERATE),
14978 kind_: (JSPropertySpec_Kind::NativeAccessor),
14979 u: JSPropertySpec_AccessorsOrValue {
14980 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14981 getter: JSPropertySpec_Accessor {
14982 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { plugins_getterinfo.get() } },
14983 },
14984 setter: JSPropertySpec_Accessor {
14985 native: JSNativeWrapper { op: None, info: ptr::null() },
14986 }
14987 }
14988 }
14989 }
14990,
14991 JSPropertySpec {
14992 name: JSPropertySpec_Name { string_: c"links".as_ptr() },
14993 attributes_: (JSPROP_ENUMERATE),
14994 kind_: (JSPropertySpec_Kind::NativeAccessor),
14995 u: JSPropertySpec_AccessorsOrValue {
14996 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
14997 getter: JSPropertySpec_Accessor {
14998 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { links_getterinfo.get() } },
14999 },
15000 setter: JSPropertySpec_Accessor {
15001 native: JSNativeWrapper { op: None, info: ptr::null() },
15002 }
15003 }
15004 }
15005 }
15006,
15007 JSPropertySpec {
15008 name: JSPropertySpec_Name { string_: c"forms".as_ptr() },
15009 attributes_: (JSPROP_ENUMERATE),
15010 kind_: (JSPropertySpec_Kind::NativeAccessor),
15011 u: JSPropertySpec_AccessorsOrValue {
15012 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15013 getter: JSPropertySpec_Accessor {
15014 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { forms_getterinfo.get() } },
15015 },
15016 setter: JSPropertySpec_Accessor {
15017 native: JSNativeWrapper { op: None, info: ptr::null() },
15018 }
15019 }
15020 }
15021 }
15022,
15023 JSPropertySpec {
15024 name: JSPropertySpec_Name { string_: c"scripts".as_ptr() },
15025 attributes_: (JSPROP_ENUMERATE),
15026 kind_: (JSPropertySpec_Kind::NativeAccessor),
15027 u: JSPropertySpec_AccessorsOrValue {
15028 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15029 getter: JSPropertySpec_Accessor {
15030 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { scripts_getterinfo.get() } },
15031 },
15032 setter: JSPropertySpec_Accessor {
15033 native: JSNativeWrapper { op: None, info: ptr::null() },
15034 }
15035 }
15036 }
15037 }
15038,
15039 JSPropertySpec {
15040 name: JSPropertySpec_Name { string_: c"currentScript".as_ptr() },
15041 attributes_: (JSPROP_ENUMERATE),
15042 kind_: (JSPropertySpec_Kind::NativeAccessor),
15043 u: JSPropertySpec_AccessorsOrValue {
15044 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15045 getter: JSPropertySpec_Accessor {
15046 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { currentScript_getterinfo.get() } },
15047 },
15048 setter: JSPropertySpec_Accessor {
15049 native: JSNativeWrapper { op: None, info: ptr::null() },
15050 }
15051 }
15052 }
15053 }
15054,
15055 JSPropertySpec {
15056 name: JSPropertySpec_Name { string_: c"defaultView".as_ptr() },
15057 attributes_: (JSPROP_ENUMERATE),
15058 kind_: (JSPropertySpec_Kind::NativeAccessor),
15059 u: JSPropertySpec_AccessorsOrValue {
15060 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15061 getter: JSPropertySpec_Accessor {
15062 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { defaultView_getterinfo.get() } },
15063 },
15064 setter: JSPropertySpec_Accessor {
15065 native: JSNativeWrapper { op: None, info: ptr::null() },
15066 }
15067 }
15068 }
15069 }
15070,
15071 JSPropertySpec {
15072 name: JSPropertySpec_Name { string_: c"hidden".as_ptr() },
15073 attributes_: (JSPROP_ENUMERATE),
15074 kind_: (JSPropertySpec_Kind::NativeAccessor),
15075 u: JSPropertySpec_AccessorsOrValue {
15076 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15077 getter: JSPropertySpec_Accessor {
15078 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { hidden_getterinfo.get() } },
15079 },
15080 setter: JSPropertySpec_Accessor {
15081 native: JSNativeWrapper { op: None, info: ptr::null() },
15082 }
15083 }
15084 }
15085 }
15086,
15087 JSPropertySpec {
15088 name: JSPropertySpec_Name { string_: c"visibilityState".as_ptr() },
15089 attributes_: (JSPROP_ENUMERATE),
15090 kind_: (JSPropertySpec_Kind::NativeAccessor),
15091 u: JSPropertySpec_AccessorsOrValue {
15092 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15093 getter: JSPropertySpec_Accessor {
15094 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { visibilityState_getterinfo.get() } },
15095 },
15096 setter: JSPropertySpec_Accessor {
15097 native: JSNativeWrapper { op: None, info: ptr::null() },
15098 }
15099 }
15100 }
15101 }
15102,
15103 JSPropertySpec {
15104 name: JSPropertySpec_Name { string_: c"onreadystatechange".as_ptr() },
15105 attributes_: (JSPROP_ENUMERATE),
15106 kind_: (JSPropertySpec_Kind::NativeAccessor),
15107 u: JSPropertySpec_AccessorsOrValue {
15108 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15109 getter: JSPropertySpec_Accessor {
15110 native: JSNativeWrapper { op: Some(generic_lenient_getter::<false>), info: unsafe { onreadystatechange_getterinfo.get() } },
15111 },
15112 setter: JSPropertySpec_Accessor {
15113 native: JSNativeWrapper { op: Some(generic_lenient_setter), info: unsafe { onreadystatechange_setterinfo.get() } },
15114 }
15115 }
15116 }
15117 }
15118,
15119 JSPropertySpec {
15120 name: JSPropertySpec_Name { string_: c"fgColor".as_ptr() },
15121 attributes_: (JSPROP_ENUMERATE),
15122 kind_: (JSPropertySpec_Kind::NativeAccessor),
15123 u: JSPropertySpec_AccessorsOrValue {
15124 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15125 getter: JSPropertySpec_Accessor {
15126 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { fgColor_getterinfo.get() } },
15127 },
15128 setter: JSPropertySpec_Accessor {
15129 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { fgColor_setterinfo.get() } },
15130 }
15131 }
15132 }
15133 }
15134,
15135 JSPropertySpec {
15136 name: JSPropertySpec_Name { string_: c"bgColor".as_ptr() },
15137 attributes_: (JSPROP_ENUMERATE),
15138 kind_: (JSPropertySpec_Kind::NativeAccessor),
15139 u: JSPropertySpec_AccessorsOrValue {
15140 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15141 getter: JSPropertySpec_Accessor {
15142 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { bgColor_getterinfo.get() } },
15143 },
15144 setter: JSPropertySpec_Accessor {
15145 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { bgColor_setterinfo.get() } },
15146 }
15147 }
15148 }
15149 }
15150,
15151 JSPropertySpec {
15152 name: JSPropertySpec_Name { string_: c"anchors".as_ptr() },
15153 attributes_: (JSPROP_ENUMERATE),
15154 kind_: (JSPropertySpec_Kind::NativeAccessor),
15155 u: JSPropertySpec_AccessorsOrValue {
15156 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15157 getter: JSPropertySpec_Accessor {
15158 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { anchors_getterinfo.get() } },
15159 },
15160 setter: JSPropertySpec_Accessor {
15161 native: JSNativeWrapper { op: None, info: ptr::null() },
15162 }
15163 }
15164 }
15165 }
15166,
15167 JSPropertySpec {
15168 name: JSPropertySpec_Name { string_: c"applets".as_ptr() },
15169 attributes_: (JSPROP_ENUMERATE),
15170 kind_: (JSPropertySpec_Kind::NativeAccessor),
15171 u: JSPropertySpec_AccessorsOrValue {
15172 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15173 getter: JSPropertySpec_Accessor {
15174 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { applets_getterinfo.get() } },
15175 },
15176 setter: JSPropertySpec_Accessor {
15177 native: JSNativeWrapper { op: None, info: ptr::null() },
15178 }
15179 }
15180 }
15181 }
15182,
15183 JSPropertySpec {
15184 name: JSPropertySpec_Name { string_: c"fullscreenEnabled".as_ptr() },
15185 attributes_: (JSPROP_ENUMERATE),
15186 kind_: (JSPropertySpec_Kind::NativeAccessor),
15187 u: JSPropertySpec_AccessorsOrValue {
15188 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15189 getter: JSPropertySpec_Accessor {
15190 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { fullscreenEnabled_getterinfo.get() } },
15191 },
15192 setter: JSPropertySpec_Accessor {
15193 native: JSNativeWrapper { op: None, info: ptr::null() },
15194 }
15195 }
15196 }
15197 }
15198,
15199 JSPropertySpec {
15200 name: JSPropertySpec_Name { string_: c"fullscreenElement".as_ptr() },
15201 attributes_: (JSPROP_ENUMERATE),
15202 kind_: (JSPropertySpec_Kind::NativeAccessor),
15203 u: JSPropertySpec_AccessorsOrValue {
15204 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15205 getter: JSPropertySpec_Accessor {
15206 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { fullscreenElement_getterinfo.get() } },
15207 },
15208 setter: JSPropertySpec_Accessor {
15209 native: JSNativeWrapper { op: None, info: ptr::null() },
15210 }
15211 }
15212 }
15213 }
15214,
15215 JSPropertySpec {
15216 name: JSPropertySpec_Name { string_: c"fullscreen".as_ptr() },
15217 attributes_: (JSPROP_ENUMERATE),
15218 kind_: (JSPropertySpec_Kind::NativeAccessor),
15219 u: JSPropertySpec_AccessorsOrValue {
15220 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15221 getter: JSPropertySpec_Accessor {
15222 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { fullscreen_getterinfo.get() } },
15223 },
15224 setter: JSPropertySpec_Accessor {
15225 native: JSNativeWrapper { op: None, info: ptr::null() },
15226 }
15227 }
15228 }
15229 }
15230,
15231 JSPropertySpec {
15232 name: JSPropertySpec_Name { string_: c"onfullscreenchange".as_ptr() },
15233 attributes_: (JSPROP_ENUMERATE),
15234 kind_: (JSPropertySpec_Kind::NativeAccessor),
15235 u: JSPropertySpec_AccessorsOrValue {
15236 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15237 getter: JSPropertySpec_Accessor {
15238 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onfullscreenchange_getterinfo.get() } },
15239 },
15240 setter: JSPropertySpec_Accessor {
15241 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onfullscreenchange_setterinfo.get() } },
15242 }
15243 }
15244 }
15245 }
15246,
15247 JSPropertySpec {
15248 name: JSPropertySpec_Name { string_: c"onfullscreenerror".as_ptr() },
15249 attributes_: (JSPROP_ENUMERATE),
15250 kind_: (JSPropertySpec_Kind::NativeAccessor),
15251 u: JSPropertySpec_AccessorsOrValue {
15252 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15253 getter: JSPropertySpec_Accessor {
15254 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onfullscreenerror_getterinfo.get() } },
15255 },
15256 setter: JSPropertySpec_Accessor {
15257 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onfullscreenerror_setterinfo.get() } },
15258 }
15259 }
15260 }
15261 }
15262,
15263 JSPropertySpec {
15264 name: JSPropertySpec_Name { string_: c"scrollingElement".as_ptr() },
15265 attributes_: (JSPROP_ENUMERATE),
15266 kind_: (JSPropertySpec_Kind::NativeAccessor),
15267 u: JSPropertySpec_AccessorsOrValue {
15268 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15269 getter: JSPropertySpec_Accessor {
15270 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { scrollingElement_getterinfo.get() } },
15271 },
15272 setter: JSPropertySpec_Accessor {
15273 native: JSNativeWrapper { op: None, info: ptr::null() },
15274 }
15275 }
15276 }
15277 }
15278,
15279 JSPropertySpec {
15280 name: JSPropertySpec_Name { string_: c"activeElement".as_ptr() },
15281 attributes_: (JSPROP_ENUMERATE),
15282 kind_: (JSPropertySpec_Kind::NativeAccessor),
15283 u: JSPropertySpec_AccessorsOrValue {
15284 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15285 getter: JSPropertySpec_Accessor {
15286 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { activeElement_getterinfo.get() } },
15287 },
15288 setter: JSPropertySpec_Accessor {
15289 native: JSNativeWrapper { op: None, info: ptr::null() },
15290 }
15291 }
15292 }
15293 }
15294,
15295 JSPropertySpec {
15296 name: JSPropertySpec_Name { string_: c"styleSheets".as_ptr() },
15297 attributes_: (JSPROP_ENUMERATE),
15298 kind_: (JSPropertySpec_Kind::NativeAccessor),
15299 u: JSPropertySpec_AccessorsOrValue {
15300 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15301 getter: JSPropertySpec_Accessor {
15302 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { styleSheets_getterinfo.get() } },
15303 },
15304 setter: JSPropertySpec_Accessor {
15305 native: JSNativeWrapper { op: None, info: ptr::null() },
15306 }
15307 }
15308 }
15309 }
15310,
15311 JSPropertySpec::ZERO]))[..]
15312,
15313&Box::leak(Box::new([
15314 JSPropertySpec {
15315 name: JSPropertySpec_Name { string_: c"adoptedStyleSheets".as_ptr() },
15316 attributes_: (JSPROP_ENUMERATE),
15317 kind_: (JSPropertySpec_Kind::NativeAccessor),
15318 u: JSPropertySpec_AccessorsOrValue {
15319 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15320 getter: JSPropertySpec_Accessor {
15321 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { adoptedStyleSheets_getterinfo.get() } },
15322 },
15323 setter: JSPropertySpec_Accessor {
15324 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { adoptedStyleSheets_setterinfo.get() } },
15325 }
15326 }
15327 }
15328 }
15329,
15330 JSPropertySpec::ZERO]))[..]
15331,
15332&Box::leak(Box::new([
15333 JSPropertySpec {
15334 name: JSPropertySpec_Name { string_: c"fonts".as_ptr() },
15335 attributes_: (JSPROP_ENUMERATE),
15336 kind_: (JSPropertySpec_Kind::NativeAccessor),
15337 u: JSPropertySpec_AccessorsOrValue {
15338 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15339 getter: JSPropertySpec_Accessor {
15340 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { fonts_getterinfo.get() } },
15341 },
15342 setter: JSPropertySpec_Accessor {
15343 native: JSNativeWrapper { op: None, info: ptr::null() },
15344 }
15345 }
15346 }
15347 }
15348,
15349 JSPropertySpec {
15350 name: JSPropertySpec_Name { string_: c"onabort".as_ptr() },
15351 attributes_: (JSPROP_ENUMERATE),
15352 kind_: (JSPropertySpec_Kind::NativeAccessor),
15353 u: JSPropertySpec_AccessorsOrValue {
15354 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15355 getter: JSPropertySpec_Accessor {
15356 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onabort_getterinfo.get() } },
15357 },
15358 setter: JSPropertySpec_Accessor {
15359 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onabort_setterinfo.get() } },
15360 }
15361 }
15362 }
15363 }
15364,
15365 JSPropertySpec {
15366 name: JSPropertySpec_Name { string_: c"onauxclick".as_ptr() },
15367 attributes_: (JSPROP_ENUMERATE),
15368 kind_: (JSPropertySpec_Kind::NativeAccessor),
15369 u: JSPropertySpec_AccessorsOrValue {
15370 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15371 getter: JSPropertySpec_Accessor {
15372 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onauxclick_getterinfo.get() } },
15373 },
15374 setter: JSPropertySpec_Accessor {
15375 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onauxclick_setterinfo.get() } },
15376 }
15377 }
15378 }
15379 }
15380,
15381 JSPropertySpec {
15382 name: JSPropertySpec_Name { string_: c"onbeforeinput".as_ptr() },
15383 attributes_: (JSPROP_ENUMERATE),
15384 kind_: (JSPropertySpec_Kind::NativeAccessor),
15385 u: JSPropertySpec_AccessorsOrValue {
15386 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15387 getter: JSPropertySpec_Accessor {
15388 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onbeforeinput_getterinfo.get() } },
15389 },
15390 setter: JSPropertySpec_Accessor {
15391 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onbeforeinput_setterinfo.get() } },
15392 }
15393 }
15394 }
15395 }
15396,
15397 JSPropertySpec {
15398 name: JSPropertySpec_Name { string_: c"onbeforematch".as_ptr() },
15399 attributes_: (JSPROP_ENUMERATE),
15400 kind_: (JSPropertySpec_Kind::NativeAccessor),
15401 u: JSPropertySpec_AccessorsOrValue {
15402 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15403 getter: JSPropertySpec_Accessor {
15404 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onbeforematch_getterinfo.get() } },
15405 },
15406 setter: JSPropertySpec_Accessor {
15407 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onbeforematch_setterinfo.get() } },
15408 }
15409 }
15410 }
15411 }
15412,
15413 JSPropertySpec {
15414 name: JSPropertySpec_Name { string_: c"onbeforetoggle".as_ptr() },
15415 attributes_: (JSPROP_ENUMERATE),
15416 kind_: (JSPropertySpec_Kind::NativeAccessor),
15417 u: JSPropertySpec_AccessorsOrValue {
15418 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15419 getter: JSPropertySpec_Accessor {
15420 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onbeforetoggle_getterinfo.get() } },
15421 },
15422 setter: JSPropertySpec_Accessor {
15423 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onbeforetoggle_setterinfo.get() } },
15424 }
15425 }
15426 }
15427 }
15428,
15429 JSPropertySpec {
15430 name: JSPropertySpec_Name { string_: c"onblur".as_ptr() },
15431 attributes_: (JSPROP_ENUMERATE),
15432 kind_: (JSPropertySpec_Kind::NativeAccessor),
15433 u: JSPropertySpec_AccessorsOrValue {
15434 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15435 getter: JSPropertySpec_Accessor {
15436 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onblur_getterinfo.get() } },
15437 },
15438 setter: JSPropertySpec_Accessor {
15439 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onblur_setterinfo.get() } },
15440 }
15441 }
15442 }
15443 }
15444,
15445 JSPropertySpec {
15446 name: JSPropertySpec_Name { string_: c"oncancel".as_ptr() },
15447 attributes_: (JSPROP_ENUMERATE),
15448 kind_: (JSPropertySpec_Kind::NativeAccessor),
15449 u: JSPropertySpec_AccessorsOrValue {
15450 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15451 getter: JSPropertySpec_Accessor {
15452 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncancel_getterinfo.get() } },
15453 },
15454 setter: JSPropertySpec_Accessor {
15455 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncancel_setterinfo.get() } },
15456 }
15457 }
15458 }
15459 }
15460,
15461 JSPropertySpec {
15462 name: JSPropertySpec_Name { string_: c"oncanplay".as_ptr() },
15463 attributes_: (JSPROP_ENUMERATE),
15464 kind_: (JSPropertySpec_Kind::NativeAccessor),
15465 u: JSPropertySpec_AccessorsOrValue {
15466 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15467 getter: JSPropertySpec_Accessor {
15468 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncanplay_getterinfo.get() } },
15469 },
15470 setter: JSPropertySpec_Accessor {
15471 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncanplay_setterinfo.get() } },
15472 }
15473 }
15474 }
15475 }
15476,
15477 JSPropertySpec {
15478 name: JSPropertySpec_Name { string_: c"oncanplaythrough".as_ptr() },
15479 attributes_: (JSPROP_ENUMERATE),
15480 kind_: (JSPropertySpec_Kind::NativeAccessor),
15481 u: JSPropertySpec_AccessorsOrValue {
15482 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15483 getter: JSPropertySpec_Accessor {
15484 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncanplaythrough_getterinfo.get() } },
15485 },
15486 setter: JSPropertySpec_Accessor {
15487 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncanplaythrough_setterinfo.get() } },
15488 }
15489 }
15490 }
15491 }
15492,
15493 JSPropertySpec {
15494 name: JSPropertySpec_Name { string_: c"onchange".as_ptr() },
15495 attributes_: (JSPROP_ENUMERATE),
15496 kind_: (JSPropertySpec_Kind::NativeAccessor),
15497 u: JSPropertySpec_AccessorsOrValue {
15498 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15499 getter: JSPropertySpec_Accessor {
15500 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onchange_getterinfo.get() } },
15501 },
15502 setter: JSPropertySpec_Accessor {
15503 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onchange_setterinfo.get() } },
15504 }
15505 }
15506 }
15507 }
15508,
15509 JSPropertySpec {
15510 name: JSPropertySpec_Name { string_: c"onclick".as_ptr() },
15511 attributes_: (JSPROP_ENUMERATE),
15512 kind_: (JSPropertySpec_Kind::NativeAccessor),
15513 u: JSPropertySpec_AccessorsOrValue {
15514 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15515 getter: JSPropertySpec_Accessor {
15516 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onclick_getterinfo.get() } },
15517 },
15518 setter: JSPropertySpec_Accessor {
15519 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onclick_setterinfo.get() } },
15520 }
15521 }
15522 }
15523 }
15524,
15525 JSPropertySpec {
15526 name: JSPropertySpec_Name { string_: c"onclose".as_ptr() },
15527 attributes_: (JSPROP_ENUMERATE),
15528 kind_: (JSPropertySpec_Kind::NativeAccessor),
15529 u: JSPropertySpec_AccessorsOrValue {
15530 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15531 getter: JSPropertySpec_Accessor {
15532 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onclose_getterinfo.get() } },
15533 },
15534 setter: JSPropertySpec_Accessor {
15535 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onclose_setterinfo.get() } },
15536 }
15537 }
15538 }
15539 }
15540,
15541 JSPropertySpec {
15542 name: JSPropertySpec_Name { string_: c"oncommand".as_ptr() },
15543 attributes_: (JSPROP_ENUMERATE),
15544 kind_: (JSPropertySpec_Kind::NativeAccessor),
15545 u: JSPropertySpec_AccessorsOrValue {
15546 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15547 getter: JSPropertySpec_Accessor {
15548 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncommand_getterinfo.get() } },
15549 },
15550 setter: JSPropertySpec_Accessor {
15551 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncommand_setterinfo.get() } },
15552 }
15553 }
15554 }
15555 }
15556,
15557 JSPropertySpec {
15558 name: JSPropertySpec_Name { string_: c"oncontextlost".as_ptr() },
15559 attributes_: (JSPROP_ENUMERATE),
15560 kind_: (JSPropertySpec_Kind::NativeAccessor),
15561 u: JSPropertySpec_AccessorsOrValue {
15562 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15563 getter: JSPropertySpec_Accessor {
15564 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncontextlost_getterinfo.get() } },
15565 },
15566 setter: JSPropertySpec_Accessor {
15567 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncontextlost_setterinfo.get() } },
15568 }
15569 }
15570 }
15571 }
15572,
15573 JSPropertySpec {
15574 name: JSPropertySpec_Name { string_: c"oncontextmenu".as_ptr() },
15575 attributes_: (JSPROP_ENUMERATE),
15576 kind_: (JSPropertySpec_Kind::NativeAccessor),
15577 u: JSPropertySpec_AccessorsOrValue {
15578 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15579 getter: JSPropertySpec_Accessor {
15580 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncontextmenu_getterinfo.get() } },
15581 },
15582 setter: JSPropertySpec_Accessor {
15583 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncontextmenu_setterinfo.get() } },
15584 }
15585 }
15586 }
15587 }
15588,
15589 JSPropertySpec {
15590 name: JSPropertySpec_Name { string_: c"oncontextrestored".as_ptr() },
15591 attributes_: (JSPROP_ENUMERATE),
15592 kind_: (JSPropertySpec_Kind::NativeAccessor),
15593 u: JSPropertySpec_AccessorsOrValue {
15594 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15595 getter: JSPropertySpec_Accessor {
15596 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncontextrestored_getterinfo.get() } },
15597 },
15598 setter: JSPropertySpec_Accessor {
15599 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncontextrestored_setterinfo.get() } },
15600 }
15601 }
15602 }
15603 }
15604,
15605 JSPropertySpec {
15606 name: JSPropertySpec_Name { string_: c"oncopy".as_ptr() },
15607 attributes_: (JSPROP_ENUMERATE),
15608 kind_: (JSPropertySpec_Kind::NativeAccessor),
15609 u: JSPropertySpec_AccessorsOrValue {
15610 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15611 getter: JSPropertySpec_Accessor {
15612 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncopy_getterinfo.get() } },
15613 },
15614 setter: JSPropertySpec_Accessor {
15615 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncopy_setterinfo.get() } },
15616 }
15617 }
15618 }
15619 }
15620,
15621 JSPropertySpec {
15622 name: JSPropertySpec_Name { string_: c"oncuechange".as_ptr() },
15623 attributes_: (JSPROP_ENUMERATE),
15624 kind_: (JSPropertySpec_Kind::NativeAccessor),
15625 u: JSPropertySpec_AccessorsOrValue {
15626 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15627 getter: JSPropertySpec_Accessor {
15628 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncuechange_getterinfo.get() } },
15629 },
15630 setter: JSPropertySpec_Accessor {
15631 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncuechange_setterinfo.get() } },
15632 }
15633 }
15634 }
15635 }
15636,
15637 JSPropertySpec {
15638 name: JSPropertySpec_Name { string_: c"oncut".as_ptr() },
15639 attributes_: (JSPROP_ENUMERATE),
15640 kind_: (JSPropertySpec_Kind::NativeAccessor),
15641 u: JSPropertySpec_AccessorsOrValue {
15642 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15643 getter: JSPropertySpec_Accessor {
15644 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oncut_getterinfo.get() } },
15645 },
15646 setter: JSPropertySpec_Accessor {
15647 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oncut_setterinfo.get() } },
15648 }
15649 }
15650 }
15651 }
15652,
15653 JSPropertySpec {
15654 name: JSPropertySpec_Name { string_: c"ondblclick".as_ptr() },
15655 attributes_: (JSPROP_ENUMERATE),
15656 kind_: (JSPropertySpec_Kind::NativeAccessor),
15657 u: JSPropertySpec_AccessorsOrValue {
15658 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15659 getter: JSPropertySpec_Accessor {
15660 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondblclick_getterinfo.get() } },
15661 },
15662 setter: JSPropertySpec_Accessor {
15663 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondblclick_setterinfo.get() } },
15664 }
15665 }
15666 }
15667 }
15668,
15669 JSPropertySpec {
15670 name: JSPropertySpec_Name { string_: c"ondrag".as_ptr() },
15671 attributes_: (JSPROP_ENUMERATE),
15672 kind_: (JSPropertySpec_Kind::NativeAccessor),
15673 u: JSPropertySpec_AccessorsOrValue {
15674 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15675 getter: JSPropertySpec_Accessor {
15676 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondrag_getterinfo.get() } },
15677 },
15678 setter: JSPropertySpec_Accessor {
15679 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondrag_setterinfo.get() } },
15680 }
15681 }
15682 }
15683 }
15684,
15685 JSPropertySpec {
15686 name: JSPropertySpec_Name { string_: c"ondragend".as_ptr() },
15687 attributes_: (JSPROP_ENUMERATE),
15688 kind_: (JSPropertySpec_Kind::NativeAccessor),
15689 u: JSPropertySpec_AccessorsOrValue {
15690 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15691 getter: JSPropertySpec_Accessor {
15692 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragend_getterinfo.get() } },
15693 },
15694 setter: JSPropertySpec_Accessor {
15695 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragend_setterinfo.get() } },
15696 }
15697 }
15698 }
15699 }
15700,
15701 JSPropertySpec {
15702 name: JSPropertySpec_Name { string_: c"ondragenter".as_ptr() },
15703 attributes_: (JSPROP_ENUMERATE),
15704 kind_: (JSPropertySpec_Kind::NativeAccessor),
15705 u: JSPropertySpec_AccessorsOrValue {
15706 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15707 getter: JSPropertySpec_Accessor {
15708 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragenter_getterinfo.get() } },
15709 },
15710 setter: JSPropertySpec_Accessor {
15711 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragenter_setterinfo.get() } },
15712 }
15713 }
15714 }
15715 }
15716,
15717 JSPropertySpec {
15718 name: JSPropertySpec_Name { string_: c"ondragleave".as_ptr() },
15719 attributes_: (JSPROP_ENUMERATE),
15720 kind_: (JSPropertySpec_Kind::NativeAccessor),
15721 u: JSPropertySpec_AccessorsOrValue {
15722 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15723 getter: JSPropertySpec_Accessor {
15724 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragleave_getterinfo.get() } },
15725 },
15726 setter: JSPropertySpec_Accessor {
15727 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragleave_setterinfo.get() } },
15728 }
15729 }
15730 }
15731 }
15732,
15733 JSPropertySpec {
15734 name: JSPropertySpec_Name { string_: c"ondragover".as_ptr() },
15735 attributes_: (JSPROP_ENUMERATE),
15736 kind_: (JSPropertySpec_Kind::NativeAccessor),
15737 u: JSPropertySpec_AccessorsOrValue {
15738 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15739 getter: JSPropertySpec_Accessor {
15740 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragover_getterinfo.get() } },
15741 },
15742 setter: JSPropertySpec_Accessor {
15743 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragover_setterinfo.get() } },
15744 }
15745 }
15746 }
15747 }
15748,
15749 JSPropertySpec {
15750 name: JSPropertySpec_Name { string_: c"ondragstart".as_ptr() },
15751 attributes_: (JSPROP_ENUMERATE),
15752 kind_: (JSPropertySpec_Kind::NativeAccessor),
15753 u: JSPropertySpec_AccessorsOrValue {
15754 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15755 getter: JSPropertySpec_Accessor {
15756 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondragstart_getterinfo.get() } },
15757 },
15758 setter: JSPropertySpec_Accessor {
15759 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondragstart_setterinfo.get() } },
15760 }
15761 }
15762 }
15763 }
15764,
15765 JSPropertySpec {
15766 name: JSPropertySpec_Name { string_: c"ondrop".as_ptr() },
15767 attributes_: (JSPROP_ENUMERATE),
15768 kind_: (JSPropertySpec_Kind::NativeAccessor),
15769 u: JSPropertySpec_AccessorsOrValue {
15770 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15771 getter: JSPropertySpec_Accessor {
15772 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondrop_getterinfo.get() } },
15773 },
15774 setter: JSPropertySpec_Accessor {
15775 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondrop_setterinfo.get() } },
15776 }
15777 }
15778 }
15779 }
15780,
15781 JSPropertySpec {
15782 name: JSPropertySpec_Name { string_: c"ondurationchange".as_ptr() },
15783 attributes_: (JSPROP_ENUMERATE),
15784 kind_: (JSPropertySpec_Kind::NativeAccessor),
15785 u: JSPropertySpec_AccessorsOrValue {
15786 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15787 getter: JSPropertySpec_Accessor {
15788 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ondurationchange_getterinfo.get() } },
15789 },
15790 setter: JSPropertySpec_Accessor {
15791 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ondurationchange_setterinfo.get() } },
15792 }
15793 }
15794 }
15795 }
15796,
15797 JSPropertySpec {
15798 name: JSPropertySpec_Name { string_: c"onemptied".as_ptr() },
15799 attributes_: (JSPROP_ENUMERATE),
15800 kind_: (JSPropertySpec_Kind::NativeAccessor),
15801 u: JSPropertySpec_AccessorsOrValue {
15802 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15803 getter: JSPropertySpec_Accessor {
15804 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onemptied_getterinfo.get() } },
15805 },
15806 setter: JSPropertySpec_Accessor {
15807 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onemptied_setterinfo.get() } },
15808 }
15809 }
15810 }
15811 }
15812,
15813 JSPropertySpec {
15814 name: JSPropertySpec_Name { string_: c"onended".as_ptr() },
15815 attributes_: (JSPROP_ENUMERATE),
15816 kind_: (JSPropertySpec_Kind::NativeAccessor),
15817 u: JSPropertySpec_AccessorsOrValue {
15818 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15819 getter: JSPropertySpec_Accessor {
15820 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onended_getterinfo.get() } },
15821 },
15822 setter: JSPropertySpec_Accessor {
15823 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onended_setterinfo.get() } },
15824 }
15825 }
15826 }
15827 }
15828,
15829 JSPropertySpec {
15830 name: JSPropertySpec_Name { string_: c"onerror".as_ptr() },
15831 attributes_: (JSPROP_ENUMERATE),
15832 kind_: (JSPropertySpec_Kind::NativeAccessor),
15833 u: JSPropertySpec_AccessorsOrValue {
15834 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15835 getter: JSPropertySpec_Accessor {
15836 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onerror_getterinfo.get() } },
15837 },
15838 setter: JSPropertySpec_Accessor {
15839 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onerror_setterinfo.get() } },
15840 }
15841 }
15842 }
15843 }
15844,
15845 JSPropertySpec {
15846 name: JSPropertySpec_Name { string_: c"onfocus".as_ptr() },
15847 attributes_: (JSPROP_ENUMERATE),
15848 kind_: (JSPropertySpec_Kind::NativeAccessor),
15849 u: JSPropertySpec_AccessorsOrValue {
15850 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15851 getter: JSPropertySpec_Accessor {
15852 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onfocus_getterinfo.get() } },
15853 },
15854 setter: JSPropertySpec_Accessor {
15855 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onfocus_setterinfo.get() } },
15856 }
15857 }
15858 }
15859 }
15860,
15861 JSPropertySpec {
15862 name: JSPropertySpec_Name { string_: c"onformdata".as_ptr() },
15863 attributes_: (JSPROP_ENUMERATE),
15864 kind_: (JSPropertySpec_Kind::NativeAccessor),
15865 u: JSPropertySpec_AccessorsOrValue {
15866 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15867 getter: JSPropertySpec_Accessor {
15868 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onformdata_getterinfo.get() } },
15869 },
15870 setter: JSPropertySpec_Accessor {
15871 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onformdata_setterinfo.get() } },
15872 }
15873 }
15874 }
15875 }
15876,
15877 JSPropertySpec {
15878 name: JSPropertySpec_Name { string_: c"oninput".as_ptr() },
15879 attributes_: (JSPROP_ENUMERATE),
15880 kind_: (JSPropertySpec_Kind::NativeAccessor),
15881 u: JSPropertySpec_AccessorsOrValue {
15882 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15883 getter: JSPropertySpec_Accessor {
15884 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oninput_getterinfo.get() } },
15885 },
15886 setter: JSPropertySpec_Accessor {
15887 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oninput_setterinfo.get() } },
15888 }
15889 }
15890 }
15891 }
15892,
15893 JSPropertySpec {
15894 name: JSPropertySpec_Name { string_: c"oninvalid".as_ptr() },
15895 attributes_: (JSPROP_ENUMERATE),
15896 kind_: (JSPropertySpec_Kind::NativeAccessor),
15897 u: JSPropertySpec_AccessorsOrValue {
15898 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15899 getter: JSPropertySpec_Accessor {
15900 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { oninvalid_getterinfo.get() } },
15901 },
15902 setter: JSPropertySpec_Accessor {
15903 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { oninvalid_setterinfo.get() } },
15904 }
15905 }
15906 }
15907 }
15908,
15909 JSPropertySpec {
15910 name: JSPropertySpec_Name { string_: c"onkeydown".as_ptr() },
15911 attributes_: (JSPROP_ENUMERATE),
15912 kind_: (JSPropertySpec_Kind::NativeAccessor),
15913 u: JSPropertySpec_AccessorsOrValue {
15914 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15915 getter: JSPropertySpec_Accessor {
15916 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onkeydown_getterinfo.get() } },
15917 },
15918 setter: JSPropertySpec_Accessor {
15919 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onkeydown_setterinfo.get() } },
15920 }
15921 }
15922 }
15923 }
15924,
15925 JSPropertySpec {
15926 name: JSPropertySpec_Name { string_: c"onkeypress".as_ptr() },
15927 attributes_: (JSPROP_ENUMERATE),
15928 kind_: (JSPropertySpec_Kind::NativeAccessor),
15929 u: JSPropertySpec_AccessorsOrValue {
15930 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15931 getter: JSPropertySpec_Accessor {
15932 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onkeypress_getterinfo.get() } },
15933 },
15934 setter: JSPropertySpec_Accessor {
15935 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onkeypress_setterinfo.get() } },
15936 }
15937 }
15938 }
15939 }
15940,
15941 JSPropertySpec {
15942 name: JSPropertySpec_Name { string_: c"onkeyup".as_ptr() },
15943 attributes_: (JSPROP_ENUMERATE),
15944 kind_: (JSPropertySpec_Kind::NativeAccessor),
15945 u: JSPropertySpec_AccessorsOrValue {
15946 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15947 getter: JSPropertySpec_Accessor {
15948 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onkeyup_getterinfo.get() } },
15949 },
15950 setter: JSPropertySpec_Accessor {
15951 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onkeyup_setterinfo.get() } },
15952 }
15953 }
15954 }
15955 }
15956,
15957 JSPropertySpec {
15958 name: JSPropertySpec_Name { string_: c"onload".as_ptr() },
15959 attributes_: (JSPROP_ENUMERATE),
15960 kind_: (JSPropertySpec_Kind::NativeAccessor),
15961 u: JSPropertySpec_AccessorsOrValue {
15962 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15963 getter: JSPropertySpec_Accessor {
15964 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onload_getterinfo.get() } },
15965 },
15966 setter: JSPropertySpec_Accessor {
15967 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onload_setterinfo.get() } },
15968 }
15969 }
15970 }
15971 }
15972,
15973 JSPropertySpec {
15974 name: JSPropertySpec_Name { string_: c"onloadeddata".as_ptr() },
15975 attributes_: (JSPROP_ENUMERATE),
15976 kind_: (JSPropertySpec_Kind::NativeAccessor),
15977 u: JSPropertySpec_AccessorsOrValue {
15978 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15979 getter: JSPropertySpec_Accessor {
15980 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onloadeddata_getterinfo.get() } },
15981 },
15982 setter: JSPropertySpec_Accessor {
15983 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onloadeddata_setterinfo.get() } },
15984 }
15985 }
15986 }
15987 }
15988,
15989 JSPropertySpec {
15990 name: JSPropertySpec_Name { string_: c"onloadedmetadata".as_ptr() },
15991 attributes_: (JSPROP_ENUMERATE),
15992 kind_: (JSPropertySpec_Kind::NativeAccessor),
15993 u: JSPropertySpec_AccessorsOrValue {
15994 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
15995 getter: JSPropertySpec_Accessor {
15996 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onloadedmetadata_getterinfo.get() } },
15997 },
15998 setter: JSPropertySpec_Accessor {
15999 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onloadedmetadata_setterinfo.get() } },
16000 }
16001 }
16002 }
16003 }
16004,
16005 JSPropertySpec {
16006 name: JSPropertySpec_Name { string_: c"onloadstart".as_ptr() },
16007 attributes_: (JSPROP_ENUMERATE),
16008 kind_: (JSPropertySpec_Kind::NativeAccessor),
16009 u: JSPropertySpec_AccessorsOrValue {
16010 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16011 getter: JSPropertySpec_Accessor {
16012 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onloadstart_getterinfo.get() } },
16013 },
16014 setter: JSPropertySpec_Accessor {
16015 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onloadstart_setterinfo.get() } },
16016 }
16017 }
16018 }
16019 }
16020,
16021 JSPropertySpec {
16022 name: JSPropertySpec_Name { string_: c"onmousedown".as_ptr() },
16023 attributes_: (JSPROP_ENUMERATE),
16024 kind_: (JSPropertySpec_Kind::NativeAccessor),
16025 u: JSPropertySpec_AccessorsOrValue {
16026 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16027 getter: JSPropertySpec_Accessor {
16028 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmousedown_getterinfo.get() } },
16029 },
16030 setter: JSPropertySpec_Accessor {
16031 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmousedown_setterinfo.get() } },
16032 }
16033 }
16034 }
16035 }
16036,
16037 JSPropertySpec {
16038 name: JSPropertySpec_Name { string_: c"onmouseenter".as_ptr() },
16039 attributes_: (JSPROP_ENUMERATE),
16040 kind_: (JSPropertySpec_Kind::NativeAccessor),
16041 u: JSPropertySpec_AccessorsOrValue {
16042 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16043 getter: JSPropertySpec_Accessor {
16044 native: JSNativeWrapper { op: Some(generic_lenient_getter::<false>), info: unsafe { onmouseenter_getterinfo.get() } },
16045 },
16046 setter: JSPropertySpec_Accessor {
16047 native: JSNativeWrapper { op: Some(generic_lenient_setter), info: unsafe { onmouseenter_setterinfo.get() } },
16048 }
16049 }
16050 }
16051 }
16052,
16053 JSPropertySpec {
16054 name: JSPropertySpec_Name { string_: c"onmouseleave".as_ptr() },
16055 attributes_: (JSPROP_ENUMERATE),
16056 kind_: (JSPropertySpec_Kind::NativeAccessor),
16057 u: JSPropertySpec_AccessorsOrValue {
16058 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16059 getter: JSPropertySpec_Accessor {
16060 native: JSNativeWrapper { op: Some(generic_lenient_getter::<false>), info: unsafe { onmouseleave_getterinfo.get() } },
16061 },
16062 setter: JSPropertySpec_Accessor {
16063 native: JSNativeWrapper { op: Some(generic_lenient_setter), info: unsafe { onmouseleave_setterinfo.get() } },
16064 }
16065 }
16066 }
16067 }
16068,
16069 JSPropertySpec {
16070 name: JSPropertySpec_Name { string_: c"onmousemove".as_ptr() },
16071 attributes_: (JSPROP_ENUMERATE),
16072 kind_: (JSPropertySpec_Kind::NativeAccessor),
16073 u: JSPropertySpec_AccessorsOrValue {
16074 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16075 getter: JSPropertySpec_Accessor {
16076 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmousemove_getterinfo.get() } },
16077 },
16078 setter: JSPropertySpec_Accessor {
16079 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmousemove_setterinfo.get() } },
16080 }
16081 }
16082 }
16083 }
16084,
16085 JSPropertySpec {
16086 name: JSPropertySpec_Name { string_: c"onmouseout".as_ptr() },
16087 attributes_: (JSPROP_ENUMERATE),
16088 kind_: (JSPropertySpec_Kind::NativeAccessor),
16089 u: JSPropertySpec_AccessorsOrValue {
16090 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16091 getter: JSPropertySpec_Accessor {
16092 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmouseout_getterinfo.get() } },
16093 },
16094 setter: JSPropertySpec_Accessor {
16095 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmouseout_setterinfo.get() } },
16096 }
16097 }
16098 }
16099 }
16100,
16101 JSPropertySpec {
16102 name: JSPropertySpec_Name { string_: c"onmouseover".as_ptr() },
16103 attributes_: (JSPROP_ENUMERATE),
16104 kind_: (JSPropertySpec_Kind::NativeAccessor),
16105 u: JSPropertySpec_AccessorsOrValue {
16106 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16107 getter: JSPropertySpec_Accessor {
16108 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmouseover_getterinfo.get() } },
16109 },
16110 setter: JSPropertySpec_Accessor {
16111 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmouseover_setterinfo.get() } },
16112 }
16113 }
16114 }
16115 }
16116,
16117 JSPropertySpec {
16118 name: JSPropertySpec_Name { string_: c"onmouseup".as_ptr() },
16119 attributes_: (JSPROP_ENUMERATE),
16120 kind_: (JSPropertySpec_Kind::NativeAccessor),
16121 u: JSPropertySpec_AccessorsOrValue {
16122 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16123 getter: JSPropertySpec_Accessor {
16124 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onmouseup_getterinfo.get() } },
16125 },
16126 setter: JSPropertySpec_Accessor {
16127 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onmouseup_setterinfo.get() } },
16128 }
16129 }
16130 }
16131 }
16132,
16133 JSPropertySpec {
16134 name: JSPropertySpec_Name { string_: c"onpaste".as_ptr() },
16135 attributes_: (JSPROP_ENUMERATE),
16136 kind_: (JSPropertySpec_Kind::NativeAccessor),
16137 u: JSPropertySpec_AccessorsOrValue {
16138 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16139 getter: JSPropertySpec_Accessor {
16140 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onpaste_getterinfo.get() } },
16141 },
16142 setter: JSPropertySpec_Accessor {
16143 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onpaste_setterinfo.get() } },
16144 }
16145 }
16146 }
16147 }
16148,
16149 JSPropertySpec {
16150 name: JSPropertySpec_Name { string_: c"onpause".as_ptr() },
16151 attributes_: (JSPROP_ENUMERATE),
16152 kind_: (JSPropertySpec_Kind::NativeAccessor),
16153 u: JSPropertySpec_AccessorsOrValue {
16154 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16155 getter: JSPropertySpec_Accessor {
16156 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onpause_getterinfo.get() } },
16157 },
16158 setter: JSPropertySpec_Accessor {
16159 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onpause_setterinfo.get() } },
16160 }
16161 }
16162 }
16163 }
16164,
16165 JSPropertySpec {
16166 name: JSPropertySpec_Name { string_: c"onplay".as_ptr() },
16167 attributes_: (JSPROP_ENUMERATE),
16168 kind_: (JSPropertySpec_Kind::NativeAccessor),
16169 u: JSPropertySpec_AccessorsOrValue {
16170 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16171 getter: JSPropertySpec_Accessor {
16172 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onplay_getterinfo.get() } },
16173 },
16174 setter: JSPropertySpec_Accessor {
16175 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onplay_setterinfo.get() } },
16176 }
16177 }
16178 }
16179 }
16180,
16181 JSPropertySpec {
16182 name: JSPropertySpec_Name { string_: c"onplaying".as_ptr() },
16183 attributes_: (JSPROP_ENUMERATE),
16184 kind_: (JSPropertySpec_Kind::NativeAccessor),
16185 u: JSPropertySpec_AccessorsOrValue {
16186 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16187 getter: JSPropertySpec_Accessor {
16188 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onplaying_getterinfo.get() } },
16189 },
16190 setter: JSPropertySpec_Accessor {
16191 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onplaying_setterinfo.get() } },
16192 }
16193 }
16194 }
16195 }
16196,
16197 JSPropertySpec {
16198 name: JSPropertySpec_Name { string_: c"onprogress".as_ptr() },
16199 attributes_: (JSPROP_ENUMERATE),
16200 kind_: (JSPropertySpec_Kind::NativeAccessor),
16201 u: JSPropertySpec_AccessorsOrValue {
16202 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16203 getter: JSPropertySpec_Accessor {
16204 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onprogress_getterinfo.get() } },
16205 },
16206 setter: JSPropertySpec_Accessor {
16207 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onprogress_setterinfo.get() } },
16208 }
16209 }
16210 }
16211 }
16212,
16213 JSPropertySpec {
16214 name: JSPropertySpec_Name { string_: c"onratechange".as_ptr() },
16215 attributes_: (JSPROP_ENUMERATE),
16216 kind_: (JSPropertySpec_Kind::NativeAccessor),
16217 u: JSPropertySpec_AccessorsOrValue {
16218 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16219 getter: JSPropertySpec_Accessor {
16220 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onratechange_getterinfo.get() } },
16221 },
16222 setter: JSPropertySpec_Accessor {
16223 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onratechange_setterinfo.get() } },
16224 }
16225 }
16226 }
16227 }
16228,
16229 JSPropertySpec {
16230 name: JSPropertySpec_Name { string_: c"onreset".as_ptr() },
16231 attributes_: (JSPROP_ENUMERATE),
16232 kind_: (JSPropertySpec_Kind::NativeAccessor),
16233 u: JSPropertySpec_AccessorsOrValue {
16234 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16235 getter: JSPropertySpec_Accessor {
16236 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onreset_getterinfo.get() } },
16237 },
16238 setter: JSPropertySpec_Accessor {
16239 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onreset_setterinfo.get() } },
16240 }
16241 }
16242 }
16243 }
16244,
16245 JSPropertySpec {
16246 name: JSPropertySpec_Name { string_: c"onresize".as_ptr() },
16247 attributes_: (JSPROP_ENUMERATE),
16248 kind_: (JSPropertySpec_Kind::NativeAccessor),
16249 u: JSPropertySpec_AccessorsOrValue {
16250 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16251 getter: JSPropertySpec_Accessor {
16252 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onresize_getterinfo.get() } },
16253 },
16254 setter: JSPropertySpec_Accessor {
16255 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onresize_setterinfo.get() } },
16256 }
16257 }
16258 }
16259 }
16260,
16261 JSPropertySpec {
16262 name: JSPropertySpec_Name { string_: c"onscroll".as_ptr() },
16263 attributes_: (JSPROP_ENUMERATE),
16264 kind_: (JSPropertySpec_Kind::NativeAccessor),
16265 u: JSPropertySpec_AccessorsOrValue {
16266 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16267 getter: JSPropertySpec_Accessor {
16268 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onscroll_getterinfo.get() } },
16269 },
16270 setter: JSPropertySpec_Accessor {
16271 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onscroll_setterinfo.get() } },
16272 }
16273 }
16274 }
16275 }
16276,
16277 JSPropertySpec {
16278 name: JSPropertySpec_Name { string_: c"onscrollend".as_ptr() },
16279 attributes_: (JSPROP_ENUMERATE),
16280 kind_: (JSPropertySpec_Kind::NativeAccessor),
16281 u: JSPropertySpec_AccessorsOrValue {
16282 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16283 getter: JSPropertySpec_Accessor {
16284 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onscrollend_getterinfo.get() } },
16285 },
16286 setter: JSPropertySpec_Accessor {
16287 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onscrollend_setterinfo.get() } },
16288 }
16289 }
16290 }
16291 }
16292,
16293 JSPropertySpec {
16294 name: JSPropertySpec_Name { string_: c"onsecuritypolicyviolation".as_ptr() },
16295 attributes_: (JSPROP_ENUMERATE),
16296 kind_: (JSPropertySpec_Kind::NativeAccessor),
16297 u: JSPropertySpec_AccessorsOrValue {
16298 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16299 getter: JSPropertySpec_Accessor {
16300 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onsecuritypolicyviolation_getterinfo.get() } },
16301 },
16302 setter: JSPropertySpec_Accessor {
16303 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onsecuritypolicyviolation_setterinfo.get() } },
16304 }
16305 }
16306 }
16307 }
16308,
16309 JSPropertySpec {
16310 name: JSPropertySpec_Name { string_: c"onseeked".as_ptr() },
16311 attributes_: (JSPROP_ENUMERATE),
16312 kind_: (JSPropertySpec_Kind::NativeAccessor),
16313 u: JSPropertySpec_AccessorsOrValue {
16314 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16315 getter: JSPropertySpec_Accessor {
16316 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onseeked_getterinfo.get() } },
16317 },
16318 setter: JSPropertySpec_Accessor {
16319 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onseeked_setterinfo.get() } },
16320 }
16321 }
16322 }
16323 }
16324,
16325 JSPropertySpec {
16326 name: JSPropertySpec_Name { string_: c"onseeking".as_ptr() },
16327 attributes_: (JSPROP_ENUMERATE),
16328 kind_: (JSPropertySpec_Kind::NativeAccessor),
16329 u: JSPropertySpec_AccessorsOrValue {
16330 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16331 getter: JSPropertySpec_Accessor {
16332 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onseeking_getterinfo.get() } },
16333 },
16334 setter: JSPropertySpec_Accessor {
16335 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onseeking_setterinfo.get() } },
16336 }
16337 }
16338 }
16339 }
16340,
16341 JSPropertySpec {
16342 name: JSPropertySpec_Name { string_: c"onselect".as_ptr() },
16343 attributes_: (JSPROP_ENUMERATE),
16344 kind_: (JSPropertySpec_Kind::NativeAccessor),
16345 u: JSPropertySpec_AccessorsOrValue {
16346 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16347 getter: JSPropertySpec_Accessor {
16348 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onselect_getterinfo.get() } },
16349 },
16350 setter: JSPropertySpec_Accessor {
16351 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onselect_setterinfo.get() } },
16352 }
16353 }
16354 }
16355 }
16356,
16357 JSPropertySpec {
16358 name: JSPropertySpec_Name { string_: c"onslotchange".as_ptr() },
16359 attributes_: (JSPROP_ENUMERATE),
16360 kind_: (JSPropertySpec_Kind::NativeAccessor),
16361 u: JSPropertySpec_AccessorsOrValue {
16362 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16363 getter: JSPropertySpec_Accessor {
16364 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onslotchange_getterinfo.get() } },
16365 },
16366 setter: JSPropertySpec_Accessor {
16367 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onslotchange_setterinfo.get() } },
16368 }
16369 }
16370 }
16371 }
16372,
16373 JSPropertySpec {
16374 name: JSPropertySpec_Name { string_: c"onstalled".as_ptr() },
16375 attributes_: (JSPROP_ENUMERATE),
16376 kind_: (JSPropertySpec_Kind::NativeAccessor),
16377 u: JSPropertySpec_AccessorsOrValue {
16378 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16379 getter: JSPropertySpec_Accessor {
16380 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onstalled_getterinfo.get() } },
16381 },
16382 setter: JSPropertySpec_Accessor {
16383 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onstalled_setterinfo.get() } },
16384 }
16385 }
16386 }
16387 }
16388,
16389 JSPropertySpec {
16390 name: JSPropertySpec_Name { string_: c"onsubmit".as_ptr() },
16391 attributes_: (JSPROP_ENUMERATE),
16392 kind_: (JSPropertySpec_Kind::NativeAccessor),
16393 u: JSPropertySpec_AccessorsOrValue {
16394 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16395 getter: JSPropertySpec_Accessor {
16396 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onsubmit_getterinfo.get() } },
16397 },
16398 setter: JSPropertySpec_Accessor {
16399 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onsubmit_setterinfo.get() } },
16400 }
16401 }
16402 }
16403 }
16404,
16405 JSPropertySpec {
16406 name: JSPropertySpec_Name { string_: c"onsuspend".as_ptr() },
16407 attributes_: (JSPROP_ENUMERATE),
16408 kind_: (JSPropertySpec_Kind::NativeAccessor),
16409 u: JSPropertySpec_AccessorsOrValue {
16410 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16411 getter: JSPropertySpec_Accessor {
16412 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onsuspend_getterinfo.get() } },
16413 },
16414 setter: JSPropertySpec_Accessor {
16415 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onsuspend_setterinfo.get() } },
16416 }
16417 }
16418 }
16419 }
16420,
16421 JSPropertySpec {
16422 name: JSPropertySpec_Name { string_: c"ontimeupdate".as_ptr() },
16423 attributes_: (JSPROP_ENUMERATE),
16424 kind_: (JSPropertySpec_Kind::NativeAccessor),
16425 u: JSPropertySpec_AccessorsOrValue {
16426 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16427 getter: JSPropertySpec_Accessor {
16428 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontimeupdate_getterinfo.get() } },
16429 },
16430 setter: JSPropertySpec_Accessor {
16431 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontimeupdate_setterinfo.get() } },
16432 }
16433 }
16434 }
16435 }
16436,
16437 JSPropertySpec {
16438 name: JSPropertySpec_Name { string_: c"ontoggle".as_ptr() },
16439 attributes_: (JSPROP_ENUMERATE),
16440 kind_: (JSPropertySpec_Kind::NativeAccessor),
16441 u: JSPropertySpec_AccessorsOrValue {
16442 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16443 getter: JSPropertySpec_Accessor {
16444 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontoggle_getterinfo.get() } },
16445 },
16446 setter: JSPropertySpec_Accessor {
16447 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontoggle_setterinfo.get() } },
16448 }
16449 }
16450 }
16451 }
16452,
16453 JSPropertySpec {
16454 name: JSPropertySpec_Name { string_: c"onvolumechange".as_ptr() },
16455 attributes_: (JSPROP_ENUMERATE),
16456 kind_: (JSPropertySpec_Kind::NativeAccessor),
16457 u: JSPropertySpec_AccessorsOrValue {
16458 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16459 getter: JSPropertySpec_Accessor {
16460 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onvolumechange_getterinfo.get() } },
16461 },
16462 setter: JSPropertySpec_Accessor {
16463 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onvolumechange_setterinfo.get() } },
16464 }
16465 }
16466 }
16467 }
16468,
16469 JSPropertySpec {
16470 name: JSPropertySpec_Name { string_: c"onwaiting".as_ptr() },
16471 attributes_: (JSPROP_ENUMERATE),
16472 kind_: (JSPropertySpec_Kind::NativeAccessor),
16473 u: JSPropertySpec_AccessorsOrValue {
16474 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16475 getter: JSPropertySpec_Accessor {
16476 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwaiting_getterinfo.get() } },
16477 },
16478 setter: JSPropertySpec_Accessor {
16479 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwaiting_setterinfo.get() } },
16480 }
16481 }
16482 }
16483 }
16484,
16485 JSPropertySpec {
16486 name: JSPropertySpec_Name { string_: c"onwebkitanimationend".as_ptr() },
16487 attributes_: (JSPROP_ENUMERATE),
16488 kind_: (JSPropertySpec_Kind::NativeAccessor),
16489 u: JSPropertySpec_AccessorsOrValue {
16490 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16491 getter: JSPropertySpec_Accessor {
16492 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwebkitanimationend_getterinfo.get() } },
16493 },
16494 setter: JSPropertySpec_Accessor {
16495 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwebkitanimationend_setterinfo.get() } },
16496 }
16497 }
16498 }
16499 }
16500,
16501 JSPropertySpec {
16502 name: JSPropertySpec_Name { string_: c"onwebkitanimationiteration".as_ptr() },
16503 attributes_: (JSPROP_ENUMERATE),
16504 kind_: (JSPropertySpec_Kind::NativeAccessor),
16505 u: JSPropertySpec_AccessorsOrValue {
16506 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16507 getter: JSPropertySpec_Accessor {
16508 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwebkitanimationiteration_getterinfo.get() } },
16509 },
16510 setter: JSPropertySpec_Accessor {
16511 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwebkitanimationiteration_setterinfo.get() } },
16512 }
16513 }
16514 }
16515 }
16516,
16517 JSPropertySpec {
16518 name: JSPropertySpec_Name { string_: c"onwebkitanimationstart".as_ptr() },
16519 attributes_: (JSPROP_ENUMERATE),
16520 kind_: (JSPropertySpec_Kind::NativeAccessor),
16521 u: JSPropertySpec_AccessorsOrValue {
16522 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16523 getter: JSPropertySpec_Accessor {
16524 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwebkitanimationstart_getterinfo.get() } },
16525 },
16526 setter: JSPropertySpec_Accessor {
16527 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwebkitanimationstart_setterinfo.get() } },
16528 }
16529 }
16530 }
16531 }
16532,
16533 JSPropertySpec {
16534 name: JSPropertySpec_Name { string_: c"onwebkittransitionend".as_ptr() },
16535 attributes_: (JSPROP_ENUMERATE),
16536 kind_: (JSPropertySpec_Kind::NativeAccessor),
16537 u: JSPropertySpec_AccessorsOrValue {
16538 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16539 getter: JSPropertySpec_Accessor {
16540 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwebkittransitionend_getterinfo.get() } },
16541 },
16542 setter: JSPropertySpec_Accessor {
16543 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwebkittransitionend_setterinfo.get() } },
16544 }
16545 }
16546 }
16547 }
16548,
16549 JSPropertySpec {
16550 name: JSPropertySpec_Name { string_: c"onwheel".as_ptr() },
16551 attributes_: (JSPROP_ENUMERATE),
16552 kind_: (JSPropertySpec_Kind::NativeAccessor),
16553 u: JSPropertySpec_AccessorsOrValue {
16554 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16555 getter: JSPropertySpec_Accessor {
16556 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onwheel_getterinfo.get() } },
16557 },
16558 setter: JSPropertySpec_Accessor {
16559 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onwheel_setterinfo.get() } },
16560 }
16561 }
16562 }
16563 }
16564,
16565 JSPropertySpec {
16566 name: JSPropertySpec_Name { string_: c"onanimationstart".as_ptr() },
16567 attributes_: (JSPROP_ENUMERATE),
16568 kind_: (JSPropertySpec_Kind::NativeAccessor),
16569 u: JSPropertySpec_AccessorsOrValue {
16570 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16571 getter: JSPropertySpec_Accessor {
16572 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onanimationstart_getterinfo.get() } },
16573 },
16574 setter: JSPropertySpec_Accessor {
16575 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onanimationstart_setterinfo.get() } },
16576 }
16577 }
16578 }
16579 }
16580,
16581 JSPropertySpec {
16582 name: JSPropertySpec_Name { string_: c"onanimationiteration".as_ptr() },
16583 attributes_: (JSPROP_ENUMERATE),
16584 kind_: (JSPropertySpec_Kind::NativeAccessor),
16585 u: JSPropertySpec_AccessorsOrValue {
16586 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16587 getter: JSPropertySpec_Accessor {
16588 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onanimationiteration_getterinfo.get() } },
16589 },
16590 setter: JSPropertySpec_Accessor {
16591 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onanimationiteration_setterinfo.get() } },
16592 }
16593 }
16594 }
16595 }
16596,
16597 JSPropertySpec {
16598 name: JSPropertySpec_Name { string_: c"onanimationend".as_ptr() },
16599 attributes_: (JSPROP_ENUMERATE),
16600 kind_: (JSPropertySpec_Kind::NativeAccessor),
16601 u: JSPropertySpec_AccessorsOrValue {
16602 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16603 getter: JSPropertySpec_Accessor {
16604 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onanimationend_getterinfo.get() } },
16605 },
16606 setter: JSPropertySpec_Accessor {
16607 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onanimationend_setterinfo.get() } },
16608 }
16609 }
16610 }
16611 }
16612,
16613 JSPropertySpec {
16614 name: JSPropertySpec_Name { string_: c"onanimationcancel".as_ptr() },
16615 attributes_: (JSPROP_ENUMERATE),
16616 kind_: (JSPropertySpec_Kind::NativeAccessor),
16617 u: JSPropertySpec_AccessorsOrValue {
16618 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16619 getter: JSPropertySpec_Accessor {
16620 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onanimationcancel_getterinfo.get() } },
16621 },
16622 setter: JSPropertySpec_Accessor {
16623 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onanimationcancel_setterinfo.get() } },
16624 }
16625 }
16626 }
16627 }
16628,
16629 JSPropertySpec {
16630 name: JSPropertySpec_Name { string_: c"ontransitionrun".as_ptr() },
16631 attributes_: (JSPROP_ENUMERATE),
16632 kind_: (JSPropertySpec_Kind::NativeAccessor),
16633 u: JSPropertySpec_AccessorsOrValue {
16634 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16635 getter: JSPropertySpec_Accessor {
16636 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontransitionrun_getterinfo.get() } },
16637 },
16638 setter: JSPropertySpec_Accessor {
16639 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontransitionrun_setterinfo.get() } },
16640 }
16641 }
16642 }
16643 }
16644,
16645 JSPropertySpec {
16646 name: JSPropertySpec_Name { string_: c"ontransitionend".as_ptr() },
16647 attributes_: (JSPROP_ENUMERATE),
16648 kind_: (JSPropertySpec_Kind::NativeAccessor),
16649 u: JSPropertySpec_AccessorsOrValue {
16650 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16651 getter: JSPropertySpec_Accessor {
16652 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontransitionend_getterinfo.get() } },
16653 },
16654 setter: JSPropertySpec_Accessor {
16655 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontransitionend_setterinfo.get() } },
16656 }
16657 }
16658 }
16659 }
16660,
16661 JSPropertySpec {
16662 name: JSPropertySpec_Name { string_: c"ontransitioncancel".as_ptr() },
16663 attributes_: (JSPROP_ENUMERATE),
16664 kind_: (JSPropertySpec_Kind::NativeAccessor),
16665 u: JSPropertySpec_AccessorsOrValue {
16666 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16667 getter: JSPropertySpec_Accessor {
16668 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { ontransitioncancel_getterinfo.get() } },
16669 },
16670 setter: JSPropertySpec_Accessor {
16671 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { ontransitioncancel_setterinfo.get() } },
16672 }
16673 }
16674 }
16675 }
16676,
16677 JSPropertySpec {
16678 name: JSPropertySpec_Name { string_: c"onselectstart".as_ptr() },
16679 attributes_: (JSPROP_ENUMERATE),
16680 kind_: (JSPropertySpec_Kind::NativeAccessor),
16681 u: JSPropertySpec_AccessorsOrValue {
16682 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16683 getter: JSPropertySpec_Accessor {
16684 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onselectstart_getterinfo.get() } },
16685 },
16686 setter: JSPropertySpec_Accessor {
16687 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onselectstart_setterinfo.get() } },
16688 }
16689 }
16690 }
16691 }
16692,
16693 JSPropertySpec {
16694 name: JSPropertySpec_Name { string_: c"onselectionchange".as_ptr() },
16695 attributes_: (JSPROP_ENUMERATE),
16696 kind_: (JSPropertySpec_Kind::NativeAccessor),
16697 u: JSPropertySpec_AccessorsOrValue {
16698 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16699 getter: JSPropertySpec_Accessor {
16700 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onselectionchange_getterinfo.get() } },
16701 },
16702 setter: JSPropertySpec_Accessor {
16703 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onselectionchange_setterinfo.get() } },
16704 }
16705 }
16706 }
16707 }
16708,
16709 JSPropertySpec {
16710 name: JSPropertySpec_Name { string_: c"children".as_ptr() },
16711 attributes_: (JSPROP_ENUMERATE),
16712 kind_: (JSPropertySpec_Kind::NativeAccessor),
16713 u: JSPropertySpec_AccessorsOrValue {
16714 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16715 getter: JSPropertySpec_Accessor {
16716 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { children_getterinfo.get() } },
16717 },
16718 setter: JSPropertySpec_Accessor {
16719 native: JSNativeWrapper { op: None, info: ptr::null() },
16720 }
16721 }
16722 }
16723 }
16724,
16725 JSPropertySpec {
16726 name: JSPropertySpec_Name { string_: c"firstElementChild".as_ptr() },
16727 attributes_: (JSPROP_ENUMERATE),
16728 kind_: (JSPropertySpec_Kind::NativeAccessor),
16729 u: JSPropertySpec_AccessorsOrValue {
16730 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16731 getter: JSPropertySpec_Accessor {
16732 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { firstElementChild_getterinfo.get() } },
16733 },
16734 setter: JSPropertySpec_Accessor {
16735 native: JSNativeWrapper { op: None, info: ptr::null() },
16736 }
16737 }
16738 }
16739 }
16740,
16741 JSPropertySpec {
16742 name: JSPropertySpec_Name { string_: c"lastElementChild".as_ptr() },
16743 attributes_: (JSPROP_ENUMERATE),
16744 kind_: (JSPropertySpec_Kind::NativeAccessor),
16745 u: JSPropertySpec_AccessorsOrValue {
16746 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16747 getter: JSPropertySpec_Accessor {
16748 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { lastElementChild_getterinfo.get() } },
16749 },
16750 setter: JSPropertySpec_Accessor {
16751 native: JSNativeWrapper { op: None, info: ptr::null() },
16752 }
16753 }
16754 }
16755 }
16756,
16757 JSPropertySpec {
16758 name: JSPropertySpec_Name { string_: c"childElementCount".as_ptr() },
16759 attributes_: (JSPROP_ENUMERATE),
16760 kind_: (JSPropertySpec_Kind::NativeAccessor),
16761 u: JSPropertySpec_AccessorsOrValue {
16762 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16763 getter: JSPropertySpec_Accessor {
16764 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { childElementCount_getterinfo.get() } },
16765 },
16766 setter: JSPropertySpec_Accessor {
16767 native: JSNativeWrapper { op: None, info: ptr::null() },
16768 }
16769 }
16770 }
16771 }
16772,
16773 JSPropertySpec::ZERO]))[..]
16774,
16775&Box::leak(Box::new([
16776 JSPropertySpec {
16777 name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
16778 attributes_: (JSPROP_READONLY),
16779 kind_: (JSPropertySpec_Kind::Value),
16780 u: JSPropertySpec_AccessorsOrValue {
16781 value: JSPropertySpec_ValueWrapper {
16782 type_: JSPropertySpec_ValueWrapper_Type::String,
16783 __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
16784 string: c"Document".as_ptr(),
16785 }
16786 }
16787 }
16788 }
16789,
16790 JSPropertySpec::ZERO]))[..]
16791])));
16792}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
16793
16794pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
16795 sAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[0]),
16796 Guard::new(&[Condition::Pref("dom_adoptedstylesheet_enabled"),Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[1]),
16797 Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[2]),
16798 Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[3])])));
16799}static sLegacyUnforgeableAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
16800
16801pub(crate) fn init_sLegacyUnforgeableAttributes_specs<D: DomTypes>() {
16802 sLegacyUnforgeableAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
16803 JSPropertySpec {
16804 name: JSPropertySpec_Name { string_: c"location".as_ptr() },
16805 attributes_: (JSPROP_ENUMERATE | JSPROP_PERMANENT),
16806 kind_: (JSPropertySpec_Kind::NativeAccessor),
16807 u: JSPropertySpec_AccessorsOrValue {
16808 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
16809 getter: JSPropertySpec_Accessor {
16810 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { location_getterinfo.get() } },
16811 },
16812 setter: JSPropertySpec_Accessor {
16813 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { location_setterinfo.get() } },
16814 }
16815 }
16816 }
16817 }
16818,
16819 JSPropertySpec::ZERO]))[..]
16820])));
16821}static sLegacyUnforgeableAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
16822
16823pub(crate) fn init_sLegacyUnforgeableAttributes_prefs<D: DomTypes>() {
16824 sLegacyUnforgeableAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sLegacyUnforgeableAttributes_specs.get() })[0])])));
16825}
16826pub fn GetProtoObject<D: DomTypes>
16827(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
16828 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::Document), CreateInterfaceObjects::<D>, rval)
16830}
16831
16832
16833static PrototypeClass: JSClass = JSClass {
16834 name: c"DocumentPrototype".as_ptr(),
16835 flags:
16836 (1 & JSCLASS_RESERVED_SLOTS_MASK ) << JSCLASS_RESERVED_SLOTS_SHIFT,
16838 cOps: ptr::null(),
16839 spec: ptr::null(),
16840 ext: ptr::null(),
16841 oOps: ptr::null(),
16842};
16843
16844unsafe extern "C" fn _constructor<D: DomTypes>
16845(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
16846 let mut result = false;
16847 wrap_panic(&mut || result = {
16848 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16849 let args = CallArgs::from_vp(vp, argc);
16850 let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());
16851
16852 call_default_constructor::<D>(
16853 SafeJSContext::from_ptr(cx.raw_cx()),
16854 &args,
16855 &global,
16856 PrototypeList::ID::Document,
16857 "Document",
16858 CreateInterfaceObjects::<D>,
16859 |cx: SafeJSContext, args: &CallArgs, global: &D::GlobalScope, desired_proto: HandleObject| {
16860 let result: Result<DomRoot<D::Document>, Error> = <D::Document>::Constructor(global.downcast::<D::Window>().unwrap(), Some(desired_proto), CanGc::note());
16861 let result = match result {
16862 Ok(result) => result,
16863 Err(e) => {
16864 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
16865 return false;
16866 },
16867 };
16868
16869 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16870 return true;
16871 }
16872 )
16873
16874 });
16875 result
16876}
16877
16878
16879static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();
16880
16881pub(crate) fn init_interface_object<D: DomTypes>() {
16882 INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
16883 Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
16884 b"function Document() {\n [native code]\n}",
16885 PrototypeList::ID::Document,
16886 2,
16887 ));
16888}
16889
16890pub fn GetConstructorObject<D: DomTypes>
16891(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
16892 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::Document), CreateInterfaceObjects::<D>, rval)
16894}
16895
16896pub fn DefineDOMInterface<D: DomTypes>
16897(cx: SafeJSContext, global: HandleObject){
16898 define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::Document),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
16899}
16900
16901pub fn ConstructorEnabled<D: DomTypes>
16902(aCx: SafeJSContext, aObj: HandleObject) -> bool{
16903 is_exposed_in(aObj, Globals::WINDOW)
16904}
16905
16906unsafe fn CreateInterfaceObjects<D: DomTypes>
16907(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
16908
16909 rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
16910 Node_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
16911 assert!(!prototype_proto.is_null());
16912
16913 rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
16914 create_interface_prototype_object::<D>(cx,
16915 global,
16916 prototype_proto.handle(),
16917 &PrototypeClass,
16918 sMethods.get(),
16919 sAttributes.get(),
16920 &[],
16921 unscopable_names,
16922 prototype.handle_mut());
16923 assert!(!prototype.is_null());
16924 assert!((*cache)[PrototypeList::ID::Document as usize].is_null());
16925 (*cache)[PrototypeList::ID::Document as usize] = prototype.get();
16926 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::Document as isize),
16927 ptr::null_mut(),
16928 prototype.get());
16929
16930 rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
16931
16932 Node_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());
16933
16934 assert!(!interface_proto.is_null());
16935
16936 rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
16937 create_noncallback_interface_object::<D>(cx,
16938 global,
16939 interface_proto.handle(),
16940 INTERFACE_OBJECT_CLASS.get(),
16941 sStaticMethods.get(),
16942 &[],
16943 &[],
16944 prototype.handle(),
16945 c"Document",
16946 0,
16947 &[],
16948 interface.handle_mut());
16949 assert!(!interface.is_null());
16950
16951 assert!((*cache)[PrototypeList::Constructor::Document as usize].is_null());
16952 (*cache)[PrototypeList::Constructor::Document as usize] = interface.get();
16953 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::Document as isize),
16954 ptr::null_mut(),
16955 interface.get());
16956
16957
16958 rooted!(&in(cx) let mut unforgeable_holder = ptr::null_mut::<JSObject>());
16959 unforgeable_holder.handle_mut().set(
16960 JS_NewObjectWithoutMetadata(cx.raw_cx(), ptr::null(), HandleObject::null()));
16961 assert!(!unforgeable_holder.is_null());
16962
16963 define_guarded_properties::<D>(cx, unforgeable_holder.handle(), unsafe { sLegacyUnforgeableAttributes.get() }, global);
16964 let val = ObjectValue(unforgeable_holder.get());
16965 JS_SetReservedSlot(prototype.get(), DOM_PROTO_UNFORGEABLE_HOLDER_SLOT, &val)
16966}
16967
16968
16969 pub(crate) fn init_statics<D: DomTypes>() {
16970 init_interface_object::<D>();
16971
16972 crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_getElementsByTagName_methodinfo::<D>();
16973crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_getElementsByTagNameNS_methodinfo::<D>();
16974crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_getElementsByClassName_methodinfo::<D>();
16975crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createElement_methodinfo::<D>();
16976crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createElementNS_methodinfo::<D>();
16977crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createDocumentFragment_methodinfo::<D>();
16978crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createTextNode_methodinfo::<D>();
16979crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createCDATASection_methodinfo::<D>();
16980crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createComment_methodinfo::<D>();
16981crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createProcessingInstruction_methodinfo::<D>();
16982crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_importNode_methodinfo::<D>();
16983crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_adoptNode_methodinfo::<D>();
16984crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createAttribute_methodinfo::<D>();
16985crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createAttributeNS_methodinfo::<D>();
16986crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createEvent_methodinfo::<D>();
16987crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createRange_methodinfo::<D>();
16988crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createNodeIterator_methodinfo::<D>();
16989crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createTreeWalker_methodinfo::<D>();
16990crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_getElementsByName_methodinfo::<D>();
16991crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_open_methodinfo::<D>();
16992crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_close_methodinfo::<D>();
16993crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_write_methodinfo::<D>();
16994crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_writeln_methodinfo::<D>();
16995crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_hasFocus_methodinfo::<D>();
16996crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_queryCommandSupported_methodinfo::<D>();
16997crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_clear_methodinfo::<D>();
16998crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_captureEvents_methodinfo::<D>();
16999crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_releaseEvents_methodinfo::<D>();
17000crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_exitFullscreen_methodinfo::<D>();
17001crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_getSelection_methodinfo::<D>();
17002crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_servoGetMediaControls_methodinfo::<D>();
17003crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_elementFromPoint_methodinfo::<D>();
17004crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_elementsFromPoint_methodinfo::<D>();
17005crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_getElementById_methodinfo::<D>();
17006crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_prepend_methodinfo::<D>();
17007crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_append_methodinfo::<D>();
17008crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_replaceChildren_methodinfo::<D>();
17009crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_querySelector_methodinfo::<D>();
17010crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_querySelectorAll_methodinfo::<D>();
17011crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createExpression_methodinfo::<D>();
17012crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_createNSResolver_methodinfo::<D>();
17013crate::codegen::GenericBindings::DocumentBinding::Document_Binding::init_evaluate_methodinfo::<D>();
17014 init_implementation_getterinfo::<D>();
17015init_URL_getterinfo::<D>();
17016init_documentURI_getterinfo::<D>();
17017init_compatMode_getterinfo::<D>();
17018init_characterSet_getterinfo::<D>();
17019init_charset_getterinfo::<D>();
17020init_inputEncoding_getterinfo::<D>();
17021init_contentType_getterinfo::<D>();
17022init_doctype_getterinfo::<D>();
17023init_documentElement_getterinfo::<D>();
17024init_location_getterinfo::<D>();
17025init_domain_getterinfo::<D>();
17026init_referrer_getterinfo::<D>();
17027init_cookie_getterinfo::<D>();
17028init_lastModified_getterinfo::<D>();
17029init_readyState_getterinfo::<D>();
17030init_title_getterinfo::<D>();
17031init_body_getterinfo::<D>();
17032init_head_getterinfo::<D>();
17033init_images_getterinfo::<D>();
17034init_embeds_getterinfo::<D>();
17035init_plugins_getterinfo::<D>();
17036init_links_getterinfo::<D>();
17037init_forms_getterinfo::<D>();
17038init_scripts_getterinfo::<D>();
17039init_currentScript_getterinfo::<D>();
17040init_defaultView_getterinfo::<D>();
17041init_hidden_getterinfo::<D>();
17042init_visibilityState_getterinfo::<D>();
17043init_onreadystatechange_getterinfo::<D>();
17044init_fgColor_getterinfo::<D>();
17045init_bgColor_getterinfo::<D>();
17046init_anchors_getterinfo::<D>();
17047init_applets_getterinfo::<D>();
17048init_fullscreenEnabled_getterinfo::<D>();
17049init_fullscreenElement_getterinfo::<D>();
17050init_fullscreen_getterinfo::<D>();
17051init_onfullscreenchange_getterinfo::<D>();
17052init_onfullscreenerror_getterinfo::<D>();
17053init_scrollingElement_getterinfo::<D>();
17054init_activeElement_getterinfo::<D>();
17055init_styleSheets_getterinfo::<D>();
17056init_adoptedStyleSheets_getterinfo::<D>();
17057init_fonts_getterinfo::<D>();
17058init_onabort_getterinfo::<D>();
17059init_onauxclick_getterinfo::<D>();
17060init_onbeforeinput_getterinfo::<D>();
17061init_onbeforematch_getterinfo::<D>();
17062init_onbeforetoggle_getterinfo::<D>();
17063init_onblur_getterinfo::<D>();
17064init_oncancel_getterinfo::<D>();
17065init_oncanplay_getterinfo::<D>();
17066init_oncanplaythrough_getterinfo::<D>();
17067init_onchange_getterinfo::<D>();
17068init_onclick_getterinfo::<D>();
17069init_onclose_getterinfo::<D>();
17070init_oncommand_getterinfo::<D>();
17071init_oncontextlost_getterinfo::<D>();
17072init_oncontextmenu_getterinfo::<D>();
17073init_oncontextrestored_getterinfo::<D>();
17074init_oncopy_getterinfo::<D>();
17075init_oncuechange_getterinfo::<D>();
17076init_oncut_getterinfo::<D>();
17077init_ondblclick_getterinfo::<D>();
17078init_ondrag_getterinfo::<D>();
17079init_ondragend_getterinfo::<D>();
17080init_ondragenter_getterinfo::<D>();
17081init_ondragleave_getterinfo::<D>();
17082init_ondragover_getterinfo::<D>();
17083init_ondragstart_getterinfo::<D>();
17084init_ondrop_getterinfo::<D>();
17085init_ondurationchange_getterinfo::<D>();
17086init_onemptied_getterinfo::<D>();
17087init_onended_getterinfo::<D>();
17088init_onerror_getterinfo::<D>();
17089init_onfocus_getterinfo::<D>();
17090init_onformdata_getterinfo::<D>();
17091init_oninput_getterinfo::<D>();
17092init_oninvalid_getterinfo::<D>();
17093init_onkeydown_getterinfo::<D>();
17094init_onkeypress_getterinfo::<D>();
17095init_onkeyup_getterinfo::<D>();
17096init_onload_getterinfo::<D>();
17097init_onloadeddata_getterinfo::<D>();
17098init_onloadedmetadata_getterinfo::<D>();
17099init_onloadstart_getterinfo::<D>();
17100init_onmousedown_getterinfo::<D>();
17101init_onmouseenter_getterinfo::<D>();
17102init_onmouseleave_getterinfo::<D>();
17103init_onmousemove_getterinfo::<D>();
17104init_onmouseout_getterinfo::<D>();
17105init_onmouseover_getterinfo::<D>();
17106init_onmouseup_getterinfo::<D>();
17107init_onpaste_getterinfo::<D>();
17108init_onpause_getterinfo::<D>();
17109init_onplay_getterinfo::<D>();
17110init_onplaying_getterinfo::<D>();
17111init_onprogress_getterinfo::<D>();
17112init_onratechange_getterinfo::<D>();
17113init_onreset_getterinfo::<D>();
17114init_onresize_getterinfo::<D>();
17115init_onscroll_getterinfo::<D>();
17116init_onscrollend_getterinfo::<D>();
17117init_onsecuritypolicyviolation_getterinfo::<D>();
17118init_onseeked_getterinfo::<D>();
17119init_onseeking_getterinfo::<D>();
17120init_onselect_getterinfo::<D>();
17121init_onslotchange_getterinfo::<D>();
17122init_onstalled_getterinfo::<D>();
17123init_onsubmit_getterinfo::<D>();
17124init_onsuspend_getterinfo::<D>();
17125init_ontimeupdate_getterinfo::<D>();
17126init_ontoggle_getterinfo::<D>();
17127init_onvolumechange_getterinfo::<D>();
17128init_onwaiting_getterinfo::<D>();
17129init_onwebkitanimationend_getterinfo::<D>();
17130init_onwebkitanimationiteration_getterinfo::<D>();
17131init_onwebkitanimationstart_getterinfo::<D>();
17132init_onwebkittransitionend_getterinfo::<D>();
17133init_onwheel_getterinfo::<D>();
17134init_onanimationstart_getterinfo::<D>();
17135init_onanimationiteration_getterinfo::<D>();
17136init_onanimationend_getterinfo::<D>();
17137init_onanimationcancel_getterinfo::<D>();
17138init_ontransitionrun_getterinfo::<D>();
17139init_ontransitionend_getterinfo::<D>();
17140init_ontransitioncancel_getterinfo::<D>();
17141init_onselectstart_getterinfo::<D>();
17142init_onselectionchange_getterinfo::<D>();
17143init_children_getterinfo::<D>();
17144init_firstElementChild_getterinfo::<D>();
17145init_lastElementChild_getterinfo::<D>();
17146init_childElementCount_getterinfo::<D>();
17147 init_location_setterinfo::<D>();
17148init_domain_setterinfo::<D>();
17149init_cookie_setterinfo::<D>();
17150init_title_setterinfo::<D>();
17151init_body_setterinfo::<D>();
17152init_onreadystatechange_setterinfo::<D>();
17153init_fgColor_setterinfo::<D>();
17154init_bgColor_setterinfo::<D>();
17155init_onfullscreenchange_setterinfo::<D>();
17156init_onfullscreenerror_setterinfo::<D>();
17157init_adoptedStyleSheets_setterinfo::<D>();
17158init_onabort_setterinfo::<D>();
17159init_onauxclick_setterinfo::<D>();
17160init_onbeforeinput_setterinfo::<D>();
17161init_onbeforematch_setterinfo::<D>();
17162init_onbeforetoggle_setterinfo::<D>();
17163init_onblur_setterinfo::<D>();
17164init_oncancel_setterinfo::<D>();
17165init_oncanplay_setterinfo::<D>();
17166init_oncanplaythrough_setterinfo::<D>();
17167init_onchange_setterinfo::<D>();
17168init_onclick_setterinfo::<D>();
17169init_onclose_setterinfo::<D>();
17170init_oncommand_setterinfo::<D>();
17171init_oncontextlost_setterinfo::<D>();
17172init_oncontextmenu_setterinfo::<D>();
17173init_oncontextrestored_setterinfo::<D>();
17174init_oncopy_setterinfo::<D>();
17175init_oncuechange_setterinfo::<D>();
17176init_oncut_setterinfo::<D>();
17177init_ondblclick_setterinfo::<D>();
17178init_ondrag_setterinfo::<D>();
17179init_ondragend_setterinfo::<D>();
17180init_ondragenter_setterinfo::<D>();
17181init_ondragleave_setterinfo::<D>();
17182init_ondragover_setterinfo::<D>();
17183init_ondragstart_setterinfo::<D>();
17184init_ondrop_setterinfo::<D>();
17185init_ondurationchange_setterinfo::<D>();
17186init_onemptied_setterinfo::<D>();
17187init_onended_setterinfo::<D>();
17188init_onerror_setterinfo::<D>();
17189init_onfocus_setterinfo::<D>();
17190init_onformdata_setterinfo::<D>();
17191init_oninput_setterinfo::<D>();
17192init_oninvalid_setterinfo::<D>();
17193init_onkeydown_setterinfo::<D>();
17194init_onkeypress_setterinfo::<D>();
17195init_onkeyup_setterinfo::<D>();
17196init_onload_setterinfo::<D>();
17197init_onloadeddata_setterinfo::<D>();
17198init_onloadedmetadata_setterinfo::<D>();
17199init_onloadstart_setterinfo::<D>();
17200init_onmousedown_setterinfo::<D>();
17201init_onmouseenter_setterinfo::<D>();
17202init_onmouseleave_setterinfo::<D>();
17203init_onmousemove_setterinfo::<D>();
17204init_onmouseout_setterinfo::<D>();
17205init_onmouseover_setterinfo::<D>();
17206init_onmouseup_setterinfo::<D>();
17207init_onpaste_setterinfo::<D>();
17208init_onpause_setterinfo::<D>();
17209init_onplay_setterinfo::<D>();
17210init_onplaying_setterinfo::<D>();
17211init_onprogress_setterinfo::<D>();
17212init_onratechange_setterinfo::<D>();
17213init_onreset_setterinfo::<D>();
17214init_onresize_setterinfo::<D>();
17215init_onscroll_setterinfo::<D>();
17216init_onscrollend_setterinfo::<D>();
17217init_onsecuritypolicyviolation_setterinfo::<D>();
17218init_onseeked_setterinfo::<D>();
17219init_onseeking_setterinfo::<D>();
17220init_onselect_setterinfo::<D>();
17221init_onslotchange_setterinfo::<D>();
17222init_onstalled_setterinfo::<D>();
17223init_onsubmit_setterinfo::<D>();
17224init_onsuspend_setterinfo::<D>();
17225init_ontimeupdate_setterinfo::<D>();
17226init_ontoggle_setterinfo::<D>();
17227init_onvolumechange_setterinfo::<D>();
17228init_onwaiting_setterinfo::<D>();
17229init_onwebkitanimationend_setterinfo::<D>();
17230init_onwebkitanimationiteration_setterinfo::<D>();
17231init_onwebkitanimationstart_setterinfo::<D>();
17232init_onwebkittransitionend_setterinfo::<D>();
17233init_onwheel_setterinfo::<D>();
17234init_onanimationstart_setterinfo::<D>();
17235init_onanimationiteration_setterinfo::<D>();
17236init_onanimationend_setterinfo::<D>();
17237init_onanimationcancel_setterinfo::<D>();
17238init_ontransitionrun_setterinfo::<D>();
17239init_ontransitionend_setterinfo::<D>();
17240init_ontransitioncancel_setterinfo::<D>();
17241init_onselectstart_setterinfo::<D>();
17242init_onselectionchange_setterinfo::<D>();
17243
17244 init_sStaticMethods_specs::<D>();
17245init_sStaticMethods_prefs::<D>();
17246init_sMethods_specs::<D>();
17247init_sMethods_prefs::<D>();
17248init_sAttributes_specs::<D>();
17249init_sAttributes_prefs::<D>();
17250init_sLegacyUnforgeableAttributes_specs::<D>();
17251init_sLegacyUnforgeableAttributes_prefs::<D>();
17252 }
17253 }