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::DOMMatrixBinding::DOMMatrixInit;
6use crate::codegen::GenericBindings::DOMPointBinding::DOMPointInit;
7use crate::codegen::GenericBindings::DOMPointReadOnlyBinding::DOMPointReadOnly_Binding;
8use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
9use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
10use crate::codegen::GenericBindings::WorkletGlobalScopeBinding::WorkletGlobalScope_Binding;
11use crate::import::base::*;
12
13pub use self::DOMMatrixReadOnly_Binding::{Wrap, DOMMatrixReadOnlyMethods, GetProtoObject, GetConstructorObject, DefineDOMInterface};
14pub mod DOMMatrixReadOnly_Binding {
15use crate::codegen::GenericBindings::DOMMatrixBinding::DOMMatrixInit;
16use crate::codegen::GenericBindings::DOMPointBinding::DOMPointInit;
17use crate::codegen::GenericBindings::DOMPointReadOnlyBinding::DOMPointReadOnly_Binding;
18use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
19use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
20use crate::codegen::GenericBindings::WorkletGlobalScopeBinding::WorkletGlobalScope_Binding;
21use crate::import::module::*;
22
23unsafe extern "C" fn fromMatrix<D: DomTypes>
24(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
25 let mut result = false;
26 wrap_panic(&mut || result = (|| {
27 let args = CallArgs::from_vp(vp, argc);
28 let global = D::GlobalScope::from_object(args.callee());
29 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
30 let args = CallArgs::from_vp(vp, argc);
31 let arg0: crate::codegen::GenericBindings::DOMMatrixBinding::DOMMatrixInit = if args.get(0).is_undefined() {
32 crate::codegen::GenericBindings::DOMMatrixBinding::DOMMatrixInit::empty()
33 } else {
34 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
35 Ok(ConversionResult::Success(value)) => value,
36 Ok(ConversionResult::Failure(error)) => {
37 throw_type_error(cx.raw_cx(), &error);
38 return false;
39
40 }
41 _ => {
42 return false;
43
44 },
45 }
46
47 };
48 let result: Result<DomRoot<D::DOMMatrixReadOnly>, Error> = <D::DOMMatrixReadOnly>::FromMatrix(&global, &arg0, CanGc::note());
49 let result = match result {
50 Ok(result) => result,
51 Err(e) => {
52 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
53 return false;
54 },
55 };
56
57 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
58 return true;
59 })());
60 result
61}
62
63unsafe extern "C" fn fromFloat32Array<D: DomTypes>
64(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
65 let mut result = false;
66 wrap_panic(&mut || result = (|| {
67 let args = CallArgs::from_vp(vp, argc);
68 let global = D::GlobalScope::from_object(args.callee());
69 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
70 let args = CallArgs::from_vp(vp, argc);
71
72 if argc < 1 {
73 throw_type_error(cx.raw_cx(), "Not enough arguments to \"DOMMatrixReadOnly.fromFloat32Array\".");
74 return false;
75 }
76 let arg0: typedarray::Float32Array = if HandleValue::from_raw(args.get(0)).get().is_object() {
77 match typedarray::Float32Array::from(HandleValue::from_raw(args.get(0)).get().to_object()) {
78 Ok(val) => val,
79 Err(()) => {
80 throw_type_error(cx.raw_cx(), "value is not a typed array.");
81 return false;
82
83 }
84 }
85
86 } else {
87 throw_type_error(cx.raw_cx(), "Value is not an object.");
88 return false;
89
90 };
91 auto_root!(&in(cx) let arg0 = arg0);
92 let result: Result<DomRoot<D::DOMMatrixReadOnly>, Error> = <D::DOMMatrixReadOnly>::FromFloat32Array(&global, arg0, CanGc::note());
93 let result = match result {
94 Ok(result) => result,
95 Err(e) => {
96 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
97 return false;
98 },
99 };
100
101 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
102 return true;
103 })());
104 result
105}
106
107unsafe extern "C" fn fromFloat64Array<D: DomTypes>
108(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
109 let mut result = false;
110 wrap_panic(&mut || result = (|| {
111 let args = CallArgs::from_vp(vp, argc);
112 let global = D::GlobalScope::from_object(args.callee());
113 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
114 let args = CallArgs::from_vp(vp, argc);
115
116 if argc < 1 {
117 throw_type_error(cx.raw_cx(), "Not enough arguments to \"DOMMatrixReadOnly.fromFloat64Array\".");
118 return false;
119 }
120 let arg0: typedarray::Float64Array = if HandleValue::from_raw(args.get(0)).get().is_object() {
121 match typedarray::Float64Array::from(HandleValue::from_raw(args.get(0)).get().to_object()) {
122 Ok(val) => val,
123 Err(()) => {
124 throw_type_error(cx.raw_cx(), "value is not a typed array.");
125 return false;
126
127 }
128 }
129
130 } else {
131 throw_type_error(cx.raw_cx(), "Value is not an object.");
132 return false;
133
134 };
135 auto_root!(&in(cx) let arg0 = arg0);
136 let result: Result<DomRoot<D::DOMMatrixReadOnly>, Error> = <D::DOMMatrixReadOnly>::FromFloat64Array(&global, arg0, CanGc::note());
137 let result = match result {
138 Ok(result) => result,
139 Err(e) => {
140 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
141 return false;
142 },
143 };
144
145 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
146 return true;
147 })());
148 result
149}
150
151unsafe extern "C" fn get_a<D: DomTypes>
152(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
153 let mut result = false;
154 wrap_panic(&mut || result = (|| {
155 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
156 let this = &*(this as *const D::DOMMatrixReadOnly);
157 let result: f64 = this.A();
158
159 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
160 return true;
161 })());
162 result
163}
164
165
166static a_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
167
168pub(crate) fn init_a_getterinfo<D: DomTypes>() {
169 a_getterinfo.set(JSJitInfo {
170 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
171 getter: Some(get_a::<D>)
172 },
173 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
174 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
175 },
176 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
177 _bitfield_align_1: [],
178 _bitfield_1: __BindgenBitfieldUnit::new(
179 new_jsjitinfo_bitfield_1!(
180 JSJitInfo_OpType::Getter as u8,
181 JSJitInfo_AliasSet::AliasEverything as u8,
182 JSValueType::JSVAL_TYPE_DOUBLE as u8,
183 true,
184 false,
185 false,
186 false,
187 false,
188 false,
189 0,
190 ).to_ne_bytes()
191 ),
192});
193}
194unsafe extern "C" fn get_b<D: DomTypes>
195(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
196 let mut result = false;
197 wrap_panic(&mut || result = (|| {
198 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
199 let this = &*(this as *const D::DOMMatrixReadOnly);
200 let result: f64 = this.B();
201
202 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
203 return true;
204 })());
205 result
206}
207
208
209static b_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
210
211pub(crate) fn init_b_getterinfo<D: DomTypes>() {
212 b_getterinfo.set(JSJitInfo {
213 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
214 getter: Some(get_b::<D>)
215 },
216 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
217 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
218 },
219 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
220 _bitfield_align_1: [],
221 _bitfield_1: __BindgenBitfieldUnit::new(
222 new_jsjitinfo_bitfield_1!(
223 JSJitInfo_OpType::Getter as u8,
224 JSJitInfo_AliasSet::AliasEverything as u8,
225 JSValueType::JSVAL_TYPE_DOUBLE as u8,
226 true,
227 false,
228 false,
229 false,
230 false,
231 false,
232 0,
233 ).to_ne_bytes()
234 ),
235});
236}
237unsafe extern "C" fn get_c<D: DomTypes>
238(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
239 let mut result = false;
240 wrap_panic(&mut || result = (|| {
241 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
242 let this = &*(this as *const D::DOMMatrixReadOnly);
243 let result: f64 = this.C();
244
245 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
246 return true;
247 })());
248 result
249}
250
251
252static c_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
253
254pub(crate) fn init_c_getterinfo<D: DomTypes>() {
255 c_getterinfo.set(JSJitInfo {
256 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
257 getter: Some(get_c::<D>)
258 },
259 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
260 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
261 },
262 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
263 _bitfield_align_1: [],
264 _bitfield_1: __BindgenBitfieldUnit::new(
265 new_jsjitinfo_bitfield_1!(
266 JSJitInfo_OpType::Getter as u8,
267 JSJitInfo_AliasSet::AliasEverything as u8,
268 JSValueType::JSVAL_TYPE_DOUBLE as u8,
269 true,
270 false,
271 false,
272 false,
273 false,
274 false,
275 0,
276 ).to_ne_bytes()
277 ),
278});
279}
280unsafe extern "C" fn get_d<D: DomTypes>
281(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
282 let mut result = false;
283 wrap_panic(&mut || result = (|| {
284 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
285 let this = &*(this as *const D::DOMMatrixReadOnly);
286 let result: f64 = this.D();
287
288 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
289 return true;
290 })());
291 result
292}
293
294
295static d_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
296
297pub(crate) fn init_d_getterinfo<D: DomTypes>() {
298 d_getterinfo.set(JSJitInfo {
299 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
300 getter: Some(get_d::<D>)
301 },
302 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
303 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
304 },
305 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
306 _bitfield_align_1: [],
307 _bitfield_1: __BindgenBitfieldUnit::new(
308 new_jsjitinfo_bitfield_1!(
309 JSJitInfo_OpType::Getter as u8,
310 JSJitInfo_AliasSet::AliasEverything as u8,
311 JSValueType::JSVAL_TYPE_DOUBLE as u8,
312 true,
313 false,
314 false,
315 false,
316 false,
317 false,
318 0,
319 ).to_ne_bytes()
320 ),
321});
322}
323unsafe extern "C" fn get_e<D: DomTypes>
324(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
325 let mut result = false;
326 wrap_panic(&mut || result = (|| {
327 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
328 let this = &*(this as *const D::DOMMatrixReadOnly);
329 let result: f64 = this.E();
330
331 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
332 return true;
333 })());
334 result
335}
336
337
338static e_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
339
340pub(crate) fn init_e_getterinfo<D: DomTypes>() {
341 e_getterinfo.set(JSJitInfo {
342 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
343 getter: Some(get_e::<D>)
344 },
345 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
346 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
347 },
348 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
349 _bitfield_align_1: [],
350 _bitfield_1: __BindgenBitfieldUnit::new(
351 new_jsjitinfo_bitfield_1!(
352 JSJitInfo_OpType::Getter as u8,
353 JSJitInfo_AliasSet::AliasEverything as u8,
354 JSValueType::JSVAL_TYPE_DOUBLE as u8,
355 true,
356 false,
357 false,
358 false,
359 false,
360 false,
361 0,
362 ).to_ne_bytes()
363 ),
364});
365}
366unsafe extern "C" fn get_f<D: DomTypes>
367(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
368 let mut result = false;
369 wrap_panic(&mut || result = (|| {
370 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
371 let this = &*(this as *const D::DOMMatrixReadOnly);
372 let result: f64 = this.F();
373
374 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
375 return true;
376 })());
377 result
378}
379
380
381static f_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
382
383pub(crate) fn init_f_getterinfo<D: DomTypes>() {
384 f_getterinfo.set(JSJitInfo {
385 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
386 getter: Some(get_f::<D>)
387 },
388 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
389 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
390 },
391 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
392 _bitfield_align_1: [],
393 _bitfield_1: __BindgenBitfieldUnit::new(
394 new_jsjitinfo_bitfield_1!(
395 JSJitInfo_OpType::Getter as u8,
396 JSJitInfo_AliasSet::AliasEverything as u8,
397 JSValueType::JSVAL_TYPE_DOUBLE as u8,
398 true,
399 false,
400 false,
401 false,
402 false,
403 false,
404 0,
405 ).to_ne_bytes()
406 ),
407});
408}
409unsafe extern "C" fn get_m11<D: DomTypes>
410(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
411 let mut result = false;
412 wrap_panic(&mut || result = (|| {
413 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
414 let this = &*(this as *const D::DOMMatrixReadOnly);
415 let result: f64 = this.M11();
416
417 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
418 return true;
419 })());
420 result
421}
422
423
424static m11_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
425
426pub(crate) fn init_m11_getterinfo<D: DomTypes>() {
427 m11_getterinfo.set(JSJitInfo {
428 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
429 getter: Some(get_m11::<D>)
430 },
431 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
432 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
433 },
434 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
435 _bitfield_align_1: [],
436 _bitfield_1: __BindgenBitfieldUnit::new(
437 new_jsjitinfo_bitfield_1!(
438 JSJitInfo_OpType::Getter as u8,
439 JSJitInfo_AliasSet::AliasEverything as u8,
440 JSValueType::JSVAL_TYPE_DOUBLE as u8,
441 true,
442 false,
443 false,
444 false,
445 false,
446 false,
447 0,
448 ).to_ne_bytes()
449 ),
450});
451}
452unsafe extern "C" fn get_m12<D: DomTypes>
453(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
454 let mut result = false;
455 wrap_panic(&mut || result = (|| {
456 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
457 let this = &*(this as *const D::DOMMatrixReadOnly);
458 let result: f64 = this.M12();
459
460 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
461 return true;
462 })());
463 result
464}
465
466
467static m12_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
468
469pub(crate) fn init_m12_getterinfo<D: DomTypes>() {
470 m12_getterinfo.set(JSJitInfo {
471 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
472 getter: Some(get_m12::<D>)
473 },
474 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
475 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
476 },
477 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
478 _bitfield_align_1: [],
479 _bitfield_1: __BindgenBitfieldUnit::new(
480 new_jsjitinfo_bitfield_1!(
481 JSJitInfo_OpType::Getter as u8,
482 JSJitInfo_AliasSet::AliasEverything as u8,
483 JSValueType::JSVAL_TYPE_DOUBLE as u8,
484 true,
485 false,
486 false,
487 false,
488 false,
489 false,
490 0,
491 ).to_ne_bytes()
492 ),
493});
494}
495unsafe extern "C" fn get_m13<D: DomTypes>
496(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
497 let mut result = false;
498 wrap_panic(&mut || result = (|| {
499 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
500 let this = &*(this as *const D::DOMMatrixReadOnly);
501 let result: f64 = this.M13();
502
503 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
504 return true;
505 })());
506 result
507}
508
509
510static m13_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
511
512pub(crate) fn init_m13_getterinfo<D: DomTypes>() {
513 m13_getterinfo.set(JSJitInfo {
514 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
515 getter: Some(get_m13::<D>)
516 },
517 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
518 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
519 },
520 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
521 _bitfield_align_1: [],
522 _bitfield_1: __BindgenBitfieldUnit::new(
523 new_jsjitinfo_bitfield_1!(
524 JSJitInfo_OpType::Getter as u8,
525 JSJitInfo_AliasSet::AliasEverything as u8,
526 JSValueType::JSVAL_TYPE_DOUBLE as u8,
527 true,
528 false,
529 false,
530 false,
531 false,
532 false,
533 0,
534 ).to_ne_bytes()
535 ),
536});
537}
538unsafe extern "C" fn get_m14<D: DomTypes>
539(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
540 let mut result = false;
541 wrap_panic(&mut || result = (|| {
542 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
543 let this = &*(this as *const D::DOMMatrixReadOnly);
544 let result: f64 = this.M14();
545
546 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
547 return true;
548 })());
549 result
550}
551
552
553static m14_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
554
555pub(crate) fn init_m14_getterinfo<D: DomTypes>() {
556 m14_getterinfo.set(JSJitInfo {
557 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
558 getter: Some(get_m14::<D>)
559 },
560 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
561 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
562 },
563 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
564 _bitfield_align_1: [],
565 _bitfield_1: __BindgenBitfieldUnit::new(
566 new_jsjitinfo_bitfield_1!(
567 JSJitInfo_OpType::Getter as u8,
568 JSJitInfo_AliasSet::AliasEverything as u8,
569 JSValueType::JSVAL_TYPE_DOUBLE as u8,
570 true,
571 false,
572 false,
573 false,
574 false,
575 false,
576 0,
577 ).to_ne_bytes()
578 ),
579});
580}
581unsafe extern "C" fn get_m21<D: DomTypes>
582(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
583 let mut result = false;
584 wrap_panic(&mut || result = (|| {
585 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
586 let this = &*(this as *const D::DOMMatrixReadOnly);
587 let result: f64 = this.M21();
588
589 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
590 return true;
591 })());
592 result
593}
594
595
596static m21_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
597
598pub(crate) fn init_m21_getterinfo<D: DomTypes>() {
599 m21_getterinfo.set(JSJitInfo {
600 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
601 getter: Some(get_m21::<D>)
602 },
603 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
604 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
605 },
606 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
607 _bitfield_align_1: [],
608 _bitfield_1: __BindgenBitfieldUnit::new(
609 new_jsjitinfo_bitfield_1!(
610 JSJitInfo_OpType::Getter as u8,
611 JSJitInfo_AliasSet::AliasEverything as u8,
612 JSValueType::JSVAL_TYPE_DOUBLE as u8,
613 true,
614 false,
615 false,
616 false,
617 false,
618 false,
619 0,
620 ).to_ne_bytes()
621 ),
622});
623}
624unsafe extern "C" fn get_m22<D: DomTypes>
625(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
626 let mut result = false;
627 wrap_panic(&mut || result = (|| {
628 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
629 let this = &*(this as *const D::DOMMatrixReadOnly);
630 let result: f64 = this.M22();
631
632 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
633 return true;
634 })());
635 result
636}
637
638
639static m22_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
640
641pub(crate) fn init_m22_getterinfo<D: DomTypes>() {
642 m22_getterinfo.set(JSJitInfo {
643 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
644 getter: Some(get_m22::<D>)
645 },
646 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
647 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
648 },
649 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
650 _bitfield_align_1: [],
651 _bitfield_1: __BindgenBitfieldUnit::new(
652 new_jsjitinfo_bitfield_1!(
653 JSJitInfo_OpType::Getter as u8,
654 JSJitInfo_AliasSet::AliasEverything as u8,
655 JSValueType::JSVAL_TYPE_DOUBLE as u8,
656 true,
657 false,
658 false,
659 false,
660 false,
661 false,
662 0,
663 ).to_ne_bytes()
664 ),
665});
666}
667unsafe extern "C" fn get_m23<D: DomTypes>
668(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
669 let mut result = false;
670 wrap_panic(&mut || result = (|| {
671 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
672 let this = &*(this as *const D::DOMMatrixReadOnly);
673 let result: f64 = this.M23();
674
675 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
676 return true;
677 })());
678 result
679}
680
681
682static m23_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
683
684pub(crate) fn init_m23_getterinfo<D: DomTypes>() {
685 m23_getterinfo.set(JSJitInfo {
686 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
687 getter: Some(get_m23::<D>)
688 },
689 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
690 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
691 },
692 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
693 _bitfield_align_1: [],
694 _bitfield_1: __BindgenBitfieldUnit::new(
695 new_jsjitinfo_bitfield_1!(
696 JSJitInfo_OpType::Getter as u8,
697 JSJitInfo_AliasSet::AliasEverything as u8,
698 JSValueType::JSVAL_TYPE_DOUBLE as u8,
699 true,
700 false,
701 false,
702 false,
703 false,
704 false,
705 0,
706 ).to_ne_bytes()
707 ),
708});
709}
710unsafe extern "C" fn get_m24<D: DomTypes>
711(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
712 let mut result = false;
713 wrap_panic(&mut || result = (|| {
714 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
715 let this = &*(this as *const D::DOMMatrixReadOnly);
716 let result: f64 = this.M24();
717
718 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
719 return true;
720 })());
721 result
722}
723
724
725static m24_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
726
727pub(crate) fn init_m24_getterinfo<D: DomTypes>() {
728 m24_getterinfo.set(JSJitInfo {
729 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
730 getter: Some(get_m24::<D>)
731 },
732 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
733 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
734 },
735 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
736 _bitfield_align_1: [],
737 _bitfield_1: __BindgenBitfieldUnit::new(
738 new_jsjitinfo_bitfield_1!(
739 JSJitInfo_OpType::Getter as u8,
740 JSJitInfo_AliasSet::AliasEverything as u8,
741 JSValueType::JSVAL_TYPE_DOUBLE as u8,
742 true,
743 false,
744 false,
745 false,
746 false,
747 false,
748 0,
749 ).to_ne_bytes()
750 ),
751});
752}
753unsafe extern "C" fn get_m31<D: DomTypes>
754(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
755 let mut result = false;
756 wrap_panic(&mut || result = (|| {
757 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
758 let this = &*(this as *const D::DOMMatrixReadOnly);
759 let result: f64 = this.M31();
760
761 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
762 return true;
763 })());
764 result
765}
766
767
768static m31_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
769
770pub(crate) fn init_m31_getterinfo<D: DomTypes>() {
771 m31_getterinfo.set(JSJitInfo {
772 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
773 getter: Some(get_m31::<D>)
774 },
775 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
776 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
777 },
778 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
779 _bitfield_align_1: [],
780 _bitfield_1: __BindgenBitfieldUnit::new(
781 new_jsjitinfo_bitfield_1!(
782 JSJitInfo_OpType::Getter as u8,
783 JSJitInfo_AliasSet::AliasEverything as u8,
784 JSValueType::JSVAL_TYPE_DOUBLE as u8,
785 true,
786 false,
787 false,
788 false,
789 false,
790 false,
791 0,
792 ).to_ne_bytes()
793 ),
794});
795}
796unsafe extern "C" fn get_m32<D: DomTypes>
797(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
798 let mut result = false;
799 wrap_panic(&mut || result = (|| {
800 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
801 let this = &*(this as *const D::DOMMatrixReadOnly);
802 let result: f64 = this.M32();
803
804 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
805 return true;
806 })());
807 result
808}
809
810
811static m32_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
812
813pub(crate) fn init_m32_getterinfo<D: DomTypes>() {
814 m32_getterinfo.set(JSJitInfo {
815 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
816 getter: Some(get_m32::<D>)
817 },
818 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
819 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
820 },
821 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
822 _bitfield_align_1: [],
823 _bitfield_1: __BindgenBitfieldUnit::new(
824 new_jsjitinfo_bitfield_1!(
825 JSJitInfo_OpType::Getter as u8,
826 JSJitInfo_AliasSet::AliasEverything as u8,
827 JSValueType::JSVAL_TYPE_DOUBLE as u8,
828 true,
829 false,
830 false,
831 false,
832 false,
833 false,
834 0,
835 ).to_ne_bytes()
836 ),
837});
838}
839unsafe extern "C" fn get_m33<D: DomTypes>
840(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
841 let mut result = false;
842 wrap_panic(&mut || result = (|| {
843 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
844 let this = &*(this as *const D::DOMMatrixReadOnly);
845 let result: f64 = this.M33();
846
847 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
848 return true;
849 })());
850 result
851}
852
853
854static m33_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
855
856pub(crate) fn init_m33_getterinfo<D: DomTypes>() {
857 m33_getterinfo.set(JSJitInfo {
858 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
859 getter: Some(get_m33::<D>)
860 },
861 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
862 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
863 },
864 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
865 _bitfield_align_1: [],
866 _bitfield_1: __BindgenBitfieldUnit::new(
867 new_jsjitinfo_bitfield_1!(
868 JSJitInfo_OpType::Getter as u8,
869 JSJitInfo_AliasSet::AliasEverything as u8,
870 JSValueType::JSVAL_TYPE_DOUBLE as u8,
871 true,
872 false,
873 false,
874 false,
875 false,
876 false,
877 0,
878 ).to_ne_bytes()
879 ),
880});
881}
882unsafe extern "C" fn get_m34<D: DomTypes>
883(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
884 let mut result = false;
885 wrap_panic(&mut || result = (|| {
886 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
887 let this = &*(this as *const D::DOMMatrixReadOnly);
888 let result: f64 = this.M34();
889
890 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
891 return true;
892 })());
893 result
894}
895
896
897static m34_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
898
899pub(crate) fn init_m34_getterinfo<D: DomTypes>() {
900 m34_getterinfo.set(JSJitInfo {
901 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
902 getter: Some(get_m34::<D>)
903 },
904 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
905 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
906 },
907 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
908 _bitfield_align_1: [],
909 _bitfield_1: __BindgenBitfieldUnit::new(
910 new_jsjitinfo_bitfield_1!(
911 JSJitInfo_OpType::Getter as u8,
912 JSJitInfo_AliasSet::AliasEverything as u8,
913 JSValueType::JSVAL_TYPE_DOUBLE as u8,
914 true,
915 false,
916 false,
917 false,
918 false,
919 false,
920 0,
921 ).to_ne_bytes()
922 ),
923});
924}
925unsafe extern "C" fn get_m41<D: DomTypes>
926(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
927 let mut result = false;
928 wrap_panic(&mut || result = (|| {
929 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
930 let this = &*(this as *const D::DOMMatrixReadOnly);
931 let result: f64 = this.M41();
932
933 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
934 return true;
935 })());
936 result
937}
938
939
940static m41_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
941
942pub(crate) fn init_m41_getterinfo<D: DomTypes>() {
943 m41_getterinfo.set(JSJitInfo {
944 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
945 getter: Some(get_m41::<D>)
946 },
947 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
948 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
949 },
950 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
951 _bitfield_align_1: [],
952 _bitfield_1: __BindgenBitfieldUnit::new(
953 new_jsjitinfo_bitfield_1!(
954 JSJitInfo_OpType::Getter as u8,
955 JSJitInfo_AliasSet::AliasEverything as u8,
956 JSValueType::JSVAL_TYPE_DOUBLE as u8,
957 true,
958 false,
959 false,
960 false,
961 false,
962 false,
963 0,
964 ).to_ne_bytes()
965 ),
966});
967}
968unsafe extern "C" fn get_m42<D: DomTypes>
969(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
970 let mut result = false;
971 wrap_panic(&mut || result = (|| {
972 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
973 let this = &*(this as *const D::DOMMatrixReadOnly);
974 let result: f64 = this.M42();
975
976 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
977 return true;
978 })());
979 result
980}
981
982
983static m42_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
984
985pub(crate) fn init_m42_getterinfo<D: DomTypes>() {
986 m42_getterinfo.set(JSJitInfo {
987 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
988 getter: Some(get_m42::<D>)
989 },
990 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
991 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
992 },
993 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
994 _bitfield_align_1: [],
995 _bitfield_1: __BindgenBitfieldUnit::new(
996 new_jsjitinfo_bitfield_1!(
997 JSJitInfo_OpType::Getter as u8,
998 JSJitInfo_AliasSet::AliasEverything as u8,
999 JSValueType::JSVAL_TYPE_DOUBLE as u8,
1000 true,
1001 false,
1002 false,
1003 false,
1004 false,
1005 false,
1006 0,
1007 ).to_ne_bytes()
1008 ),
1009});
1010}
1011unsafe extern "C" fn get_m43<D: DomTypes>
1012(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1013 let mut result = false;
1014 wrap_panic(&mut || result = (|| {
1015 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1016 let this = &*(this as *const D::DOMMatrixReadOnly);
1017 let result: f64 = this.M43();
1018
1019 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1020 return true;
1021 })());
1022 result
1023}
1024
1025
1026static m43_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1027
1028pub(crate) fn init_m43_getterinfo<D: DomTypes>() {
1029 m43_getterinfo.set(JSJitInfo {
1030 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1031 getter: Some(get_m43::<D>)
1032 },
1033 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1034 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1035 },
1036 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1037 _bitfield_align_1: [],
1038 _bitfield_1: __BindgenBitfieldUnit::new(
1039 new_jsjitinfo_bitfield_1!(
1040 JSJitInfo_OpType::Getter as u8,
1041 JSJitInfo_AliasSet::AliasEverything as u8,
1042 JSValueType::JSVAL_TYPE_DOUBLE as u8,
1043 true,
1044 false,
1045 false,
1046 false,
1047 false,
1048 false,
1049 0,
1050 ).to_ne_bytes()
1051 ),
1052});
1053}
1054unsafe extern "C" fn get_m44<D: DomTypes>
1055(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1056 let mut result = false;
1057 wrap_panic(&mut || result = (|| {
1058 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1059 let this = &*(this as *const D::DOMMatrixReadOnly);
1060 let result: f64 = this.M44();
1061
1062 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1063 return true;
1064 })());
1065 result
1066}
1067
1068
1069static m44_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1070
1071pub(crate) fn init_m44_getterinfo<D: DomTypes>() {
1072 m44_getterinfo.set(JSJitInfo {
1073 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1074 getter: Some(get_m44::<D>)
1075 },
1076 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1077 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1078 },
1079 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1080 _bitfield_align_1: [],
1081 _bitfield_1: __BindgenBitfieldUnit::new(
1082 new_jsjitinfo_bitfield_1!(
1083 JSJitInfo_OpType::Getter as u8,
1084 JSJitInfo_AliasSet::AliasEverything as u8,
1085 JSValueType::JSVAL_TYPE_DOUBLE as u8,
1086 true,
1087 false,
1088 false,
1089 false,
1090 false,
1091 false,
1092 0,
1093 ).to_ne_bytes()
1094 ),
1095});
1096}
1097unsafe extern "C" fn get_is2D<D: DomTypes>
1098(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1099 let mut result = false;
1100 wrap_panic(&mut || result = (|| {
1101 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1102 let this = &*(this as *const D::DOMMatrixReadOnly);
1103 let result: bool = this.Is2D();
1104
1105 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1106 return true;
1107 })());
1108 result
1109}
1110
1111
1112static is2D_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1113
1114pub(crate) fn init_is2D_getterinfo<D: DomTypes>() {
1115 is2D_getterinfo.set(JSJitInfo {
1116 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1117 getter: Some(get_is2D::<D>)
1118 },
1119 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1120 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1121 },
1122 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1123 _bitfield_align_1: [],
1124 _bitfield_1: __BindgenBitfieldUnit::new(
1125 new_jsjitinfo_bitfield_1!(
1126 JSJitInfo_OpType::Getter as u8,
1127 JSJitInfo_AliasSet::AliasEverything as u8,
1128 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
1129 true,
1130 false,
1131 false,
1132 false,
1133 false,
1134 false,
1135 0,
1136 ).to_ne_bytes()
1137 ),
1138});
1139}
1140unsafe extern "C" fn get_isIdentity<D: DomTypes>
1141(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1142 let mut result = false;
1143 wrap_panic(&mut || result = (|| {
1144 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1145 let this = &*(this as *const D::DOMMatrixReadOnly);
1146 let result: bool = this.IsIdentity();
1147
1148 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1149 return true;
1150 })());
1151 result
1152}
1153
1154
1155static isIdentity_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1156
1157pub(crate) fn init_isIdentity_getterinfo<D: DomTypes>() {
1158 isIdentity_getterinfo.set(JSJitInfo {
1159 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1160 getter: Some(get_isIdentity::<D>)
1161 },
1162 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1163 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1164 },
1165 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1166 _bitfield_align_1: [],
1167 _bitfield_1: __BindgenBitfieldUnit::new(
1168 new_jsjitinfo_bitfield_1!(
1169 JSJitInfo_OpType::Getter as u8,
1170 JSJitInfo_AliasSet::AliasEverything as u8,
1171 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
1172 true,
1173 false,
1174 false,
1175 false,
1176 false,
1177 false,
1178 0,
1179 ).to_ne_bytes()
1180 ),
1181});
1182}
1183unsafe extern "C" fn translate<D: DomTypes>
1184(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1185 let mut result = false;
1186 wrap_panic(&mut || result = (|| {
1187 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1188 let this = &*(this as *const D::DOMMatrixReadOnly);
1189 let args = &*args;
1190 let argc = args.argc_;
1191 let arg0: f64 = if args.get(0).is_undefined() {
1192 0.0
1193 } else {
1194 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1195 Ok(ConversionResult::Success(value)) => value,
1196 Ok(ConversionResult::Failure(error)) => {
1197 throw_type_error(cx.raw_cx(), &error);
1198 return false;
1199
1200 }
1201 _ => {
1202 return false;
1203
1204 },
1205 }
1206
1207 };
1208 let arg1: f64 = if args.get(1).is_undefined() {
1209 0.0
1210 } else {
1211 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1212 Ok(ConversionResult::Success(value)) => value,
1213 Ok(ConversionResult::Failure(error)) => {
1214 throw_type_error(cx.raw_cx(), &error);
1215 return false;
1216
1217 }
1218 _ => {
1219 return false;
1220
1221 },
1222 }
1223
1224 };
1225 let arg2: f64 = if args.get(2).is_undefined() {
1226 0.0
1227 } else {
1228 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
1229 Ok(ConversionResult::Success(value)) => value,
1230 Ok(ConversionResult::Failure(error)) => {
1231 throw_type_error(cx.raw_cx(), &error);
1232 return false;
1233
1234 }
1235 _ => {
1236 return false;
1237
1238 },
1239 }
1240
1241 };
1242 let result: DomRoot<D::DOMMatrix> = this.Translate(arg0, arg1, arg2, CanGc::note());
1243
1244 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1245 return true;
1246 })());
1247 result
1248}
1249
1250
1251static translate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1252
1253pub(crate) fn init_translate_methodinfo<D: DomTypes>() {
1254 translate_methodinfo.set(JSJitInfo {
1255 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1256 method: Some(translate::<D>)
1257 },
1258 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1259 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1260 },
1261 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1262 _bitfield_align_1: [],
1263 _bitfield_1: __BindgenBitfieldUnit::new(
1264 new_jsjitinfo_bitfield_1!(
1265 JSJitInfo_OpType::Method as u8,
1266 JSJitInfo_AliasSet::AliasEverything as u8,
1267 JSValueType::JSVAL_TYPE_OBJECT as u8,
1268 false,
1269 false,
1270 false,
1271 false,
1272 false,
1273 false,
1274 0,
1275 ).to_ne_bytes()
1276 ),
1277});
1278}
1279unsafe extern "C" fn scale<D: DomTypes>
1280(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1281 let mut result = false;
1282 wrap_panic(&mut || result = (|| {
1283 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1284 let this = &*(this as *const D::DOMMatrixReadOnly);
1285 let args = &*args;
1286 let argc = args.argc_;
1287 let arg0: f64 = if args.get(0).is_undefined() {
1288 1.0
1289 } else {
1290 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1291 Ok(ConversionResult::Success(value)) => value,
1292 Ok(ConversionResult::Failure(error)) => {
1293 throw_type_error(cx.raw_cx(), &error);
1294 return false;
1295
1296 }
1297 _ => {
1298 return false;
1299
1300 },
1301 }
1302
1303 };
1304 let arg1: Option<f64> = if args.get(1).is_undefined() {
1305 None
1306 } else {
1307 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1308 Ok(ConversionResult::Success(value)) => value,
1309 Ok(ConversionResult::Failure(error)) => {
1310 throw_type_error(cx.raw_cx(), &error);
1311 return false;
1312
1313 }
1314 _ => {
1315 return false;
1316
1317 },
1318 }
1319 )
1320 };
1321 let arg2: f64 = if args.get(2).is_undefined() {
1322 1.0
1323 } else {
1324 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
1325 Ok(ConversionResult::Success(value)) => value,
1326 Ok(ConversionResult::Failure(error)) => {
1327 throw_type_error(cx.raw_cx(), &error);
1328 return false;
1329
1330 }
1331 _ => {
1332 return false;
1333
1334 },
1335 }
1336
1337 };
1338 let arg3: f64 = if args.get(3).is_undefined() {
1339 0.0
1340 } else {
1341 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
1342 Ok(ConversionResult::Success(value)) => value,
1343 Ok(ConversionResult::Failure(error)) => {
1344 throw_type_error(cx.raw_cx(), &error);
1345 return false;
1346
1347 }
1348 _ => {
1349 return false;
1350
1351 },
1352 }
1353
1354 };
1355 let arg4: f64 = if args.get(4).is_undefined() {
1356 0.0
1357 } else {
1358 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ()) {
1359 Ok(ConversionResult::Success(value)) => value,
1360 Ok(ConversionResult::Failure(error)) => {
1361 throw_type_error(cx.raw_cx(), &error);
1362 return false;
1363
1364 }
1365 _ => {
1366 return false;
1367
1368 },
1369 }
1370
1371 };
1372 let arg5: f64 = if args.get(5).is_undefined() {
1373 0.0
1374 } else {
1375 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ()) {
1376 Ok(ConversionResult::Success(value)) => value,
1377 Ok(ConversionResult::Failure(error)) => {
1378 throw_type_error(cx.raw_cx(), &error);
1379 return false;
1380
1381 }
1382 _ => {
1383 return false;
1384
1385 },
1386 }
1387
1388 };
1389 let result: DomRoot<D::DOMMatrix> = this.Scale(arg0, arg1, arg2, arg3, arg4, arg5, CanGc::note());
1390
1391 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1392 return true;
1393 })());
1394 result
1395}
1396
1397
1398static scale_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1399
1400pub(crate) fn init_scale_methodinfo<D: DomTypes>() {
1401 scale_methodinfo.set(JSJitInfo {
1402 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1403 method: Some(scale::<D>)
1404 },
1405 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1406 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1407 },
1408 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1409 _bitfield_align_1: [],
1410 _bitfield_1: __BindgenBitfieldUnit::new(
1411 new_jsjitinfo_bitfield_1!(
1412 JSJitInfo_OpType::Method as u8,
1413 JSJitInfo_AliasSet::AliasEverything as u8,
1414 JSValueType::JSVAL_TYPE_OBJECT as u8,
1415 false,
1416 false,
1417 false,
1418 false,
1419 false,
1420 false,
1421 0,
1422 ).to_ne_bytes()
1423 ),
1424});
1425}
1426unsafe extern "C" fn scaleNonUniform<D: DomTypes>
1427(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1428 let mut result = false;
1429 wrap_panic(&mut || result = (|| {
1430 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1431 let this = &*(this as *const D::DOMMatrixReadOnly);
1432 let args = &*args;
1433 let argc = args.argc_;
1434 let arg0: f64 = if args.get(0).is_undefined() {
1435 1.0
1436 } else {
1437 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1438 Ok(ConversionResult::Success(value)) => value,
1439 Ok(ConversionResult::Failure(error)) => {
1440 throw_type_error(cx.raw_cx(), &error);
1441 return false;
1442
1443 }
1444 _ => {
1445 return false;
1446
1447 },
1448 }
1449
1450 };
1451 let arg1: f64 = if args.get(1).is_undefined() {
1452 1.0
1453 } else {
1454 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1455 Ok(ConversionResult::Success(value)) => value,
1456 Ok(ConversionResult::Failure(error)) => {
1457 throw_type_error(cx.raw_cx(), &error);
1458 return false;
1459
1460 }
1461 _ => {
1462 return false;
1463
1464 },
1465 }
1466
1467 };
1468 let result: DomRoot<D::DOMMatrix> = this.ScaleNonUniform(arg0, arg1, CanGc::note());
1469
1470 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1471 return true;
1472 })());
1473 result
1474}
1475
1476
1477static scaleNonUniform_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1478
1479pub(crate) fn init_scaleNonUniform_methodinfo<D: DomTypes>() {
1480 scaleNonUniform_methodinfo.set(JSJitInfo {
1481 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1482 method: Some(scaleNonUniform::<D>)
1483 },
1484 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1485 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1486 },
1487 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1488 _bitfield_align_1: [],
1489 _bitfield_1: __BindgenBitfieldUnit::new(
1490 new_jsjitinfo_bitfield_1!(
1491 JSJitInfo_OpType::Method as u8,
1492 JSJitInfo_AliasSet::AliasEverything as u8,
1493 JSValueType::JSVAL_TYPE_OBJECT as u8,
1494 false,
1495 false,
1496 false,
1497 false,
1498 false,
1499 false,
1500 0,
1501 ).to_ne_bytes()
1502 ),
1503});
1504}
1505unsafe extern "C" fn scale3d<D: DomTypes>
1506(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1507 let mut result = false;
1508 wrap_panic(&mut || result = (|| {
1509 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1510 let this = &*(this as *const D::DOMMatrixReadOnly);
1511 let args = &*args;
1512 let argc = args.argc_;
1513 let arg0: f64 = if args.get(0).is_undefined() {
1514 1.0
1515 } else {
1516 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1517 Ok(ConversionResult::Success(value)) => value,
1518 Ok(ConversionResult::Failure(error)) => {
1519 throw_type_error(cx.raw_cx(), &error);
1520 return false;
1521
1522 }
1523 _ => {
1524 return false;
1525
1526 },
1527 }
1528
1529 };
1530 let arg1: f64 = if args.get(1).is_undefined() {
1531 0.0
1532 } else {
1533 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1534 Ok(ConversionResult::Success(value)) => value,
1535 Ok(ConversionResult::Failure(error)) => {
1536 throw_type_error(cx.raw_cx(), &error);
1537 return false;
1538
1539 }
1540 _ => {
1541 return false;
1542
1543 },
1544 }
1545
1546 };
1547 let arg2: f64 = if args.get(2).is_undefined() {
1548 0.0
1549 } else {
1550 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
1551 Ok(ConversionResult::Success(value)) => value,
1552 Ok(ConversionResult::Failure(error)) => {
1553 throw_type_error(cx.raw_cx(), &error);
1554 return false;
1555
1556 }
1557 _ => {
1558 return false;
1559
1560 },
1561 }
1562
1563 };
1564 let arg3: f64 = if args.get(3).is_undefined() {
1565 0.0
1566 } else {
1567 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
1568 Ok(ConversionResult::Success(value)) => value,
1569 Ok(ConversionResult::Failure(error)) => {
1570 throw_type_error(cx.raw_cx(), &error);
1571 return false;
1572
1573 }
1574 _ => {
1575 return false;
1576
1577 },
1578 }
1579
1580 };
1581 let result: DomRoot<D::DOMMatrix> = this.Scale3d(arg0, arg1, arg2, arg3, CanGc::note());
1582
1583 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1584 return true;
1585 })());
1586 result
1587}
1588
1589
1590static scale3d_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1591
1592pub(crate) fn init_scale3d_methodinfo<D: DomTypes>() {
1593 scale3d_methodinfo.set(JSJitInfo {
1594 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1595 method: Some(scale3d::<D>)
1596 },
1597 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1598 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1599 },
1600 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1601 _bitfield_align_1: [],
1602 _bitfield_1: __BindgenBitfieldUnit::new(
1603 new_jsjitinfo_bitfield_1!(
1604 JSJitInfo_OpType::Method as u8,
1605 JSJitInfo_AliasSet::AliasEverything as u8,
1606 JSValueType::JSVAL_TYPE_OBJECT as u8,
1607 false,
1608 false,
1609 false,
1610 false,
1611 false,
1612 false,
1613 0,
1614 ).to_ne_bytes()
1615 ),
1616});
1617}
1618unsafe extern "C" fn rotate<D: DomTypes>
1619(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1620 let mut result = false;
1621 wrap_panic(&mut || result = (|| {
1622 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1623 let this = &*(this as *const D::DOMMatrixReadOnly);
1624 let args = &*args;
1625 let argc = args.argc_;
1626 let arg0: f64 = if args.get(0).is_undefined() {
1627 0.0
1628 } else {
1629 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1630 Ok(ConversionResult::Success(value)) => value,
1631 Ok(ConversionResult::Failure(error)) => {
1632 throw_type_error(cx.raw_cx(), &error);
1633 return false;
1634
1635 }
1636 _ => {
1637 return false;
1638
1639 },
1640 }
1641
1642 };
1643 let arg1: Option<f64> = if args.get(1).is_undefined() {
1644 None
1645 } else {
1646 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1647 Ok(ConversionResult::Success(value)) => value,
1648 Ok(ConversionResult::Failure(error)) => {
1649 throw_type_error(cx.raw_cx(), &error);
1650 return false;
1651
1652 }
1653 _ => {
1654 return false;
1655
1656 },
1657 }
1658 )
1659 };
1660 let arg2: Option<f64> = if args.get(2).is_undefined() {
1661 None
1662 } else {
1663 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
1664 Ok(ConversionResult::Success(value)) => value,
1665 Ok(ConversionResult::Failure(error)) => {
1666 throw_type_error(cx.raw_cx(), &error);
1667 return false;
1668
1669 }
1670 _ => {
1671 return false;
1672
1673 },
1674 }
1675 )
1676 };
1677 let result: DomRoot<D::DOMMatrix> = this.Rotate(arg0, arg1, arg2, CanGc::note());
1678
1679 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1680 return true;
1681 })());
1682 result
1683}
1684
1685
1686static rotate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1687
1688pub(crate) fn init_rotate_methodinfo<D: DomTypes>() {
1689 rotate_methodinfo.set(JSJitInfo {
1690 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1691 method: Some(rotate::<D>)
1692 },
1693 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1694 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1695 },
1696 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1697 _bitfield_align_1: [],
1698 _bitfield_1: __BindgenBitfieldUnit::new(
1699 new_jsjitinfo_bitfield_1!(
1700 JSJitInfo_OpType::Method as u8,
1701 JSJitInfo_AliasSet::AliasEverything as u8,
1702 JSValueType::JSVAL_TYPE_OBJECT as u8,
1703 false,
1704 false,
1705 false,
1706 false,
1707 false,
1708 false,
1709 0,
1710 ).to_ne_bytes()
1711 ),
1712});
1713}
1714unsafe extern "C" fn rotateFromVector<D: DomTypes>
1715(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1716 let mut result = false;
1717 wrap_panic(&mut || result = (|| {
1718 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1719 let this = &*(this as *const D::DOMMatrixReadOnly);
1720 let args = &*args;
1721 let argc = args.argc_;
1722 let arg0: f64 = if args.get(0).is_undefined() {
1723 0.0
1724 } else {
1725 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1726 Ok(ConversionResult::Success(value)) => value,
1727 Ok(ConversionResult::Failure(error)) => {
1728 throw_type_error(cx.raw_cx(), &error);
1729 return false;
1730
1731 }
1732 _ => {
1733 return false;
1734
1735 },
1736 }
1737
1738 };
1739 let arg1: f64 = if args.get(1).is_undefined() {
1740 0.0
1741 } else {
1742 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1743 Ok(ConversionResult::Success(value)) => value,
1744 Ok(ConversionResult::Failure(error)) => {
1745 throw_type_error(cx.raw_cx(), &error);
1746 return false;
1747
1748 }
1749 _ => {
1750 return false;
1751
1752 },
1753 }
1754
1755 };
1756 let result: DomRoot<D::DOMMatrix> = this.RotateFromVector(arg0, arg1, CanGc::note());
1757
1758 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1759 return true;
1760 })());
1761 result
1762}
1763
1764
1765static rotateFromVector_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1766
1767pub(crate) fn init_rotateFromVector_methodinfo<D: DomTypes>() {
1768 rotateFromVector_methodinfo.set(JSJitInfo {
1769 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1770 method: Some(rotateFromVector::<D>)
1771 },
1772 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1773 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1774 },
1775 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1776 _bitfield_align_1: [],
1777 _bitfield_1: __BindgenBitfieldUnit::new(
1778 new_jsjitinfo_bitfield_1!(
1779 JSJitInfo_OpType::Method as u8,
1780 JSJitInfo_AliasSet::AliasEverything as u8,
1781 JSValueType::JSVAL_TYPE_OBJECT as u8,
1782 false,
1783 false,
1784 false,
1785 false,
1786 false,
1787 false,
1788 0,
1789 ).to_ne_bytes()
1790 ),
1791});
1792}
1793unsafe extern "C" fn rotateAxisAngle<D: DomTypes>
1794(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1795 let mut result = false;
1796 wrap_panic(&mut || result = (|| {
1797 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1798 let this = &*(this as *const D::DOMMatrixReadOnly);
1799 let args = &*args;
1800 let argc = args.argc_;
1801 let arg0: f64 = if args.get(0).is_undefined() {
1802 0.0
1803 } else {
1804 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1805 Ok(ConversionResult::Success(value)) => value,
1806 Ok(ConversionResult::Failure(error)) => {
1807 throw_type_error(cx.raw_cx(), &error);
1808 return false;
1809
1810 }
1811 _ => {
1812 return false;
1813
1814 },
1815 }
1816
1817 };
1818 let arg1: f64 = if args.get(1).is_undefined() {
1819 0.0
1820 } else {
1821 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1822 Ok(ConversionResult::Success(value)) => value,
1823 Ok(ConversionResult::Failure(error)) => {
1824 throw_type_error(cx.raw_cx(), &error);
1825 return false;
1826
1827 }
1828 _ => {
1829 return false;
1830
1831 },
1832 }
1833
1834 };
1835 let arg2: f64 = if args.get(2).is_undefined() {
1836 0.0
1837 } else {
1838 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
1839 Ok(ConversionResult::Success(value)) => value,
1840 Ok(ConversionResult::Failure(error)) => {
1841 throw_type_error(cx.raw_cx(), &error);
1842 return false;
1843
1844 }
1845 _ => {
1846 return false;
1847
1848 },
1849 }
1850
1851 };
1852 let arg3: f64 = if args.get(3).is_undefined() {
1853 0.0
1854 } else {
1855 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
1856 Ok(ConversionResult::Success(value)) => value,
1857 Ok(ConversionResult::Failure(error)) => {
1858 throw_type_error(cx.raw_cx(), &error);
1859 return false;
1860
1861 }
1862 _ => {
1863 return false;
1864
1865 },
1866 }
1867
1868 };
1869 let result: DomRoot<D::DOMMatrix> = this.RotateAxisAngle(arg0, arg1, arg2, arg3, CanGc::note());
1870
1871 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1872 return true;
1873 })());
1874 result
1875}
1876
1877
1878static rotateAxisAngle_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1879
1880pub(crate) fn init_rotateAxisAngle_methodinfo<D: DomTypes>() {
1881 rotateAxisAngle_methodinfo.set(JSJitInfo {
1882 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1883 method: Some(rotateAxisAngle::<D>)
1884 },
1885 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1886 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1887 },
1888 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1889 _bitfield_align_1: [],
1890 _bitfield_1: __BindgenBitfieldUnit::new(
1891 new_jsjitinfo_bitfield_1!(
1892 JSJitInfo_OpType::Method as u8,
1893 JSJitInfo_AliasSet::AliasEverything as u8,
1894 JSValueType::JSVAL_TYPE_OBJECT as u8,
1895 false,
1896 false,
1897 false,
1898 false,
1899 false,
1900 false,
1901 0,
1902 ).to_ne_bytes()
1903 ),
1904});
1905}
1906unsafe extern "C" fn skewX<D: DomTypes>
1907(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1908 let mut result = false;
1909 wrap_panic(&mut || result = (|| {
1910 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1911 let this = &*(this as *const D::DOMMatrixReadOnly);
1912 let args = &*args;
1913 let argc = args.argc_;
1914 let arg0: f64 = if args.get(0).is_undefined() {
1915 0.0
1916 } else {
1917 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1918 Ok(ConversionResult::Success(value)) => value,
1919 Ok(ConversionResult::Failure(error)) => {
1920 throw_type_error(cx.raw_cx(), &error);
1921 return false;
1922
1923 }
1924 _ => {
1925 return false;
1926
1927 },
1928 }
1929
1930 };
1931 let result: DomRoot<D::DOMMatrix> = this.SkewX(arg0, CanGc::note());
1932
1933 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1934 return true;
1935 })());
1936 result
1937}
1938
1939
1940static skewX_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1941
1942pub(crate) fn init_skewX_methodinfo<D: DomTypes>() {
1943 skewX_methodinfo.set(JSJitInfo {
1944 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1945 method: Some(skewX::<D>)
1946 },
1947 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1948 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
1949 },
1950 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1951 _bitfield_align_1: [],
1952 _bitfield_1: __BindgenBitfieldUnit::new(
1953 new_jsjitinfo_bitfield_1!(
1954 JSJitInfo_OpType::Method as u8,
1955 JSJitInfo_AliasSet::AliasEverything as u8,
1956 JSValueType::JSVAL_TYPE_OBJECT as u8,
1957 false,
1958 false,
1959 false,
1960 false,
1961 false,
1962 false,
1963 0,
1964 ).to_ne_bytes()
1965 ),
1966});
1967}
1968unsafe extern "C" fn skewY<D: DomTypes>
1969(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1970 let mut result = false;
1971 wrap_panic(&mut || result = (|| {
1972 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1973 let this = &*(this as *const D::DOMMatrixReadOnly);
1974 let args = &*args;
1975 let argc = args.argc_;
1976 let arg0: f64 = if args.get(0).is_undefined() {
1977 0.0
1978 } else {
1979 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1980 Ok(ConversionResult::Success(value)) => value,
1981 Ok(ConversionResult::Failure(error)) => {
1982 throw_type_error(cx.raw_cx(), &error);
1983 return false;
1984
1985 }
1986 _ => {
1987 return false;
1988
1989 },
1990 }
1991
1992 };
1993 let result: DomRoot<D::DOMMatrix> = this.SkewY(arg0, CanGc::note());
1994
1995 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1996 return true;
1997 })());
1998 result
1999}
2000
2001
2002static skewY_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2003
2004pub(crate) fn init_skewY_methodinfo<D: DomTypes>() {
2005 skewY_methodinfo.set(JSJitInfo {
2006 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2007 method: Some(skewY::<D>)
2008 },
2009 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2010 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2011 },
2012 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2013 _bitfield_align_1: [],
2014 _bitfield_1: __BindgenBitfieldUnit::new(
2015 new_jsjitinfo_bitfield_1!(
2016 JSJitInfo_OpType::Method as u8,
2017 JSJitInfo_AliasSet::AliasEverything as u8,
2018 JSValueType::JSVAL_TYPE_OBJECT as u8,
2019 false,
2020 false,
2021 false,
2022 false,
2023 false,
2024 false,
2025 0,
2026 ).to_ne_bytes()
2027 ),
2028});
2029}
2030unsafe extern "C" fn multiply<D: DomTypes>
2031(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2032 let mut result = false;
2033 wrap_panic(&mut || result = (|| {
2034 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2035 let this = &*(this as *const D::DOMMatrixReadOnly);
2036 let args = &*args;
2037 let argc = args.argc_;
2038 let arg0: crate::codegen::GenericBindings::DOMMatrixBinding::DOMMatrixInit = if args.get(0).is_undefined() {
2039 crate::codegen::GenericBindings::DOMMatrixBinding::DOMMatrixInit::empty()
2040 } else {
2041 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
2042 Ok(ConversionResult::Success(value)) => value,
2043 Ok(ConversionResult::Failure(error)) => {
2044 throw_type_error(cx.raw_cx(), &error);
2045 return false;
2046
2047 }
2048 _ => {
2049 return false;
2050
2051 },
2052 }
2053
2054 };
2055 let result: Result<DomRoot<D::DOMMatrix>, Error> = this.Multiply(&arg0, CanGc::note());
2056 let result = match result {
2057 Ok(result) => result,
2058 Err(e) => {
2059 <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());
2060 return false;
2061 },
2062 };
2063
2064 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2065 return true;
2066 })());
2067 result
2068}
2069
2070
2071static multiply_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2072
2073pub(crate) fn init_multiply_methodinfo<D: DomTypes>() {
2074 multiply_methodinfo.set(JSJitInfo {
2075 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2076 method: Some(multiply::<D>)
2077 },
2078 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2079 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2080 },
2081 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2082 _bitfield_align_1: [],
2083 _bitfield_1: __BindgenBitfieldUnit::new(
2084 new_jsjitinfo_bitfield_1!(
2085 JSJitInfo_OpType::Method as u8,
2086 JSJitInfo_AliasSet::AliasEverything as u8,
2087 JSValueType::JSVAL_TYPE_OBJECT as u8,
2088 false,
2089 false,
2090 false,
2091 false,
2092 false,
2093 false,
2094 0,
2095 ).to_ne_bytes()
2096 ),
2097});
2098}
2099unsafe extern "C" fn flipX<D: DomTypes>
2100(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2101 let mut result = false;
2102 wrap_panic(&mut || result = (|| {
2103 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2104 let this = &*(this as *const D::DOMMatrixReadOnly);
2105 let args = &*args;
2106 let argc = args.argc_;
2107 let result: DomRoot<D::DOMMatrix> = this.FlipX(CanGc::note());
2108
2109 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2110 return true;
2111 })());
2112 result
2113}
2114
2115
2116static flipX_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2117
2118pub(crate) fn init_flipX_methodinfo<D: DomTypes>() {
2119 flipX_methodinfo.set(JSJitInfo {
2120 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2121 method: Some(flipX::<D>)
2122 },
2123 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2124 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2125 },
2126 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2127 _bitfield_align_1: [],
2128 _bitfield_1: __BindgenBitfieldUnit::new(
2129 new_jsjitinfo_bitfield_1!(
2130 JSJitInfo_OpType::Method as u8,
2131 JSJitInfo_AliasSet::AliasEverything as u8,
2132 JSValueType::JSVAL_TYPE_OBJECT as u8,
2133 true,
2134 false,
2135 false,
2136 false,
2137 false,
2138 false,
2139 0,
2140 ).to_ne_bytes()
2141 ),
2142});
2143}
2144unsafe extern "C" fn flipY<D: DomTypes>
2145(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2146 let mut result = false;
2147 wrap_panic(&mut || result = (|| {
2148 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2149 let this = &*(this as *const D::DOMMatrixReadOnly);
2150 let args = &*args;
2151 let argc = args.argc_;
2152 let result: DomRoot<D::DOMMatrix> = this.FlipY(CanGc::note());
2153
2154 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2155 return true;
2156 })());
2157 result
2158}
2159
2160
2161static flipY_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2162
2163pub(crate) fn init_flipY_methodinfo<D: DomTypes>() {
2164 flipY_methodinfo.set(JSJitInfo {
2165 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2166 method: Some(flipY::<D>)
2167 },
2168 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2169 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2170 },
2171 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2172 _bitfield_align_1: [],
2173 _bitfield_1: __BindgenBitfieldUnit::new(
2174 new_jsjitinfo_bitfield_1!(
2175 JSJitInfo_OpType::Method as u8,
2176 JSJitInfo_AliasSet::AliasEverything as u8,
2177 JSValueType::JSVAL_TYPE_OBJECT as u8,
2178 true,
2179 false,
2180 false,
2181 false,
2182 false,
2183 false,
2184 0,
2185 ).to_ne_bytes()
2186 ),
2187});
2188}
2189unsafe extern "C" fn inverse<D: DomTypes>
2190(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2191 let mut result = false;
2192 wrap_panic(&mut || result = (|| {
2193 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2194 let this = &*(this as *const D::DOMMatrixReadOnly);
2195 let args = &*args;
2196 let argc = args.argc_;
2197 let result: DomRoot<D::DOMMatrix> = this.Inverse(CanGc::note());
2198
2199 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2200 return true;
2201 })());
2202 result
2203}
2204
2205
2206static inverse_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2207
2208pub(crate) fn init_inverse_methodinfo<D: DomTypes>() {
2209 inverse_methodinfo.set(JSJitInfo {
2210 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2211 method: Some(inverse::<D>)
2212 },
2213 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2214 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2215 },
2216 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2217 _bitfield_align_1: [],
2218 _bitfield_1: __BindgenBitfieldUnit::new(
2219 new_jsjitinfo_bitfield_1!(
2220 JSJitInfo_OpType::Method as u8,
2221 JSJitInfo_AliasSet::AliasEverything as u8,
2222 JSValueType::JSVAL_TYPE_OBJECT as u8,
2223 true,
2224 false,
2225 false,
2226 false,
2227 false,
2228 false,
2229 0,
2230 ).to_ne_bytes()
2231 ),
2232});
2233}
2234unsafe extern "C" fn transformPoint<D: DomTypes>
2235(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2236 let mut result = false;
2237 wrap_panic(&mut || result = (|| {
2238 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2239 let this = &*(this as *const D::DOMMatrixReadOnly);
2240 let args = &*args;
2241 let argc = args.argc_;
2242 let arg0: crate::codegen::GenericBindings::DOMPointBinding::DOMPointInit = if args.get(0).is_undefined() {
2243 crate::codegen::GenericBindings::DOMPointBinding::DOMPointInit::empty()
2244 } else {
2245 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
2246 Ok(ConversionResult::Success(value)) => value,
2247 Ok(ConversionResult::Failure(error)) => {
2248 throw_type_error(cx.raw_cx(), &error);
2249 return false;
2250
2251 }
2252 _ => {
2253 return false;
2254
2255 },
2256 }
2257
2258 };
2259 let result: DomRoot<D::DOMPoint> = this.TransformPoint(&arg0, CanGc::note());
2260
2261 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2262 return true;
2263 })());
2264 result
2265}
2266
2267
2268static transformPoint_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2269
2270pub(crate) fn init_transformPoint_methodinfo<D: DomTypes>() {
2271 transformPoint_methodinfo.set(JSJitInfo {
2272 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2273 method: Some(transformPoint::<D>)
2274 },
2275 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2276 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2277 },
2278 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2279 _bitfield_align_1: [],
2280 _bitfield_1: __BindgenBitfieldUnit::new(
2281 new_jsjitinfo_bitfield_1!(
2282 JSJitInfo_OpType::Method as u8,
2283 JSJitInfo_AliasSet::AliasEverything as u8,
2284 JSValueType::JSVAL_TYPE_OBJECT as u8,
2285 false,
2286 false,
2287 false,
2288 false,
2289 false,
2290 false,
2291 0,
2292 ).to_ne_bytes()
2293 ),
2294});
2295}
2296unsafe extern "C" fn toFloat32Array<D: DomTypes>
2297(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2298 let mut result = false;
2299 wrap_panic(&mut || result = (|| {
2300 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2301 let this = &*(this as *const D::DOMMatrixReadOnly);
2302 let args = &*args;
2303 let argc = args.argc_;
2304 let result: Float32Array = this.ToFloat32Array(SafeJSContext::from_ptr(cx.raw_cx()), CanGc::note());
2305
2306 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2307 return true;
2308 })());
2309 result
2310}
2311
2312
2313static toFloat32Array_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2314
2315pub(crate) fn init_toFloat32Array_methodinfo<D: DomTypes>() {
2316 toFloat32Array_methodinfo.set(JSJitInfo {
2317 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2318 method: Some(toFloat32Array::<D>)
2319 },
2320 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2321 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2322 },
2323 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2324 _bitfield_align_1: [],
2325 _bitfield_1: __BindgenBitfieldUnit::new(
2326 new_jsjitinfo_bitfield_1!(
2327 JSJitInfo_OpType::Method as u8,
2328 JSJitInfo_AliasSet::AliasEverything as u8,
2329 JSValueType::JSVAL_TYPE_OBJECT as u8,
2330 true,
2331 false,
2332 false,
2333 false,
2334 false,
2335 false,
2336 0,
2337 ).to_ne_bytes()
2338 ),
2339});
2340}
2341unsafe extern "C" fn toFloat64Array<D: DomTypes>
2342(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2343 let mut result = false;
2344 wrap_panic(&mut || result = (|| {
2345 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2346 let this = &*(this as *const D::DOMMatrixReadOnly);
2347 let args = &*args;
2348 let argc = args.argc_;
2349 let result: Float64Array = this.ToFloat64Array(SafeJSContext::from_ptr(cx.raw_cx()), CanGc::note());
2350
2351 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2352 return true;
2353 })());
2354 result
2355}
2356
2357
2358static toFloat64Array_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2359
2360pub(crate) fn init_toFloat64Array_methodinfo<D: DomTypes>() {
2361 toFloat64Array_methodinfo.set(JSJitInfo {
2362 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2363 method: Some(toFloat64Array::<D>)
2364 },
2365 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2366 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2367 },
2368 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2369 _bitfield_align_1: [],
2370 _bitfield_1: __BindgenBitfieldUnit::new(
2371 new_jsjitinfo_bitfield_1!(
2372 JSJitInfo_OpType::Method as u8,
2373 JSJitInfo_AliasSet::AliasEverything as u8,
2374 JSValueType::JSVAL_TYPE_OBJECT as u8,
2375 true,
2376 false,
2377 false,
2378 false,
2379 false,
2380 false,
2381 0,
2382 ).to_ne_bytes()
2383 ),
2384});
2385}
2386unsafe extern "C" fn __stringifier<D: DomTypes>
2387(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2388 let mut result = false;
2389 wrap_panic(&mut || result = (|| {
2390 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2391 let this = &*(this as *const D::DOMMatrixReadOnly);
2392 let args = &*args;
2393 let argc = args.argc_;
2394 let result: Result<DOMString, Error> = this.Stringifier();
2395 let result = match result {
2396 Ok(result) => result,
2397 Err(e) => {
2398 <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());
2399 return false;
2400 },
2401 };
2402
2403 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2404 return true;
2405 })());
2406 result
2407}
2408
2409
2410static __stringifier_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2411
2412pub(crate) fn init___stringifier_methodinfo<D: DomTypes>() {
2413 __stringifier_methodinfo.set(JSJitInfo {
2414 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2415 method: Some(__stringifier::<D>)
2416 },
2417 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2418 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2419 },
2420 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2421 _bitfield_align_1: [],
2422 _bitfield_1: __BindgenBitfieldUnit::new(
2423 new_jsjitinfo_bitfield_1!(
2424 JSJitInfo_OpType::Method as u8,
2425 JSJitInfo_AliasSet::AliasEverything as u8,
2426 JSValueType::JSVAL_TYPE_STRING as u8,
2427 false,
2428 false,
2429 false,
2430 false,
2431 false,
2432 false,
2433 0,
2434 ).to_ne_bytes()
2435 ),
2436});
2437}
2438unsafe extern "C" fn toJSON<D: DomTypes>
2439(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2440 let mut result = false;
2441 wrap_panic(&mut || result = (|| {
2442 use crate::inheritance::HasParent;
2443 rooted!(in(cx) let result = JS_NewPlainObject(cx));
2444 if result.is_null() {
2445 return false;
2446 }
2447 if !CollectJSONAttributes::<D>(cx, _obj, this, result.handle()) {
2448 return false;
2449 }
2450 (*args).rval().set(ObjectValue(*result));
2451 true
2452
2453 })());
2454 result
2455}
2456
2457
2458static toJSON_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2459
2460pub(crate) fn init_toJSON_methodinfo<D: DomTypes>() {
2461 toJSON_methodinfo.set(JSJitInfo {
2462 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2463 method: Some(toJSON::<D>)
2464 },
2465 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2466 protoID: PrototypeList::ID::DOMMatrixReadOnly as u16,
2467 },
2468 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2469 _bitfield_align_1: [],
2470 _bitfield_1: __BindgenBitfieldUnit::new(
2471 new_jsjitinfo_bitfield_1!(
2472 JSJitInfo_OpType::Method as u8,
2473 JSJitInfo_AliasSet::AliasEverything as u8,
2474 JSValueType::JSVAL_TYPE_OBJECT as u8,
2475 true,
2476 false,
2477 false,
2478 false,
2479 false,
2480 false,
2481 0,
2482 ).to_ne_bytes()
2483 ),
2484});
2485}
2486unsafe extern "C" fn _finalize<D: DomTypes>
2487(_cx: *mut GCContext, obj: *mut JSObject){
2488 wrap_panic(&mut || {
2489
2490 let this = native_from_object_static::<D::DOMMatrixReadOnly>(obj).unwrap();
2491 finalize_common(this);
2492 })
2493}
2494
2495unsafe extern "C" fn _trace<D: DomTypes>
2496(trc: *mut JSTracer, obj: *mut JSObject){
2497 wrap_panic(&mut || {
2498
2499 let this = native_from_object_static::<D::DOMMatrixReadOnly>(obj).unwrap();
2500 if this.is_null() { return; } (*this).trace(trc);
2502 })
2503}
2504
2505pub unsafe fn CollectJSONAttributes<D: DomTypes>
2506(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, result: HandleObject) -> bool{
2507 let incumbent_global = D::GlobalScope::incumbent().expect("no incumbent global");
2508 let global = incumbent_global.reflector().get_jsobject();
2509 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2510 let is_satisfied = conditions.iter().any(|c|
2511 c.is_satisfied::<D>(
2512 SafeJSContext::from_ptr(cx),
2513 HandleObject::from_raw(obj),
2514 global));
2515 if is_satisfied {
2516 rooted!(in(cx) let mut temp = UndefinedValue());
2517 if !get_a::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2518 return false;
2519 }
2520 if !JS_DefineProperty(cx, result,
2521 c"a".as_ptr(),
2522 temp.handle(), JSPROP_ENUMERATE as u32) {
2523 return false;
2524 }
2525 }
2526 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2527 let is_satisfied = conditions.iter().any(|c|
2528 c.is_satisfied::<D>(
2529 SafeJSContext::from_ptr(cx),
2530 HandleObject::from_raw(obj),
2531 global));
2532 if is_satisfied {
2533 rooted!(in(cx) let mut temp = UndefinedValue());
2534 if !get_b::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2535 return false;
2536 }
2537 if !JS_DefineProperty(cx, result,
2538 c"b".as_ptr(),
2539 temp.handle(), JSPROP_ENUMERATE as u32) {
2540 return false;
2541 }
2542 }
2543 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2544 let is_satisfied = conditions.iter().any(|c|
2545 c.is_satisfied::<D>(
2546 SafeJSContext::from_ptr(cx),
2547 HandleObject::from_raw(obj),
2548 global));
2549 if is_satisfied {
2550 rooted!(in(cx) let mut temp = UndefinedValue());
2551 if !get_c::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2552 return false;
2553 }
2554 if !JS_DefineProperty(cx, result,
2555 c"c".as_ptr(),
2556 temp.handle(), JSPROP_ENUMERATE as u32) {
2557 return false;
2558 }
2559 }
2560 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2561 let is_satisfied = conditions.iter().any(|c|
2562 c.is_satisfied::<D>(
2563 SafeJSContext::from_ptr(cx),
2564 HandleObject::from_raw(obj),
2565 global));
2566 if is_satisfied {
2567 rooted!(in(cx) let mut temp = UndefinedValue());
2568 if !get_d::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2569 return false;
2570 }
2571 if !JS_DefineProperty(cx, result,
2572 c"d".as_ptr(),
2573 temp.handle(), JSPROP_ENUMERATE as u32) {
2574 return false;
2575 }
2576 }
2577 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2578 let is_satisfied = conditions.iter().any(|c|
2579 c.is_satisfied::<D>(
2580 SafeJSContext::from_ptr(cx),
2581 HandleObject::from_raw(obj),
2582 global));
2583 if is_satisfied {
2584 rooted!(in(cx) let mut temp = UndefinedValue());
2585 if !get_e::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2586 return false;
2587 }
2588 if !JS_DefineProperty(cx, result,
2589 c"e".as_ptr(),
2590 temp.handle(), JSPROP_ENUMERATE as u32) {
2591 return false;
2592 }
2593 }
2594 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2595 let is_satisfied = conditions.iter().any(|c|
2596 c.is_satisfied::<D>(
2597 SafeJSContext::from_ptr(cx),
2598 HandleObject::from_raw(obj),
2599 global));
2600 if is_satisfied {
2601 rooted!(in(cx) let mut temp = UndefinedValue());
2602 if !get_f::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2603 return false;
2604 }
2605 if !JS_DefineProperty(cx, result,
2606 c"f".as_ptr(),
2607 temp.handle(), JSPROP_ENUMERATE as u32) {
2608 return false;
2609 }
2610 }
2611 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2612 let is_satisfied = conditions.iter().any(|c|
2613 c.is_satisfied::<D>(
2614 SafeJSContext::from_ptr(cx),
2615 HandleObject::from_raw(obj),
2616 global));
2617 if is_satisfied {
2618 rooted!(in(cx) let mut temp = UndefinedValue());
2619 if !get_m11::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2620 return false;
2621 }
2622 if !JS_DefineProperty(cx, result,
2623 c"m11".as_ptr(),
2624 temp.handle(), JSPROP_ENUMERATE as u32) {
2625 return false;
2626 }
2627 }
2628 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2629 let is_satisfied = conditions.iter().any(|c|
2630 c.is_satisfied::<D>(
2631 SafeJSContext::from_ptr(cx),
2632 HandleObject::from_raw(obj),
2633 global));
2634 if is_satisfied {
2635 rooted!(in(cx) let mut temp = UndefinedValue());
2636 if !get_m12::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2637 return false;
2638 }
2639 if !JS_DefineProperty(cx, result,
2640 c"m12".as_ptr(),
2641 temp.handle(), JSPROP_ENUMERATE as u32) {
2642 return false;
2643 }
2644 }
2645 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2646 let is_satisfied = conditions.iter().any(|c|
2647 c.is_satisfied::<D>(
2648 SafeJSContext::from_ptr(cx),
2649 HandleObject::from_raw(obj),
2650 global));
2651 if is_satisfied {
2652 rooted!(in(cx) let mut temp = UndefinedValue());
2653 if !get_m13::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2654 return false;
2655 }
2656 if !JS_DefineProperty(cx, result,
2657 c"m13".as_ptr(),
2658 temp.handle(), JSPROP_ENUMERATE as u32) {
2659 return false;
2660 }
2661 }
2662 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2663 let is_satisfied = conditions.iter().any(|c|
2664 c.is_satisfied::<D>(
2665 SafeJSContext::from_ptr(cx),
2666 HandleObject::from_raw(obj),
2667 global));
2668 if is_satisfied {
2669 rooted!(in(cx) let mut temp = UndefinedValue());
2670 if !get_m14::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2671 return false;
2672 }
2673 if !JS_DefineProperty(cx, result,
2674 c"m14".as_ptr(),
2675 temp.handle(), JSPROP_ENUMERATE as u32) {
2676 return false;
2677 }
2678 }
2679 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2680 let is_satisfied = conditions.iter().any(|c|
2681 c.is_satisfied::<D>(
2682 SafeJSContext::from_ptr(cx),
2683 HandleObject::from_raw(obj),
2684 global));
2685 if is_satisfied {
2686 rooted!(in(cx) let mut temp = UndefinedValue());
2687 if !get_m21::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2688 return false;
2689 }
2690 if !JS_DefineProperty(cx, result,
2691 c"m21".as_ptr(),
2692 temp.handle(), JSPROP_ENUMERATE as u32) {
2693 return false;
2694 }
2695 }
2696 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2697 let is_satisfied = conditions.iter().any(|c|
2698 c.is_satisfied::<D>(
2699 SafeJSContext::from_ptr(cx),
2700 HandleObject::from_raw(obj),
2701 global));
2702 if is_satisfied {
2703 rooted!(in(cx) let mut temp = UndefinedValue());
2704 if !get_m22::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2705 return false;
2706 }
2707 if !JS_DefineProperty(cx, result,
2708 c"m22".as_ptr(),
2709 temp.handle(), JSPROP_ENUMERATE as u32) {
2710 return false;
2711 }
2712 }
2713 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2714 let is_satisfied = conditions.iter().any(|c|
2715 c.is_satisfied::<D>(
2716 SafeJSContext::from_ptr(cx),
2717 HandleObject::from_raw(obj),
2718 global));
2719 if is_satisfied {
2720 rooted!(in(cx) let mut temp = UndefinedValue());
2721 if !get_m23::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2722 return false;
2723 }
2724 if !JS_DefineProperty(cx, result,
2725 c"m23".as_ptr(),
2726 temp.handle(), JSPROP_ENUMERATE as u32) {
2727 return false;
2728 }
2729 }
2730 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2731 let is_satisfied = conditions.iter().any(|c|
2732 c.is_satisfied::<D>(
2733 SafeJSContext::from_ptr(cx),
2734 HandleObject::from_raw(obj),
2735 global));
2736 if is_satisfied {
2737 rooted!(in(cx) let mut temp = UndefinedValue());
2738 if !get_m24::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2739 return false;
2740 }
2741 if !JS_DefineProperty(cx, result,
2742 c"m24".as_ptr(),
2743 temp.handle(), JSPROP_ENUMERATE as u32) {
2744 return false;
2745 }
2746 }
2747 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2748 let is_satisfied = conditions.iter().any(|c|
2749 c.is_satisfied::<D>(
2750 SafeJSContext::from_ptr(cx),
2751 HandleObject::from_raw(obj),
2752 global));
2753 if is_satisfied {
2754 rooted!(in(cx) let mut temp = UndefinedValue());
2755 if !get_m31::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2756 return false;
2757 }
2758 if !JS_DefineProperty(cx, result,
2759 c"m31".as_ptr(),
2760 temp.handle(), JSPROP_ENUMERATE as u32) {
2761 return false;
2762 }
2763 }
2764 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2765 let is_satisfied = conditions.iter().any(|c|
2766 c.is_satisfied::<D>(
2767 SafeJSContext::from_ptr(cx),
2768 HandleObject::from_raw(obj),
2769 global));
2770 if is_satisfied {
2771 rooted!(in(cx) let mut temp = UndefinedValue());
2772 if !get_m32::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2773 return false;
2774 }
2775 if !JS_DefineProperty(cx, result,
2776 c"m32".as_ptr(),
2777 temp.handle(), JSPROP_ENUMERATE as u32) {
2778 return false;
2779 }
2780 }
2781 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2782 let is_satisfied = conditions.iter().any(|c|
2783 c.is_satisfied::<D>(
2784 SafeJSContext::from_ptr(cx),
2785 HandleObject::from_raw(obj),
2786 global));
2787 if is_satisfied {
2788 rooted!(in(cx) let mut temp = UndefinedValue());
2789 if !get_m33::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2790 return false;
2791 }
2792 if !JS_DefineProperty(cx, result,
2793 c"m33".as_ptr(),
2794 temp.handle(), JSPROP_ENUMERATE as u32) {
2795 return false;
2796 }
2797 }
2798 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2799 let is_satisfied = conditions.iter().any(|c|
2800 c.is_satisfied::<D>(
2801 SafeJSContext::from_ptr(cx),
2802 HandleObject::from_raw(obj),
2803 global));
2804 if is_satisfied {
2805 rooted!(in(cx) let mut temp = UndefinedValue());
2806 if !get_m34::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2807 return false;
2808 }
2809 if !JS_DefineProperty(cx, result,
2810 c"m34".as_ptr(),
2811 temp.handle(), JSPROP_ENUMERATE as u32) {
2812 return false;
2813 }
2814 }
2815 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2816 let is_satisfied = conditions.iter().any(|c|
2817 c.is_satisfied::<D>(
2818 SafeJSContext::from_ptr(cx),
2819 HandleObject::from_raw(obj),
2820 global));
2821 if is_satisfied {
2822 rooted!(in(cx) let mut temp = UndefinedValue());
2823 if !get_m41::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2824 return false;
2825 }
2826 if !JS_DefineProperty(cx, result,
2827 c"m41".as_ptr(),
2828 temp.handle(), JSPROP_ENUMERATE as u32) {
2829 return false;
2830 }
2831 }
2832 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2833 let is_satisfied = conditions.iter().any(|c|
2834 c.is_satisfied::<D>(
2835 SafeJSContext::from_ptr(cx),
2836 HandleObject::from_raw(obj),
2837 global));
2838 if is_satisfied {
2839 rooted!(in(cx) let mut temp = UndefinedValue());
2840 if !get_m42::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2841 return false;
2842 }
2843 if !JS_DefineProperty(cx, result,
2844 c"m42".as_ptr(),
2845 temp.handle(), JSPROP_ENUMERATE as u32) {
2846 return false;
2847 }
2848 }
2849 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2850 let is_satisfied = conditions.iter().any(|c|
2851 c.is_satisfied::<D>(
2852 SafeJSContext::from_ptr(cx),
2853 HandleObject::from_raw(obj),
2854 global));
2855 if is_satisfied {
2856 rooted!(in(cx) let mut temp = UndefinedValue());
2857 if !get_m43::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2858 return false;
2859 }
2860 if !JS_DefineProperty(cx, result,
2861 c"m43".as_ptr(),
2862 temp.handle(), JSPROP_ENUMERATE as u32) {
2863 return false;
2864 }
2865 }
2866 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2867 let is_satisfied = conditions.iter().any(|c|
2868 c.is_satisfied::<D>(
2869 SafeJSContext::from_ptr(cx),
2870 HandleObject::from_raw(obj),
2871 global));
2872 if is_satisfied {
2873 rooted!(in(cx) let mut temp = UndefinedValue());
2874 if !get_m44::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2875 return false;
2876 }
2877 if !JS_DefineProperty(cx, result,
2878 c"m44".as_ptr(),
2879 temp.handle(), JSPROP_ENUMERATE as u32) {
2880 return false;
2881 }
2882 }
2883 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2884 let is_satisfied = conditions.iter().any(|c|
2885 c.is_satisfied::<D>(
2886 SafeJSContext::from_ptr(cx),
2887 HandleObject::from_raw(obj),
2888 global));
2889 if is_satisfied {
2890 rooted!(in(cx) let mut temp = UndefinedValue());
2891 if !get_is2D::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2892 return false;
2893 }
2894 if !JS_DefineProperty(cx, result,
2895 c"is2D".as_ptr(),
2896 temp.handle(), JSPROP_ENUMERATE as u32) {
2897 return false;
2898 }
2899 }
2900 let conditions = &[Condition::Exposed(Globals::WINDOW), Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE), Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE), Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)];
2901 let is_satisfied = conditions.iter().any(|c|
2902 c.is_satisfied::<D>(
2903 SafeJSContext::from_ptr(cx),
2904 HandleObject::from_raw(obj),
2905 global));
2906 if is_satisfied {
2907 rooted!(in(cx) let mut temp = UndefinedValue());
2908 if !get_isIdentity::<D>(cx, obj, this, JSJitGetterCallArgs { _base: temp.handle_mut().into() }) {
2909 return false;
2910 }
2911 if !JS_DefineProperty(cx, result,
2912 c"isIdentity".as_ptr(),
2913 temp.handle(), JSPROP_ENUMERATE as u32) {
2914 return false;
2915 }
2916 }
2917 true
2918
2919}
2920
2921
2922static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();
2923
2924pub(crate) fn init_class_ops<D: DomTypes>() {
2925 CLASS_OPS.set(JSClassOps {
2926 addProperty: None,
2927 delProperty: None,
2928 enumerate: None,
2929 newEnumerate: None,
2930 resolve: None,
2931 mayResolve: None,
2932 finalize: Some(_finalize::<D>),
2933 call: None,
2934 construct: None,
2935 trace: Some(_trace::<D>),
2936 });
2937}
2938
2939pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();
2940
2941pub(crate) fn init_domjs_class<D: DomTypes>() {
2942 init_class_ops::<D>();
2943 Class.set(DOMJSClass {
2944 base: JSClass {
2945 name: c"DOMMatrixReadOnly".as_ptr(),
2946 flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
2947 (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
2948 ,
2949 cOps: unsafe { CLASS_OPS.get() },
2950 spec: ptr::null(),
2951 ext: ptr::null(),
2952 oOps: ptr::null(),
2953 },
2954 dom_class:
2955DOMClass {
2956 interface_chain: [ PrototypeList::ID::DOMMatrixReadOnly, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
2957 depth: 0,
2958 type_id: crate::codegen::InheritTypes::TopTypeId { dommatrixreadonly: (crate::codegen::InheritTypes::DOMMatrixReadOnlyTypeId::DOMMatrixReadOnly) },
2959 malloc_size_of: malloc_size_of_including_raw_self::<D::DOMMatrixReadOnly> as unsafe fn(&mut _, _) -> _,
2960 global: Globals::EMPTY,
2961},
2962 });
2963}
2964
2965#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
2966(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::DOMMatrixReadOnly>, _can_gc: CanGc) -> DomRoot<D::DOMMatrixReadOnly>{
2967
2968 let raw = Root::new(MaybeUnreflectedDom::from_box(object));
2969
2970 let scope = scope.reflector().get_jsobject();
2971 assert!(!scope.get().is_null());
2972 assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
2973 let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());
2974
2975 rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
2976 GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
2977 assert!(!canonical_proto.is_null());
2978
2979
2980 rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
2981 if let Some(given) = given_proto {
2982 proto.set(*given);
2983 if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
2984 assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
2985 }
2986 } else {
2987 proto.set(*canonical_proto);
2988 }
2989 rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
2990 cx.raw_cx(),
2991 &Class.get().base,
2992 proto.handle(),
2993 ));
2994 assert!(!obj.is_null());
2995 JS_SetReservedSlot(
2996 obj.get(),
2997 DOM_OBJECT_SLOT,
2998 &PrivateValue(raw.as_ptr() as *const libc::c_void),
2999 );
3000
3001 let root = raw.reflect_with(obj.get());
3002
3003
3004
3005 DomRoot::from_ref(&*root)
3006}
3007
3008pub trait DOMMatrixReadOnlyMethods<D: DomTypes> {
3009 fn FromMatrix(r#global: &D::GlobalScope, r#other: &crate::codegen::GenericBindings::DOMMatrixBinding::DOMMatrixInit, r#_can_gc: CanGc) -> Fallible<DomRoot<D::DOMMatrixReadOnly>>;
3010 fn FromFloat32Array(r#global: &D::GlobalScope, r#array32: CustomAutoRooterGuard<typedarray::Float32Array>, r#_can_gc: CanGc) -> Fallible<DomRoot<D::DOMMatrixReadOnly>>;
3011 fn FromFloat64Array(r#global: &D::GlobalScope, r#array64: CustomAutoRooterGuard<typedarray::Float64Array>, r#_can_gc: CanGc) -> Fallible<DomRoot<D::DOMMatrixReadOnly>>;
3012 fn A(&self, ) -> f64;
3013 fn B(&self, ) -> f64;
3014 fn C(&self, ) -> f64;
3015 fn D(&self, ) -> f64;
3016 fn E(&self, ) -> f64;
3017 fn F(&self, ) -> f64;
3018 fn M11(&self, ) -> f64;
3019 fn M12(&self, ) -> f64;
3020 fn M13(&self, ) -> f64;
3021 fn M14(&self, ) -> f64;
3022 fn M21(&self, ) -> f64;
3023 fn M22(&self, ) -> f64;
3024 fn M23(&self, ) -> f64;
3025 fn M24(&self, ) -> f64;
3026 fn M31(&self, ) -> f64;
3027 fn M32(&self, ) -> f64;
3028 fn M33(&self, ) -> f64;
3029 fn M34(&self, ) -> f64;
3030 fn M41(&self, ) -> f64;
3031 fn M42(&self, ) -> f64;
3032 fn M43(&self, ) -> f64;
3033 fn M44(&self, ) -> f64;
3034 fn Is2D(&self, ) -> bool;
3035 fn IsIdentity(&self, ) -> bool;
3036 fn Translate(&self, r#tx: f64, r#ty: f64, r#tz: f64, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3037 fn Scale(&self, r#scaleX: f64, r#scaleY: Option<f64>, r#scaleZ: f64, r#originX: f64, r#originY: f64, r#originZ: f64, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3038 fn ScaleNonUniform(&self, r#scaleX: f64, r#scaleY: f64, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3039 fn Scale3d(&self, r#scale: f64, r#originX: f64, r#originY: f64, r#originZ: f64, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3040 fn Rotate(&self, r#rotX: f64, r#rotY: Option<f64>, r#rotZ: Option<f64>, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3041 fn RotateFromVector(&self, r#x: f64, r#y: f64, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3042 fn RotateAxisAngle(&self, r#x: f64, r#y: f64, r#z: f64, r#angle: f64, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3043 fn SkewX(&self, r#sx: f64, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3044 fn SkewY(&self, r#sy: f64, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3045 fn Multiply(&self, r#other: &crate::codegen::GenericBindings::DOMMatrixBinding::DOMMatrixInit, r#_can_gc: CanGc) -> Fallible<DomRoot<D::DOMMatrix>>;
3046 fn FlipX(&self, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3047 fn FlipY(&self, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3048 fn Inverse(&self, r#_can_gc: CanGc) -> DomRoot<D::DOMMatrix>;
3049 fn TransformPoint(&self, r#point: &crate::codegen::GenericBindings::DOMPointBinding::DOMPointInit, r#_can_gc: CanGc) -> DomRoot<D::DOMPoint>;
3050 fn ToFloat32Array(&self, r#cx: SafeJSContext, r#_can_gc: CanGc) -> Float32Array;
3051 fn ToFloat64Array(&self, r#cx: SafeJSContext, r#_can_gc: CanGc) -> Float64Array;
3052 fn Stringifier(&self, ) -> Fallible<DOMString>;
3053 fn Constructor(r#global: &D::GlobalScope, r#proto: Option<HandleObject>, r#can_gc: CanGc, r#init: Option<GenericUnionTypes::StringOrUnrestrictedDoubleSequence>) -> Fallible<DomRoot<D::DOMMatrixReadOnly>>;
3054}
3055static sStaticMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
3056
3057pub(crate) fn init_sStaticMethods_specs<D: DomTypes>() {
3058 sStaticMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
3059 JSFunctionSpec {
3060 name: JSPropertySpec_Name { string_: c"fromMatrix".as_ptr() },
3061 call: JSNativeWrapper { op: Some(fromMatrix::<D>), info: ptr::null() },
3062 nargs: 0,
3063 flags: (JSPROP_ENUMERATE) as u16,
3064 selfHostedName: ptr::null()
3065 },
3066 JSFunctionSpec {
3067 name: JSPropertySpec_Name { string_: c"fromFloat32Array".as_ptr() },
3068 call: JSNativeWrapper { op: Some(fromFloat32Array::<D>), info: ptr::null() },
3069 nargs: 1,
3070 flags: (JSPROP_ENUMERATE) as u16,
3071 selfHostedName: ptr::null()
3072 },
3073 JSFunctionSpec {
3074 name: JSPropertySpec_Name { string_: c"fromFloat64Array".as_ptr() },
3075 call: JSNativeWrapper { op: Some(fromFloat64Array::<D>), info: ptr::null() },
3076 nargs: 1,
3077 flags: (JSPROP_ENUMERATE) as u16,
3078 selfHostedName: ptr::null()
3079 },
3080 JSFunctionSpec {
3081 name: JSPropertySpec_Name { string_: ptr::null() },
3082 call: JSNativeWrapper { op: None, info: ptr::null() },
3083 nargs: 0,
3084 flags: 0,
3085 selfHostedName: ptr::null()
3086 }]))[..]
3087])));
3088}static sStaticMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
3089
3090pub(crate) fn init_sStaticMethods_prefs<D: DomTypes>() {
3091 sStaticMethods.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticMethods_specs.get() })[0])])));
3092}static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
3093
3094pub(crate) fn init_sMethods_specs<D: DomTypes>() {
3095 sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
3096 JSFunctionSpec {
3097 name: JSPropertySpec_Name { string_: c"translate".as_ptr() },
3098 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { translate_methodinfo.get() } as *const _ as *const JSJitInfo },
3099 nargs: 0,
3100 flags: (JSPROP_ENUMERATE) as u16,
3101 selfHostedName: ptr::null()
3102 },
3103 JSFunctionSpec {
3104 name: JSPropertySpec_Name { string_: c"scale".as_ptr() },
3105 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { scale_methodinfo.get() } as *const _ as *const JSJitInfo },
3106 nargs: 0,
3107 flags: (JSPROP_ENUMERATE) as u16,
3108 selfHostedName: ptr::null()
3109 },
3110 JSFunctionSpec {
3111 name: JSPropertySpec_Name { string_: c"scaleNonUniform".as_ptr() },
3112 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { scaleNonUniform_methodinfo.get() } as *const _ as *const JSJitInfo },
3113 nargs: 0,
3114 flags: (JSPROP_ENUMERATE) as u16,
3115 selfHostedName: ptr::null()
3116 },
3117 JSFunctionSpec {
3118 name: JSPropertySpec_Name { string_: c"scale3d".as_ptr() },
3119 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { scale3d_methodinfo.get() } as *const _ as *const JSJitInfo },
3120 nargs: 0,
3121 flags: (JSPROP_ENUMERATE) as u16,
3122 selfHostedName: ptr::null()
3123 },
3124 JSFunctionSpec {
3125 name: JSPropertySpec_Name { string_: c"rotate".as_ptr() },
3126 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { rotate_methodinfo.get() } as *const _ as *const JSJitInfo },
3127 nargs: 0,
3128 flags: (JSPROP_ENUMERATE) as u16,
3129 selfHostedName: ptr::null()
3130 },
3131 JSFunctionSpec {
3132 name: JSPropertySpec_Name { string_: c"rotateFromVector".as_ptr() },
3133 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { rotateFromVector_methodinfo.get() } as *const _ as *const JSJitInfo },
3134 nargs: 0,
3135 flags: (JSPROP_ENUMERATE) as u16,
3136 selfHostedName: ptr::null()
3137 },
3138 JSFunctionSpec {
3139 name: JSPropertySpec_Name { string_: c"rotateAxisAngle".as_ptr() },
3140 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { rotateAxisAngle_methodinfo.get() } as *const _ as *const JSJitInfo },
3141 nargs: 0,
3142 flags: (JSPROP_ENUMERATE) as u16,
3143 selfHostedName: ptr::null()
3144 },
3145 JSFunctionSpec {
3146 name: JSPropertySpec_Name { string_: c"skewX".as_ptr() },
3147 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { skewX_methodinfo.get() } as *const _ as *const JSJitInfo },
3148 nargs: 0,
3149 flags: (JSPROP_ENUMERATE) as u16,
3150 selfHostedName: ptr::null()
3151 },
3152 JSFunctionSpec {
3153 name: JSPropertySpec_Name { string_: c"skewY".as_ptr() },
3154 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { skewY_methodinfo.get() } as *const _ as *const JSJitInfo },
3155 nargs: 0,
3156 flags: (JSPROP_ENUMERATE) as u16,
3157 selfHostedName: ptr::null()
3158 },
3159 JSFunctionSpec {
3160 name: JSPropertySpec_Name { string_: c"multiply".as_ptr() },
3161 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { multiply_methodinfo.get() } as *const _ as *const JSJitInfo },
3162 nargs: 0,
3163 flags: (JSPROP_ENUMERATE) as u16,
3164 selfHostedName: ptr::null()
3165 },
3166 JSFunctionSpec {
3167 name: JSPropertySpec_Name { string_: c"flipX".as_ptr() },
3168 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { flipX_methodinfo.get() } as *const _ as *const JSJitInfo },
3169 nargs: 0,
3170 flags: (JSPROP_ENUMERATE) as u16,
3171 selfHostedName: ptr::null()
3172 },
3173 JSFunctionSpec {
3174 name: JSPropertySpec_Name { string_: c"flipY".as_ptr() },
3175 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { flipY_methodinfo.get() } as *const _ as *const JSJitInfo },
3176 nargs: 0,
3177 flags: (JSPROP_ENUMERATE) as u16,
3178 selfHostedName: ptr::null()
3179 },
3180 JSFunctionSpec {
3181 name: JSPropertySpec_Name { string_: c"inverse".as_ptr() },
3182 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { inverse_methodinfo.get() } as *const _ as *const JSJitInfo },
3183 nargs: 0,
3184 flags: (JSPROP_ENUMERATE) as u16,
3185 selfHostedName: ptr::null()
3186 },
3187 JSFunctionSpec {
3188 name: JSPropertySpec_Name { string_: c"transformPoint".as_ptr() },
3189 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { transformPoint_methodinfo.get() } as *const _ as *const JSJitInfo },
3190 nargs: 0,
3191 flags: (JSPROP_ENUMERATE) as u16,
3192 selfHostedName: ptr::null()
3193 },
3194 JSFunctionSpec {
3195 name: JSPropertySpec_Name { string_: c"toFloat32Array".as_ptr() },
3196 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { toFloat32Array_methodinfo.get() } as *const _ as *const JSJitInfo },
3197 nargs: 0,
3198 flags: (JSPROP_ENUMERATE) as u16,
3199 selfHostedName: ptr::null()
3200 },
3201 JSFunctionSpec {
3202 name: JSPropertySpec_Name { string_: c"toFloat64Array".as_ptr() },
3203 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { toFloat64Array_methodinfo.get() } as *const _ as *const JSJitInfo },
3204 nargs: 0,
3205 flags: (JSPROP_ENUMERATE) as u16,
3206 selfHostedName: ptr::null()
3207 },
3208 JSFunctionSpec {
3209 name: JSPropertySpec_Name { string_: c"toJSON".as_ptr() },
3210 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { toJSON_methodinfo.get() } as *const _ as *const JSJitInfo },
3211 nargs: 0,
3212 flags: (JSPROP_ENUMERATE) as u16,
3213 selfHostedName: ptr::null()
3214 },
3215 JSFunctionSpec {
3216 name: JSPropertySpec_Name { string_: ptr::null() },
3217 call: JSNativeWrapper { op: None, info: ptr::null() },
3218 nargs: 0,
3219 flags: 0,
3220 selfHostedName: ptr::null()
3221 }]))[..]
3222,
3223&Box::leak(Box::new([
3224 JSFunctionSpec {
3225 name: JSPropertySpec_Name { string_: c"toString".as_ptr() },
3226 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { __stringifier_methodinfo.get() } as *const _ as *const JSJitInfo },
3227 nargs: 0,
3228 flags: (JSPROP_ENUMERATE) as u16,
3229 selfHostedName: ptr::null()
3230 },
3231 JSFunctionSpec {
3232 name: JSPropertySpec_Name { string_: ptr::null() },
3233 call: JSNativeWrapper { op: None, info: ptr::null() },
3234 nargs: 0,
3235 flags: 0,
3236 selfHostedName: ptr::null()
3237 }]))[..]
3238])));
3239}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
3240
3241pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
3242 sMethods.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0]),
3243 Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sMethods_specs.get() })[1])])));
3244}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
3245
3246pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
3247 sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
3248 JSPropertySpec {
3249 name: JSPropertySpec_Name { string_: c"a".as_ptr() },
3250 attributes_: (JSPROP_ENUMERATE),
3251 kind_: (JSPropertySpec_Kind::NativeAccessor),
3252 u: JSPropertySpec_AccessorsOrValue {
3253 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3254 getter: JSPropertySpec_Accessor {
3255 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { a_getterinfo.get() } },
3256 },
3257 setter: JSPropertySpec_Accessor {
3258 native: JSNativeWrapper { op: None, info: ptr::null() },
3259 }
3260 }
3261 }
3262 }
3263,
3264 JSPropertySpec {
3265 name: JSPropertySpec_Name { string_: c"b".as_ptr() },
3266 attributes_: (JSPROP_ENUMERATE),
3267 kind_: (JSPropertySpec_Kind::NativeAccessor),
3268 u: JSPropertySpec_AccessorsOrValue {
3269 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3270 getter: JSPropertySpec_Accessor {
3271 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { b_getterinfo.get() } },
3272 },
3273 setter: JSPropertySpec_Accessor {
3274 native: JSNativeWrapper { op: None, info: ptr::null() },
3275 }
3276 }
3277 }
3278 }
3279,
3280 JSPropertySpec {
3281 name: JSPropertySpec_Name { string_: c"c".as_ptr() },
3282 attributes_: (JSPROP_ENUMERATE),
3283 kind_: (JSPropertySpec_Kind::NativeAccessor),
3284 u: JSPropertySpec_AccessorsOrValue {
3285 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3286 getter: JSPropertySpec_Accessor {
3287 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { c_getterinfo.get() } },
3288 },
3289 setter: JSPropertySpec_Accessor {
3290 native: JSNativeWrapper { op: None, info: ptr::null() },
3291 }
3292 }
3293 }
3294 }
3295,
3296 JSPropertySpec {
3297 name: JSPropertySpec_Name { string_: c"d".as_ptr() },
3298 attributes_: (JSPROP_ENUMERATE),
3299 kind_: (JSPropertySpec_Kind::NativeAccessor),
3300 u: JSPropertySpec_AccessorsOrValue {
3301 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3302 getter: JSPropertySpec_Accessor {
3303 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { d_getterinfo.get() } },
3304 },
3305 setter: JSPropertySpec_Accessor {
3306 native: JSNativeWrapper { op: None, info: ptr::null() },
3307 }
3308 }
3309 }
3310 }
3311,
3312 JSPropertySpec {
3313 name: JSPropertySpec_Name { string_: c"e".as_ptr() },
3314 attributes_: (JSPROP_ENUMERATE),
3315 kind_: (JSPropertySpec_Kind::NativeAccessor),
3316 u: JSPropertySpec_AccessorsOrValue {
3317 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3318 getter: JSPropertySpec_Accessor {
3319 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { e_getterinfo.get() } },
3320 },
3321 setter: JSPropertySpec_Accessor {
3322 native: JSNativeWrapper { op: None, info: ptr::null() },
3323 }
3324 }
3325 }
3326 }
3327,
3328 JSPropertySpec {
3329 name: JSPropertySpec_Name { string_: c"f".as_ptr() },
3330 attributes_: (JSPROP_ENUMERATE),
3331 kind_: (JSPropertySpec_Kind::NativeAccessor),
3332 u: JSPropertySpec_AccessorsOrValue {
3333 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3334 getter: JSPropertySpec_Accessor {
3335 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { f_getterinfo.get() } },
3336 },
3337 setter: JSPropertySpec_Accessor {
3338 native: JSNativeWrapper { op: None, info: ptr::null() },
3339 }
3340 }
3341 }
3342 }
3343,
3344 JSPropertySpec {
3345 name: JSPropertySpec_Name { string_: c"m11".as_ptr() },
3346 attributes_: (JSPROP_ENUMERATE),
3347 kind_: (JSPropertySpec_Kind::NativeAccessor),
3348 u: JSPropertySpec_AccessorsOrValue {
3349 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3350 getter: JSPropertySpec_Accessor {
3351 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m11_getterinfo.get() } },
3352 },
3353 setter: JSPropertySpec_Accessor {
3354 native: JSNativeWrapper { op: None, info: ptr::null() },
3355 }
3356 }
3357 }
3358 }
3359,
3360 JSPropertySpec {
3361 name: JSPropertySpec_Name { string_: c"m12".as_ptr() },
3362 attributes_: (JSPROP_ENUMERATE),
3363 kind_: (JSPropertySpec_Kind::NativeAccessor),
3364 u: JSPropertySpec_AccessorsOrValue {
3365 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3366 getter: JSPropertySpec_Accessor {
3367 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m12_getterinfo.get() } },
3368 },
3369 setter: JSPropertySpec_Accessor {
3370 native: JSNativeWrapper { op: None, info: ptr::null() },
3371 }
3372 }
3373 }
3374 }
3375,
3376 JSPropertySpec {
3377 name: JSPropertySpec_Name { string_: c"m13".as_ptr() },
3378 attributes_: (JSPROP_ENUMERATE),
3379 kind_: (JSPropertySpec_Kind::NativeAccessor),
3380 u: JSPropertySpec_AccessorsOrValue {
3381 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3382 getter: JSPropertySpec_Accessor {
3383 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m13_getterinfo.get() } },
3384 },
3385 setter: JSPropertySpec_Accessor {
3386 native: JSNativeWrapper { op: None, info: ptr::null() },
3387 }
3388 }
3389 }
3390 }
3391,
3392 JSPropertySpec {
3393 name: JSPropertySpec_Name { string_: c"m14".as_ptr() },
3394 attributes_: (JSPROP_ENUMERATE),
3395 kind_: (JSPropertySpec_Kind::NativeAccessor),
3396 u: JSPropertySpec_AccessorsOrValue {
3397 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3398 getter: JSPropertySpec_Accessor {
3399 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m14_getterinfo.get() } },
3400 },
3401 setter: JSPropertySpec_Accessor {
3402 native: JSNativeWrapper { op: None, info: ptr::null() },
3403 }
3404 }
3405 }
3406 }
3407,
3408 JSPropertySpec {
3409 name: JSPropertySpec_Name { string_: c"m21".as_ptr() },
3410 attributes_: (JSPROP_ENUMERATE),
3411 kind_: (JSPropertySpec_Kind::NativeAccessor),
3412 u: JSPropertySpec_AccessorsOrValue {
3413 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3414 getter: JSPropertySpec_Accessor {
3415 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m21_getterinfo.get() } },
3416 },
3417 setter: JSPropertySpec_Accessor {
3418 native: JSNativeWrapper { op: None, info: ptr::null() },
3419 }
3420 }
3421 }
3422 }
3423,
3424 JSPropertySpec {
3425 name: JSPropertySpec_Name { string_: c"m22".as_ptr() },
3426 attributes_: (JSPROP_ENUMERATE),
3427 kind_: (JSPropertySpec_Kind::NativeAccessor),
3428 u: JSPropertySpec_AccessorsOrValue {
3429 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3430 getter: JSPropertySpec_Accessor {
3431 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m22_getterinfo.get() } },
3432 },
3433 setter: JSPropertySpec_Accessor {
3434 native: JSNativeWrapper { op: None, info: ptr::null() },
3435 }
3436 }
3437 }
3438 }
3439,
3440 JSPropertySpec {
3441 name: JSPropertySpec_Name { string_: c"m23".as_ptr() },
3442 attributes_: (JSPROP_ENUMERATE),
3443 kind_: (JSPropertySpec_Kind::NativeAccessor),
3444 u: JSPropertySpec_AccessorsOrValue {
3445 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3446 getter: JSPropertySpec_Accessor {
3447 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m23_getterinfo.get() } },
3448 },
3449 setter: JSPropertySpec_Accessor {
3450 native: JSNativeWrapper { op: None, info: ptr::null() },
3451 }
3452 }
3453 }
3454 }
3455,
3456 JSPropertySpec {
3457 name: JSPropertySpec_Name { string_: c"m24".as_ptr() },
3458 attributes_: (JSPROP_ENUMERATE),
3459 kind_: (JSPropertySpec_Kind::NativeAccessor),
3460 u: JSPropertySpec_AccessorsOrValue {
3461 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3462 getter: JSPropertySpec_Accessor {
3463 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m24_getterinfo.get() } },
3464 },
3465 setter: JSPropertySpec_Accessor {
3466 native: JSNativeWrapper { op: None, info: ptr::null() },
3467 }
3468 }
3469 }
3470 }
3471,
3472 JSPropertySpec {
3473 name: JSPropertySpec_Name { string_: c"m31".as_ptr() },
3474 attributes_: (JSPROP_ENUMERATE),
3475 kind_: (JSPropertySpec_Kind::NativeAccessor),
3476 u: JSPropertySpec_AccessorsOrValue {
3477 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3478 getter: JSPropertySpec_Accessor {
3479 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m31_getterinfo.get() } },
3480 },
3481 setter: JSPropertySpec_Accessor {
3482 native: JSNativeWrapper { op: None, info: ptr::null() },
3483 }
3484 }
3485 }
3486 }
3487,
3488 JSPropertySpec {
3489 name: JSPropertySpec_Name { string_: c"m32".as_ptr() },
3490 attributes_: (JSPROP_ENUMERATE),
3491 kind_: (JSPropertySpec_Kind::NativeAccessor),
3492 u: JSPropertySpec_AccessorsOrValue {
3493 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3494 getter: JSPropertySpec_Accessor {
3495 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m32_getterinfo.get() } },
3496 },
3497 setter: JSPropertySpec_Accessor {
3498 native: JSNativeWrapper { op: None, info: ptr::null() },
3499 }
3500 }
3501 }
3502 }
3503,
3504 JSPropertySpec {
3505 name: JSPropertySpec_Name { string_: c"m33".as_ptr() },
3506 attributes_: (JSPROP_ENUMERATE),
3507 kind_: (JSPropertySpec_Kind::NativeAccessor),
3508 u: JSPropertySpec_AccessorsOrValue {
3509 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3510 getter: JSPropertySpec_Accessor {
3511 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m33_getterinfo.get() } },
3512 },
3513 setter: JSPropertySpec_Accessor {
3514 native: JSNativeWrapper { op: None, info: ptr::null() },
3515 }
3516 }
3517 }
3518 }
3519,
3520 JSPropertySpec {
3521 name: JSPropertySpec_Name { string_: c"m34".as_ptr() },
3522 attributes_: (JSPROP_ENUMERATE),
3523 kind_: (JSPropertySpec_Kind::NativeAccessor),
3524 u: JSPropertySpec_AccessorsOrValue {
3525 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3526 getter: JSPropertySpec_Accessor {
3527 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m34_getterinfo.get() } },
3528 },
3529 setter: JSPropertySpec_Accessor {
3530 native: JSNativeWrapper { op: None, info: ptr::null() },
3531 }
3532 }
3533 }
3534 }
3535,
3536 JSPropertySpec {
3537 name: JSPropertySpec_Name { string_: c"m41".as_ptr() },
3538 attributes_: (JSPROP_ENUMERATE),
3539 kind_: (JSPropertySpec_Kind::NativeAccessor),
3540 u: JSPropertySpec_AccessorsOrValue {
3541 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3542 getter: JSPropertySpec_Accessor {
3543 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m41_getterinfo.get() } },
3544 },
3545 setter: JSPropertySpec_Accessor {
3546 native: JSNativeWrapper { op: None, info: ptr::null() },
3547 }
3548 }
3549 }
3550 }
3551,
3552 JSPropertySpec {
3553 name: JSPropertySpec_Name { string_: c"m42".as_ptr() },
3554 attributes_: (JSPROP_ENUMERATE),
3555 kind_: (JSPropertySpec_Kind::NativeAccessor),
3556 u: JSPropertySpec_AccessorsOrValue {
3557 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3558 getter: JSPropertySpec_Accessor {
3559 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m42_getterinfo.get() } },
3560 },
3561 setter: JSPropertySpec_Accessor {
3562 native: JSNativeWrapper { op: None, info: ptr::null() },
3563 }
3564 }
3565 }
3566 }
3567,
3568 JSPropertySpec {
3569 name: JSPropertySpec_Name { string_: c"m43".as_ptr() },
3570 attributes_: (JSPROP_ENUMERATE),
3571 kind_: (JSPropertySpec_Kind::NativeAccessor),
3572 u: JSPropertySpec_AccessorsOrValue {
3573 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3574 getter: JSPropertySpec_Accessor {
3575 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m43_getterinfo.get() } },
3576 },
3577 setter: JSPropertySpec_Accessor {
3578 native: JSNativeWrapper { op: None, info: ptr::null() },
3579 }
3580 }
3581 }
3582 }
3583,
3584 JSPropertySpec {
3585 name: JSPropertySpec_Name { string_: c"m44".as_ptr() },
3586 attributes_: (JSPROP_ENUMERATE),
3587 kind_: (JSPropertySpec_Kind::NativeAccessor),
3588 u: JSPropertySpec_AccessorsOrValue {
3589 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3590 getter: JSPropertySpec_Accessor {
3591 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { m44_getterinfo.get() } },
3592 },
3593 setter: JSPropertySpec_Accessor {
3594 native: JSNativeWrapper { op: None, info: ptr::null() },
3595 }
3596 }
3597 }
3598 }
3599,
3600 JSPropertySpec {
3601 name: JSPropertySpec_Name { string_: c"is2D".as_ptr() },
3602 attributes_: (JSPROP_ENUMERATE),
3603 kind_: (JSPropertySpec_Kind::NativeAccessor),
3604 u: JSPropertySpec_AccessorsOrValue {
3605 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3606 getter: JSPropertySpec_Accessor {
3607 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { is2D_getterinfo.get() } },
3608 },
3609 setter: JSPropertySpec_Accessor {
3610 native: JSNativeWrapper { op: None, info: ptr::null() },
3611 }
3612 }
3613 }
3614 }
3615,
3616 JSPropertySpec {
3617 name: JSPropertySpec_Name { string_: c"isIdentity".as_ptr() },
3618 attributes_: (JSPROP_ENUMERATE),
3619 kind_: (JSPropertySpec_Kind::NativeAccessor),
3620 u: JSPropertySpec_AccessorsOrValue {
3621 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
3622 getter: JSPropertySpec_Accessor {
3623 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { isIdentity_getterinfo.get() } },
3624 },
3625 setter: JSPropertySpec_Accessor {
3626 native: JSNativeWrapper { op: None, info: ptr::null() },
3627 }
3628 }
3629 }
3630 }
3631,
3632 JSPropertySpec::ZERO]))[..]
3633,
3634&Box::leak(Box::new([
3635 JSPropertySpec {
3636 name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
3637 attributes_: (JSPROP_READONLY),
3638 kind_: (JSPropertySpec_Kind::Value),
3639 u: JSPropertySpec_AccessorsOrValue {
3640 value: JSPropertySpec_ValueWrapper {
3641 type_: JSPropertySpec_ValueWrapper_Type::String,
3642 __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
3643 string: c"DOMMatrixReadOnly".as_ptr(),
3644 }
3645 }
3646 }
3647 }
3648,
3649 JSPropertySpec::ZERO]))[..]
3650])));
3651}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
3652
3653pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
3654 sAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
3655 Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
3656}
3657pub fn GetProtoObject<D: DomTypes>
3658(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
3659 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::DOMMatrixReadOnly), CreateInterfaceObjects::<D>, rval)
3661}
3662
3663
3664static PrototypeClass: JSClass = JSClass {
3665 name: c"DOMMatrixReadOnlyPrototype".as_ptr(),
3666 flags:
3667 (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
3669 cOps: ptr::null(),
3670 spec: ptr::null(),
3671 ext: ptr::null(),
3672 oOps: ptr::null(),
3673};
3674
3675unsafe extern "C" fn _constructor<D: DomTypes>
3676(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
3677 let mut result = false;
3678 wrap_panic(&mut || result = {
3679 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3680 let args = CallArgs::from_vp(vp, argc);
3681 let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());
3682
3683 call_default_constructor::<D>(
3684 SafeJSContext::from_ptr(cx.raw_cx()),
3685 &args,
3686 &global,
3687 PrototypeList::ID::DOMMatrixReadOnly,
3688 "DOMMatrixReadOnly",
3689 CreateInterfaceObjects::<D>,
3690 |cx: SafeJSContext, args: &CallArgs, global: &D::GlobalScope, desired_proto: HandleObject| {
3691 let arg0: Option<GenericUnionTypes::StringOrUnrestrictedDoubleSequence> = if args.get(0).is_undefined() {
3692 None
3693 } else {
3694 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3695 Ok(ConversionResult::Success(value)) => value,
3696 Ok(ConversionResult::Failure(error)) => {
3697 throw_type_error(cx.raw_cx(), &error);
3698 return false;
3699
3700 }
3701 _ => {
3702 return false;
3703
3704 },
3705 }
3706 )
3707 };
3708 let result: Result<DomRoot<D::DOMMatrixReadOnly>, Error> = <D::DOMMatrixReadOnly>::Constructor(global, Some(desired_proto), CanGc::note(), arg0);
3709 let result = match result {
3710 Ok(result) => result,
3711 Err(e) => {
3712 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
3713 return false;
3714 },
3715 };
3716
3717 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3718 return true;
3719 }
3720 )
3721
3722 });
3723 result
3724}
3725
3726
3727static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();
3728
3729pub(crate) fn init_interface_object<D: DomTypes>() {
3730 INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
3731 Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
3732 b"function DOMMatrixReadOnly() {\n [native code]\n}",
3733 PrototypeList::ID::DOMMatrixReadOnly,
3734 0,
3735 ));
3736}
3737
3738pub fn GetConstructorObject<D: DomTypes>
3739(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
3740 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::DOMMatrixReadOnly), CreateInterfaceObjects::<D>, rval)
3742}
3743
3744pub fn DefineDOMInterface<D: DomTypes>
3745(cx: SafeJSContext, global: HandleObject){
3746 define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::DOMMatrixReadOnly),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
3747}
3748
3749pub fn ConstructorEnabled<D: DomTypes>
3750(aCx: SafeJSContext, aObj: HandleObject) -> bool{
3751 is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::PAINT_WORKLET_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW)
3752}
3753
3754unsafe fn CreateInterfaceObjects<D: DomTypes>
3755(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
3756
3757 rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
3758 prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
3759 assert!(!prototype_proto.is_null());
3760
3761 rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
3762 create_interface_prototype_object::<D>(cx,
3763 global,
3764 prototype_proto.handle(),
3765 &PrototypeClass,
3766 sMethods.get(),
3767 sAttributes.get(),
3768 &[],
3769 &[],
3770 prototype.handle_mut());
3771 assert!(!prototype.is_null());
3772 assert!((*cache)[PrototypeList::ID::DOMMatrixReadOnly as usize].is_null());
3773 (*cache)[PrototypeList::ID::DOMMatrixReadOnly as usize] = prototype.get();
3774 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::DOMMatrixReadOnly as isize),
3775 ptr::null_mut(),
3776 prototype.get());
3777
3778 rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
3779 interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));
3780
3781 assert!(!interface_proto.is_null());
3782
3783 rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
3784 create_noncallback_interface_object::<D>(cx,
3785 global,
3786 interface_proto.handle(),
3787 INTERFACE_OBJECT_CLASS.get(),
3788 sStaticMethods.get(),
3789 &[],
3790 &[],
3791 prototype.handle(),
3792 c"DOMMatrixReadOnly",
3793 0,
3794 &[],
3795 interface.handle_mut());
3796 assert!(!interface.is_null());
3797
3798 assert!((*cache)[PrototypeList::Constructor::DOMMatrixReadOnly as usize].is_null());
3799 (*cache)[PrototypeList::Constructor::DOMMatrixReadOnly as usize] = interface.get();
3800 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::DOMMatrixReadOnly as isize),
3801 ptr::null_mut(),
3802 interface.get());
3803
3804}
3805
3806
3807 pub(crate) fn init_statics<D: DomTypes>() {
3808 init_interface_object::<D>();
3809 init_domjs_class::<D>();
3810 crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_translate_methodinfo::<D>();
3811crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_scale_methodinfo::<D>();
3812crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_scaleNonUniform_methodinfo::<D>();
3813crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_scale3d_methodinfo::<D>();
3814crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_rotate_methodinfo::<D>();
3815crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_rotateFromVector_methodinfo::<D>();
3816crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_rotateAxisAngle_methodinfo::<D>();
3817crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_skewX_methodinfo::<D>();
3818crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_skewY_methodinfo::<D>();
3819crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_multiply_methodinfo::<D>();
3820crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_flipX_methodinfo::<D>();
3821crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_flipY_methodinfo::<D>();
3822crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_inverse_methodinfo::<D>();
3823crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_transformPoint_methodinfo::<D>();
3824crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_toFloat32Array_methodinfo::<D>();
3825crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_toFloat64Array_methodinfo::<D>();
3826crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init___stringifier_methodinfo::<D>();
3827crate::codegen::GenericBindings::DOMMatrixReadOnlyBinding::DOMMatrixReadOnly_Binding::init_toJSON_methodinfo::<D>();
3828 init_a_getterinfo::<D>();
3829init_b_getterinfo::<D>();
3830init_c_getterinfo::<D>();
3831init_d_getterinfo::<D>();
3832init_e_getterinfo::<D>();
3833init_f_getterinfo::<D>();
3834init_m11_getterinfo::<D>();
3835init_m12_getterinfo::<D>();
3836init_m13_getterinfo::<D>();
3837init_m14_getterinfo::<D>();
3838init_m21_getterinfo::<D>();
3839init_m22_getterinfo::<D>();
3840init_m23_getterinfo::<D>();
3841init_m24_getterinfo::<D>();
3842init_m31_getterinfo::<D>();
3843init_m32_getterinfo::<D>();
3844init_m33_getterinfo::<D>();
3845init_m34_getterinfo::<D>();
3846init_m41_getterinfo::<D>();
3847init_m42_getterinfo::<D>();
3848init_m43_getterinfo::<D>();
3849init_m44_getterinfo::<D>();
3850init_is2D_getterinfo::<D>();
3851init_isIdentity_getterinfo::<D>();
3852
3853
3854 init_sStaticMethods_specs::<D>();
3855init_sStaticMethods_prefs::<D>();
3856init_sMethods_specs::<D>();
3857init_sMethods_prefs::<D>();
3858init_sAttributes_specs::<D>();
3859init_sAttributes_prefs::<D>();
3860 }
3861 }